comparison libpostproc/postprocess.c @ 793:8e9faf69110f libavcodec

cleanup

792:2d1283d511b7

c = checked against the other implementations (-vo md5)
*/

/*
TODO:
remove global/static vars
reduce the time wasted on the mem transfer
unroll stuff if instructions depend too much on the prior one
we use 8x8 blocks for the horizontal filters, opendivx seems to use 8x4?
move YScale thing to the end instead of fixing QP
write a faster and higher quality deblocking filter :)
make the mainloop more flexible (variable number of blocks at once
	(the if/else stuff per block is slowing things down)
compare the quality & speed of all filters

#include "../config.h"
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#ifdef HAVE_MALLOC_H
#include <malloc.h>
#endif
//#undef HAVE_MMX2
//#define HAVE_3DNOW

static uint64_t __attribute__((aligned(8))) b02= 		0x0202020202020202LL;
static uint64_t __attribute__((aligned(8))) b08= 		0x0808080808080808LL;
static uint64_t __attribute__((aligned(8))) b80= 		0x8080808080808080LL;
#endif

extern int divx_quality;
static int firstTime2 = 0;

extern int verbose;

int deringThreshold= 20;

//amount of "black" u r willing to loose to get a brightness corrected picture
double maxClippedThreshold= 0.01;

struct PPFilter{
	char *shortName;
	char *longName;
	int chromDefault; 	// is chrominance filtering on by default if this filter is manually activated

{
	char temp[GET_MODE_BUFFER_SIZE];
	char *p= temp;
	char *filterDelimiters= ",/";
	char *optionDelimiters= ":";
	struct PPMode ppMode= {0,0,0,0,0,{150,200,400}};
	char *filterToken;

	ppMode.flatnessThreshold= 56-16;
	
	strncpy(temp, name, GET_MODE_BUFFER_SIZE);

	if(verbose>1) printf("pp: %s\n", name);

	for(;;){

				}
				else if(filters[i].mask == TEMP_NOISE_FILTER)
				{
					int o;
					int numOfNoises=0;
					ppMode.maxTmpNoise[0]= 150;
					ppMode.maxTmpNoise[1]= 200;
					ppMode.maxTmpNoise[2]= 400;

					for(o=0; options[o]!=NULL; o++)
					{
						char *tail;
						ppMode.maxTmpNoise[numOfNoises]=

					}
				}
				else if(filters[i].mask == V_DEBLOCK || filters[i].mask == H_DEBLOCK)
				{
					int o;
					ppMode.baseDcDiff=256/4;
//					hFlatnessThreshold= 40;
//					vFlatnessThreshold= 40;

					for(o=0; options[o]!=NULL && o<2; o++)
					{
						char *tail;
						int val= strtol(options[o], &tail, 0);

	free(c->nonBQPTable);
	
	free(c);
}

//FIXME move this shit away from here
int readPPOpt(void *conf, char *arg)
{
  int val;

  if(arg == NULL)
    return -2; // ERR_MISSING_PARAM
  errno = 0;
  val = (int)strtol(arg,NULL,0);
  if(errno != 0)
    return -4;  // What about include cfgparser.h and use ERR_* defines */
  if(val < 0)
    return -3; // ERR_OUT_OF_RANGE

  divx_quality = val;
  firstTime2 = 1;

  return 1;
}
  
void revertPPOpt(void *conf, char* opt) 
{
  divx_quality=0;
}


void  pp_postprocess(uint8_t * src[3], int srcStride[3],
                 uint8_t * dst[3], int dstStride[3],
                 int width, int height,
                 QP_STORE_T *QP_store,  int QPStride,
		 PPMode *mode,  void *vc, int pict_type)

				c->nonBQPTable[y*mbWidth + x]= qscale;
			}
		}
	}

	if(firstTime2 && verbose)
	{
		printf("using npp filters 0x%X/0x%X\n", mode->lumMode, mode->chromMode);
		firstTime2=0;
	}

	postProcess(src[0], srcStride[0], dst[0], dstStride[0],
		width, height, QP_store, QPStride, 0, mode, c);

793:8e9faf69110f

c = checked against the other implementations (-vo md5)
*/

/*
TODO:
reduce the time wasted on the mem transfer
unroll stuff if instructions depend too much on the prior one
move YScale thing to the end instead of fixing QP
write a faster and higher quality deblocking filter :)
make the mainloop more flexible (variable number of blocks at once
	(the if/else stuff per block is slowing things down)
compare the quality & speed of all filters

#include "../config.h"
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef HAVE_MALLOC_H
#include <malloc.h>
#endif
//#undef HAVE_MMX2
//#define HAVE_3DNOW

static uint64_t __attribute__((aligned(8))) b02= 		0x0202020202020202LL;
static uint64_t __attribute__((aligned(8))) b08= 		0x0808080808080808LL;
static uint64_t __attribute__((aligned(8))) b80= 		0x8080808080808080LL;
#endif

static int verbose= 0;

static const int deringThreshold= 20;

struct PPFilter{
	char *shortName;
	char *longName;
	int chromDefault; 	// is chrominance filtering on by default if this filter is manually activated

{
	char temp[GET_MODE_BUFFER_SIZE];
	char *p= temp;
	char *filterDelimiters= ",/";
	char *optionDelimiters= ":";
	struct PPMode ppMode;
	char *filterToken;

	ppMode.lumMode= 0;
	ppMode.chromMode= 0;
	ppMode.maxTmpNoise[0]= 700;
	ppMode.maxTmpNoise[1]= 1500;
	ppMode.maxTmpNoise[2]= 3000;
	ppMode.maxAllowedY= 234;
	ppMode.minAllowedY= 16;
	ppMode.baseDcDiff= 256/4;
	ppMode.flatnessThreshold=40;
	ppMode.flatnessThreshold= 56-16;
	ppMode.maxClippedThreshold= 0.01;

	strncpy(temp, name, GET_MODE_BUFFER_SIZE);

	if(verbose>1) printf("pp: %s\n", name);

	for(;;){

				}
				else if(filters[i].mask == TEMP_NOISE_FILTER)
				{
					int o;
					int numOfNoises=0;

					for(o=0; options[o]!=NULL; o++)
					{
						char *tail;
						ppMode.maxTmpNoise[numOfNoises]=

					}
				}
				else if(filters[i].mask == V_DEBLOCK || filters[i].mask == H_DEBLOCK)
				{
					int o;

					for(o=0; options[o]!=NULL && o<2; o++)
					{
						char *tail;
						int val= strtol(options[o], &tail, 0);

	free(c->nonBQPTable);
	
	free(c);
}

void  pp_postprocess(uint8_t * src[3], int srcStride[3],
                 uint8_t * dst[3], int dstStride[3],
                 int width, int height,
                 QP_STORE_T *QP_store,  int QPStride,
		 PPMode *mode,  void *vc, int pict_type)

				c->nonBQPTable[y*mbWidth + x]= qscale;
			}
		}
	}

	if(verbose>2)
	{
		printf("using npp filters 0x%X/0x%X\n", mode->lumMode, mode->chromMode);
	}

	postProcess(src[0], srcStride[0], dst[0], dstStride[0],
		width, height, QP_store, QPStride, 0, mode, c);