libpostproc.hg: postprocess.c comparison

comparison postprocess.c @ 95:c24dab9bca80 libpostproc

cosmetics: Fix indentation to be 4 spaces and consistently place {}.

author	diego
date	Sat, 22 Mar 2008 15:46:34 +0000
parents	7c86da6ce78e
children	2653d9f33b8a

comparison

equal deleted inserted replaced

-:094413c45b0f
+:c24dab9bca80
 DECLARE_ASM_CONST(8, int, deringThreshold)= 20;
 static struct PPFilter filters[]=
 {
 {"hb", "hdeblock",              1, 1, 3, H_DEBLOCK},
 {"vb", "vdeblock",              1, 2, 4, V_DEBLOCK},
-/*      {"hr", "rkhdeblock",            1, 1, 3, H_RK1_FILTER},
+/*  {"hr", "rkhdeblock",            1, 1, 3, H_RK1_FILTER},
 {"vr", "rkvdeblock",            1, 2, 4, V_RK1_FILTER},*/
 {"h1", "x1hdeblock",            1, 1, 3, H_X1_FILTER},
 {"v1", "x1vdeblock",            1, 2, 4, V_X1_FILTER},
 {"ha", "ahdeblock",             1, 1, 3, H_A_DEBLOCK},
 {"va", "avdeblock",             1, 2, 4, V_A_DEBLOCK},
 {"dr", "dering",                1, 5, 6, DERING},
 {"al", "autolevels",            0, 1, 2, LEVEL_FIX},
 {"lb", "linblenddeint",         1, 1, 4, LINEAR_BLEND_DEINT_FILTER},
 {"li", "linipoldeint",          1, 1, 4, LINEAR_IPOL_DEINT_FILTER},
 {"ci", "cubicipoldeint",        1, 1, 4, CUBIC_IPOL_DEINT_FILTER},
 {"md", "mediandeint",           1, 1, 4, MEDIAN_DEINT_FILTER},
 {"fd", "ffmpegdeint",           1, 1, 4, FFMPEG_DEINT_FILTER},
 {"l5", "lowpass5",              1, 1, 4, LOWPASS5_DEINT_FILTER},
 {"tn", "tmpnoise",              1, 7, 8, TEMP_NOISE_FILTER},
 {"fq", "forcequant",            1, 0, 0, FORCE_QUANT},
 {NULL, NULL,0,0,0,0} //End Marker
 };
 static const char *replaceTable[]=
 {
 "default",      "hb:a,vb:a,dr:a",
 "de",           "hb:a,vb:a,dr:a",
 "fast",         "h1:a,v1:a,dr:a",
 "fa",           "h1:a,v1:a,dr:a",
 "ac",           "ha:a:128:7,va:a,dr:a",
 NULL //End Marker
 };
 #if defined(ARCH_X86)
 static inline void prefetchnta(void *p)
 {
 asm volatile(   "prefetchnta (%0)\n\t"
 : : "r" (p)
 );
 }
 static inline void prefetcht0(void *p)
 {
 asm volatile(   "prefetcht0 (%0)\n\t"
 : : "r" (p)
 );
 }
 static inline void prefetcht1(void *p)
 {
 asm volatile(   "prefetcht1 (%0)\n\t"
 : : "r" (p)
 );
 }
 static inline void prefetcht2(void *p)
 {
 asm volatile(   "prefetcht2 (%0)\n\t"
 : : "r" (p)
 );
 }
 #endif
 // The horizontal Functions exist only in C cuz the MMX code is faster with vertical filters and transposing
 /**
 * Check if the given 8x8 Block is mostly "flat"
 */
 static inline int isHorizDC_C(uint8_t src[], int stride, PPContext *c)
 {
 int numEq= 0;
 int y;
 const int dcOffset= ((c->nonBQP*c->ppMode.baseDcDiff)>>8) + 1;
 const int dcThreshold= dcOffset*2 + 1;
-for(y=0; y<BLOCK_SIZE; y++)
+for(y=0; y<BLOCK_SIZE; y++){
-{
+if(((unsigned)(src[0] - src[1] + dcOffset)) < dcThreshold) numEq++;
-if(((unsigned)(src[0] - src[1] + dcOffset)) < dcThreshold) numEq++;
+if(((unsigned)(src[1] - src[2] + dcOffset)) < dcThreshold) numEq++;
-if(((unsigned)(src[1] - src[2] + dcOffset)) < dcThreshold) numEq++;
+if(((unsigned)(src[2] - src[3] + dcOffset)) < dcThreshold) numEq++;
-if(((unsigned)(src[2] - src[3] + dcOffset)) < dcThreshold) numEq++;
+if(((unsigned)(src[3] - src[4] + dcOffset)) < dcThreshold) numEq++;
-if(((unsigned)(src[3] - src[4] + dcOffset)) < dcThreshold) numEq++;
+if(((unsigned)(src[4] - src[5] + dcOffset)) < dcThreshold) numEq++;
-if(((unsigned)(src[4] - src[5] + dcOffset)) < dcThreshold) numEq++;
+if(((unsigned)(src[5] - src[6] + dcOffset)) < dcThreshold) numEq++;
-if(((unsigned)(src[5] - src[6] + dcOffset)) < dcThreshold) numEq++;
+if(((unsigned)(src[6] - src[7] + dcOffset)) < dcThreshold) numEq++;
-if(((unsigned)(src[6] - src[7] + dcOffset)) < dcThreshold) numEq++;
+src+= stride;
-src+= stride;
+}
-}
+return numEq > c->ppMode.flatnessThreshold;
-return numEq > c->ppMode.flatnessThreshold;
 }
 /**
 * Check if the middle 8x8 Block in the given 8x16 block is flat
 */
-static inline int isVertDC_C(uint8_t src[], int stride, PPContext *c){
+static inline int isVertDC_C(uint8_t src[], int stride, PPContext *c)
-int numEq= 0;
+{
-int y;
+int numEq= 0;
-const int dcOffset= ((c->nonBQP*c->ppMode.baseDcDiff)>>8) + 1;
+int y;
-const int dcThreshold= dcOffset*2 + 1;
+const int dcOffset= ((c->nonBQP*c->ppMode.baseDcDiff)>>8) + 1;
+const int dcThreshold= dcOffset*2 + 1;
-src+= stride*4; // src points to begin of the 8x8 Block
-for(y=0; y<BLOCK_SIZE-1; y++)
+src+= stride*4; // src points to begin of the 8x8 Block
-{
+for(y=0; y<BLOCK_SIZE-1; y++){
 if(((unsigned)(src[0] - src[0+stride] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[1] - src[1+stride] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[2] - src[2+stride] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[3] - src[3+stride] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[4] - src[4+stride] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[5] - src[5+stride] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[6] - src[6+stride] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[7] - src[7+stride] + dcOffset)) < dcThreshold) numEq++;
 src+= stride;
 }
 return numEq > c->ppMode.flatnessThreshold;
 }
 static inline int isHorizMinMaxOk_C(uint8_t src[], int stride, int QP)
 {
 int i;
 #if 1
 for(i=0; i<2; i++){
 if((unsigned)(src[0] - src[5] + 2*QP) > 4*QP) return 0;
 src += stride;
 if((unsigned)(src[2] - src[7] + 2*QP) > 4*QP) return 0;
 src += stride;
 if((unsigned)(src[4] - src[1] + 2*QP) > 4*QP) return 0;
 src += stride;
 if((unsigned)(src[6] - src[3] + 2*QP) > 4*QP) return 0;
 src += stride;
 }
 #else
 for(i=0; i<8; i++){
 if((unsigned)(src[0] - src[7] + 2*QP) > 4*QP) return 0;
 src += stride;
 }
 #endif
 return 1;
 }
 static inline int isVertMinMaxOk_C(uint8_t src[], int stride, int QP)
 {
 #if 1
 #if 1
 int x;
 src+= stride*4;
-for(x=0; x<BLOCK_SIZE; x+=4)
+for(x=0; x<BLOCK_SIZE; x+=4){
-{
+if((unsigned)(src[  x + 0*stride] - src[  x + 5*stride] + 2*QP) > 4*QP) return 0;
-if((unsigned)(src[  x + 0*stride] - src[  x + 5*stride] + 2*QP) > 4*QP) return 0;
+if((unsigned)(src[1+x + 2*stride] - src[1+x + 7*stride] + 2*QP) > 4*QP) return 0;
-if((unsigned)(src[1+x + 2*stride] - src[1+x + 7*stride] + 2*QP) > 4*QP) return 0;
+if((unsigned)(src[2+x + 4*stride] - src[2+x + 1*stride] + 2*QP) > 4*QP) return 0;
-if((unsigned)(src[2+x + 4*stride] - src[2+x + 1*stride] + 2*QP) > 4*QP) return 0;
+if((unsigned)(src[3+x + 6*stride] - src[3+x + 3*stride] + 2*QP) > 4*QP) return 0;
-if((unsigned)(src[3+x + 6*stride] - src[3+x + 3*stride] + 2*QP) > 4*QP) return 0;
+}
-}
 #else
 int x;
 src+= stride*3;
-for(x=0; x<BLOCK_SIZE; x++)
+for(x=0; x<BLOCK_SIZE; x++){
-{
+if((unsigned)(src[x + stride] - src[x + (stride<<3)] + 2*QP) > 4*QP) return 0;
-if((unsigned)(src[x + stride] - src[x + (stride<<3)] + 2*QP) > 4*QP) return 0;
+}
-}
+#endif
-#endif
+return 1;
-return 1;
 #else
 int x;
 src+= stride*4;
-for(x=0; x<BLOCK_SIZE; x++)
+for(x=0; x<BLOCK_SIZE; x++){
-{
+int min=255;
-int min=255;
+int max=0;
-int max=0;
+int y;
-int y;
+for(y=0; y<8; y++){
-for(y=0; y<8; y++){
+int v= src[x + y*stride];
-int v= src[x + y*stride];
+if(v>max) max=v;
-if(v>max) max=v;
+if(v<min) min=v;
-if(v<min) min=v;
+}
-}
+if(max-min > 2*QP) return 0;
-if(max-min > 2*QP) return 0;
+}
-}
+return 1;
-return 1;
+#endif
-#endif
+}
-}
+static inline int horizClassify_C(uint8_t src[], int stride, PPContext *c)
-static inline int horizClassify_C(uint8_t src[], int stride, PPContext *c){
+{
 if( isHorizDC_C(src, stride, c) ){
 if( isHorizMinMaxOk_C(src, stride, c->QP) )
 return 1;
 else
 return 0;
 }else{
 return 2;
 }
 }
-static inline int vertClassify_C(uint8_t src[], int stride, PPContext *c){
+static inline int vertClassify_C(uint8_t src[], int stride, PPContext *c)
-if( isVertDC_C(src, stride, c) ){
+{
-if( isVertMinMaxOk_C(src, stride, c->QP) )
+if( isVertDC_C(src, stride, c) ){
-return 1;
+if( isVertMinMaxOk_C(src, stride, c->QP) )
-else
+return 1;
-return 0;
+else
-}else{
+return 0;
-return 2;
+}else{
-}
+return 2;
+}
 }
 static inline void doHorizDefFilter_C(uint8_t dst[], int stride, PPContext *c)
 {
 int y;
-for(y=0; y<BLOCK_SIZE; y++)
+for(y=0; y<BLOCK_SIZE; y++){
-{
+const int middleEnergy= 5*(dst[4] - dst[3]) + 2*(dst[2] - dst[5]);
-const int middleEnergy= 5*(dst[4] - dst[3]) + 2*(dst[2] - dst[5]);
+if(FFABS(middleEnergy) < 8*c->QP){
-if(FFABS(middleEnergy) < 8*c->QP)
+const int q=(dst[3] - dst[4])/2;
-{
+const int leftEnergy=  5*(dst[2] - dst[1]) + 2*(dst[0] - dst[3]);
-const int q=(dst[3] - dst[4])/2;
+const int rightEnergy= 5*(dst[6] - dst[5]) + 2*(dst[4] - dst[7]);
-const int leftEnergy=  5*(dst[2] - dst[1]) + 2*(dst[0] - dst[3]);
-const int rightEnergy= 5*(dst[6] - dst[5]) + 2*(dst[4] - dst[7]);
+int d= FFABS(middleEnergy) - FFMIN( FFABS(leftEnergy), FFABS(rightEnergy) );
+d= FFMAX(d, 0);
-int d= FFABS(middleEnergy) - FFMIN( FFABS(leftEnergy), FFABS(rightEnergy) );
-d= FFMAX(d, 0);
+d= (5*d + 32) >> 6;
+d*= FFSIGN(-middleEnergy);
-d= (5*d + 32) >> 6;
-d*= FFSIGN(-middleEnergy);
+if(q>0)
+{
-if(q>0)
+d= d<0 ? 0 : d;
-{
+d= d>q ? q : d;
-d= d<0 ? 0 : d;
+}
-d= d>q ? q : d;
+else
-}
+{
-else
+d= d>0 ? 0 : d;
-{
+d= d<q ? q : d;
-d= d>0 ? 0 : d;
+}
-d= d<q ? q : d;
-}
+dst[3]-= d;
+dst[4]+= d;
-dst[3]-= d;
+}
-dst[4]+= d;
+dst+= stride;
 }
-dst+= stride;
-}
 }
 /**
 * Do a horizontal low pass filter on the 10x8 block (dst points to middle 8x8 Block)
 * using the 9-Tap Filter (1,1,2,2,4,2,2,1,1)/16 (C version)
 */
 static inline void doHorizLowPass_C(uint8_t dst[], int stride, PPContext *c)
 {
 int y;
-for(y=0; y<BLOCK_SIZE; y++)
+for(y=0; y<BLOCK_SIZE; y++){
-{
+const int first= FFABS(dst[-1] - dst[0]) < c->QP ? dst[-1] : dst[0];
-const int first= FFABS(dst[-1] - dst[0]) < c->QP ? dst[-1] : dst[0];
+const int last= FFABS(dst[8] - dst[7]) < c->QP ? dst[8] : dst[7];
-const int last= FFABS(dst[8] - dst[7]) < c->QP ? dst[8] : dst[7];
+int sums[10];
-int sums[10];
+sums[0] = 4*first + dst[0] + dst[1] + dst[2] + 4;
-sums[0] = 4*first + dst[0] + dst[1] + dst[2] + 4;
+sums[1] = sums[0] - first  + dst[3];
-sums[1] = sums[0] - first  + dst[3];
+sums[2] = sums[1] - first  + dst[4];
-sums[2] = sums[1] - first  + dst[4];
+sums[3] = sums[2] - first  + dst[5];
-sums[3] = sums[2] - first  + dst[5];
+sums[4] = sums[3] - first  + dst[6];
-sums[4] = sums[3] - first  + dst[6];
+sums[5] = sums[4] - dst[0] + dst[7];
-sums[5] = sums[4] - dst[0] + dst[7];
+sums[6] = sums[5] - dst[1] + last;
-sums[6] = sums[5] - dst[1] + last;
+sums[7] = sums[6] - dst[2] + last;
-sums[7] = sums[6] - dst[2] + last;
+sums[8] = sums[7] - dst[3] + last;
-sums[8] = sums[7] - dst[3] + last;
+sums[9] = sums[8] - dst[4] + last;
-sums[9] = sums[8] - dst[4] + last;
+dst[0]= (sums[0] + sums[2] + 2*dst[0])>>4;
-dst[0]= (sums[0] + sums[2] + 2*dst[0])>>4;
+dst[1]= (sums[1] + sums[3] + 2*dst[1])>>4;
-dst[1]= (sums[1] + sums[3] + 2*dst[1])>>4;
+dst[2]= (sums[2] + sums[4] + 2*dst[2])>>4;
-dst[2]= (sums[2] + sums[4] + 2*dst[2])>>4;
+dst[3]= (sums[3] + sums[5] + 2*dst[3])>>4;
-dst[3]= (sums[3] + sums[5] + 2*dst[3])>>4;
+dst[4]= (sums[4] + sums[6] + 2*dst[4])>>4;
-dst[4]= (sums[4] + sums[6] + 2*dst[4])>>4;
+dst[5]= (sums[5] + sums[7] + 2*dst[5])>>4;
-dst[5]= (sums[5] + sums[7] + 2*dst[5])>>4;
+dst[6]= (sums[6] + sums[8] + 2*dst[6])>>4;
-dst[6]= (sums[6] + sums[8] + 2*dst[6])>>4;
+dst[7]= (sums[7] + sums[9] + 2*dst[7])>>4;
-dst[7]= (sums[7] + sums[9] + 2*dst[7])>>4;
+dst+= stride;
-dst+= stride;
+}
-}
 }
 /**
 * Experimental Filter 1 (Horizontal)
 * will not damage linear gradients
 * MMX2 version does correct clipping C version does not
 * not identical with the vertical one
 */
 static inline void horizX1Filter(uint8_t *src, int stride, int QP)
 {
 int y;
 static uint64_t *lut= NULL;
 if(lut==NULL)
+{
+int i;
+lut = av_malloc(256*8);
+for(i=0; i<256; i++)
 {
-int i;
+int v= i < 128 ? 2*i : 2*(i-256);
-lut = av_malloc(256*8);
-for(i=0; i<256; i++)
-{
-int v= i < 128 ? 2*i : 2*(i-256);
 /*
 //Simulate 112242211 9-Tap filter
-uint64_t a= (v/16) & 0xFF;
+uint64_t a= (v/16)  & 0xFF;
-uint64_t b= (v/8) & 0xFF;
+uint64_t b= (v/8)   & 0xFF;
-uint64_t c= (v/4) & 0xFF;
+uint64_t c= (v/4)   & 0xFF;
 uint64_t d= (3*v/8) & 0xFF;
 */
 //Simulate piecewise linear interpolation
-uint64_t a= (v/16) & 0xFF;
+uint64_t a= (v/16)   & 0xFF;
 uint64_t b= (v*3/16) & 0xFF;
 uint64_t c= (v*5/16) & 0xFF;
 uint64_t d= (7*v/16) & 0xFF;
 uint64_t A= (0x100 - a)&0xFF;
 uint64_t B= (0x100 - b)&0xFF;
 uint64_t C= (0x100 - c)&0xFF;
 uint64_t D= (0x100 - c)&0xFF;
 lut[i]   = (a<<56) | (b<<48) | (c<<40) | (d<<32) |
-(D<<24) | (C<<16) | (B<<8) | (A);
+(D<<24) | (C<<16) | (B<<8)  | (A);
 //lut[i] = (v<<32) | (v<<24);
 }
 }
-for(y=0; y<BLOCK_SIZE; y++)
+for(y=0; y<BLOCK_SIZE; y++){
-{
+int a= src[1] - src[2];
-int a= src[1] - src[2];
+int b= src[3] - src[4];
-int b= src[3] - src[4];
+int c= src[5] - src[6];
-int c= src[5] - src[6];
+int d= FFMAX(FFABS(b) - (FFABS(a) + FFABS(c))/2, 0);
-int d= FFMAX(FFABS(b) - (FFABS(a) + FFABS(c))/2, 0);
+if(d < QP){
-if(d < QP)
+int v = d * FFSIGN(-b);
-{
-int v = d * FFSIGN(-b);
+src[1] +=v/8;
+src[2] +=v/4;
-src[1] +=v/8;
+src[3] +=3*v/8;
-src[2] +=v/4;
+src[4] -=3*v/8;
-src[3] +=3*v/8;
+src[5] -=v/4;
-src[4] -=3*v/8;
+src[6] -=v/8;
-src[5] -=v/4;
+}
-src[6] -=v/8;
+src+=stride;
+}
-}
-src+=stride;
-}
 }
 /**
 * accurate deblock filter
 */
 static av_always_inline void do_a_deblock_C(uint8_t *src, int step, int stride, PPContext *c){
 int y;
 const int QP= c->QP;
 const int dcOffset= ((c->nonBQP*c->ppMode.baseDcDiff)>>8) + 1;
 const int dcThreshold= dcOffset*2 + 1;
 //START_TIMER
 src+= step*4; // src points to begin of the 8x8 Block
 for(y=0; y<8; y++){
 int numEq= 0;
 if(((unsigned)(src[-1*step] - src[0*step] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[ 0*step] - src[1*step] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[ 1*step] - src[2*step] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[ 2*step] - src[3*step] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[ 3*step] - src[4*step] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[ 4*step] - src[5*step] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[ 5*step] - src[6*step] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[ 6*step] - src[7*step] + dcOffset)) < dcThreshold) numEq++;
 if(((unsigned)(src[ 7*step] - src[8*step] + dcOffset)) < dcThreshold) numEq++;
 if(numEq > c->ppMode.flatnessThreshold){
 int min, max, x;
 if(src[0] > src[step]){
 max= src[0];
 min= src[step];
 }else{
 max= src[step];
 min= src[0];
 }
 for(x=2; x<8; x+=2){
 if(src[x*step] > src[(x+1)*step]){
 if(src[x    *step] > max) max= src[ x   *step];
 if(src[(x+1)*step] < min) min= src[(x+1)*step];
-}else{
-if(src[(x+1)*step] > max) max= src[(x+1)*step];
-if(src[ x   *step] < min) min= src[ x   *step];
-}
-}
-if(max-min < 2*QP){
-const int first= FFABS(src[-1*step] - src[0]) < QP ? src[-1*step] : src[0];
-const int last= FFABS(src[8*step] - src[7*step]) < QP ? src[8*step] : src[7*step];
-int sums[10];
-sums[0] = 4*first + src[0*step] + src[1*step] + src[2*step] + 4;
-sums[1] = sums[0] - first       + src[3*step];
-sums[2] = sums[1] - first       + src[4*step];
-sums[3] = sums[2] - first       + src[5*step];
-sums[4] = sums[3] - first       + src[6*step];
-sums[5] = sums[4] - src[0*step] + src[7*step];
-sums[6] = sums[5] - src[1*step] + last;
-sums[7] = sums[6] - src[2*step] + last;
-sums[8] = sums[7] - src[3*step] + last;
-sums[9] = sums[8] - src[4*step] + last;
-src[0*step]= (sums[0] + sums[2] + 2*src[0*step])>>4;
-src[1*step]= (sums[1] + sums[3] + 2*src[1*step])>>4;
-src[2*step]= (sums[2] + sums[4] + 2*src[2*step])>>4;
-src[3*step]= (sums[3] + sums[5] + 2*src[3*step])>>4;
-src[4*step]= (sums[4] + sums[6] + 2*src[4*step])>>4;
-src[5*step]= (sums[5] + sums[7] + 2*src[5*step])>>4;
-src[6*step]= (sums[6] + sums[8] + 2*src[6*step])>>4;
-src[7*step]= (sums[7] + sums[9] + 2*src[7*step])>>4;
-}
 }else{
-const int middleEnergy= 5*(src[4*step] - src[3*step]) + 2*(src[2*step] - src[5*step]);
+if(src[(x+1)*step] > max) max= src[(x+1)*step];
+if(src[ x   *step] < min) min= src[ x   *step];
-if(FFABS(middleEnergy) < 8*QP)
-{
-const int q=(src[3*step] - src[4*step])/2;
-const int leftEnergy=  5*(src[2*step] - src[1*step]) + 2*(src[0*step] - src[3*step]);
-const int rightEnergy= 5*(src[6*step] - src[5*step]) + 2*(src[4*step] - src[7*step]);
-int d= FFABS(middleEnergy) - FFMIN( FFABS(leftEnergy), FFABS(rightEnergy) );
-d= FFMAX(d, 0);
-d= (5*d + 32) >> 6;
-d*= FFSIGN(-middleEnergy);
-if(q>0)
-{
-d= d<0 ? 0 : d;
-d= d>q ? q : d;
-}
-else
-{
-d= d>0 ? 0 : d;
-d= d<q ? q : d;
-}
-src[3*step]-= d;
-src[4*step]+= d;
-}
 }
+}
-src += stride;
+if(max-min < 2*QP){
-}
+const int first= FFABS(src[-1*step] - src[0]) < QP ? src[-1*step] : src[0];
+const int last= FFABS(src[8*step] - src[7*step]) < QP ? src[8*step] : src[7*step];
+int sums[10];
+sums[0] = 4*first + src[0*step] + src[1*step] + src[2*step] + 4;
+sums[1] = sums[0] - first       + src[3*step];
+sums[2] = sums[1] - first       + src[4*step];
+sums[3] = sums[2] - first       + src[5*step];
+sums[4] = sums[3] - first       + src[6*step];
+sums[5] = sums[4] - src[0*step] + src[7*step];
+sums[6] = sums[5] - src[1*step] + last;
+sums[7] = sums[6] - src[2*step] + last;
+sums[8] = sums[7] - src[3*step] + last;
+sums[9] = sums[8] - src[4*step] + last;
+src[0*step]= (sums[0] + sums[2] + 2*src[0*step])>>4;
+src[1*step]= (sums[1] + sums[3] + 2*src[1*step])>>4;
+src[2*step]= (sums[2] + sums[4] + 2*src[2*step])>>4;
+src[3*step]= (sums[3] + sums[5] + 2*src[3*step])>>4;
+src[4*step]= (sums[4] + sums[6] + 2*src[4*step])>>4;
+src[5*step]= (sums[5] + sums[7] + 2*src[5*step])>>4;
+src[6*step]= (sums[6] + sums[8] + 2*src[6*step])>>4;
+src[7*step]= (sums[7] + sums[9] + 2*src[7*step])>>4;
+}
+}else{
+const int middleEnergy= 5*(src[4*step] - src[3*step]) + 2*(src[2*step] - src[5*step]);
+if(FFABS(middleEnergy) < 8*QP){
+const int q=(src[3*step] - src[4*step])/2;
+const int leftEnergy=  5*(src[2*step] - src[1*step]) + 2*(src[0*step] - src[3*step]);
+const int rightEnergy= 5*(src[6*step] - src[5*step]) + 2*(src[4*step] - src[7*step]);
+int d= FFABS(middleEnergy) - FFMIN( FFABS(leftEnergy), FFABS(rightEnergy) );
+d= FFMAX(d, 0);
+d= (5*d + 32) >> 6;
+d*= FFSIGN(-middleEnergy);
+if(q>0){
+d= d<0 ? 0 : d;
+d= d>q ? q : d;
+}else{
+d= d>0 ? 0 : d;
+d= d<q ? q : d;
+}
+src[3*step]-= d;
+src[4*step]+= d;
+}
+}
+src += stride;
+}
 /*if(step==16){
 STOP_TIMER("step16")
 }else{
 STOP_TIMER("stepX")
 }*/
 // minor note: the HAVE_xyz is messed up after that line so do not use it.
 static inline void postProcess(const uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
 const QP_STORE_T QPs[], int QPStride, int isColor, pp_mode_t *vm, pp_context_t *vc)
 {
 PPContext *c= (PPContext *)vc;
 PPMode *ppMode= (PPMode *)vm;
 c->ppMode= *ppMode; //FIXME
 // Using ifs here as they are faster than function pointers although the
 // difference would not be measurable here but it is much better because
 // someone might exchange the CPU whithout restarting MPlayer ;)
 #ifdef RUNTIME_CPUDETECT
 #if defined(ARCH_X86)
 // ordered per speed fastest first
 if(c->cpuCaps & PP_CPU_CAPS_MMX2)
 postProcess_MMX2(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 else if(c->cpuCaps & PP_CPU_CAPS_3DNOW)
 postProcess_3DNow(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 else if(c->cpuCaps & PP_CPU_CAPS_MMX)
 postProcess_MMX(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 else
 postProcess_C(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 #else
 #ifdef HAVE_ALTIVEC
 if(c->cpuCaps & PP_CPU_CAPS_ALTIVEC)
 postProcess_altivec(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 else
 #endif
 postProcess_C(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 #endif
 #else //RUNTIME_CPUDETECT
 #ifdef HAVE_MMX2
 postProcess_MMX2(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 #elif defined (HAVE_3DNOW)
 postProcess_3DNow(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 #elif defined (HAVE_MMX)
 postProcess_MMX(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 #elif defined (HAVE_ALTIVEC)
 postProcess_altivec(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 #else
 postProcess_C(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 #endif
 #endif //!RUNTIME_CPUDETECT
 }
 //static void postProcess(uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
 "\n"
 ;
 pp_mode_t *pp_get_mode_by_name_and_quality(const char *name, int quality)
 {
 char temp[GET_MODE_BUFFER_SIZE];
 char *p= temp;
 static const char filterDelimiters[] = ",/";
 static const char optionDelimiters[] = ":";
 struct PPMode *ppMode;
 char *filterToken;
 ppMode= av_malloc(sizeof(PPMode));
 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/8;
 ppMode->flatnessThreshold= 56-16-1;
 ppMode->maxClippedThreshold= 0.01;
 ppMode->error=0;
 strncpy(temp, name, GET_MODE_BUFFER_SIZE);
 av_log(NULL, AV_LOG_DEBUG, "pp: %s\n", name);
 for(;;){
 char *filterName;
 int q= 1000000; //PP_QUALITY_MAX;
 int chrom=-1;
 int luma=-1;
 char *option;
 char *options[OPTIONS_ARRAY_SIZE];
 int i;
 int filterNameOk=0;
 int numOfUnknownOptions=0;
 int enable=1; //does the user want us to enabled or disabled the filter
 filterToken= strtok(p, filterDelimiters);
 if(filterToken == NULL) break;
 p+= strlen(filterToken) + 1; // p points to next filterToken
 filterName= strtok(filterToken, optionDelimiters);
 av_log(NULL, AV_LOG_DEBUG, "pp: %s::%s\n", filterToken, filterName);
-if(*filterName == '-')
+if(*filterName == '-'){
+enable=0;
+filterName++;
+}
+for(;;){ //for all options
+option= strtok(NULL, optionDelimiters);
+if(option == NULL) break;
+av_log(NULL, AV_LOG_DEBUG, "pp: option: %s\n", option);
+if(!strcmp("autoq", option) || !strcmp("a", option)) q= quality;
+else if(!strcmp("nochrom", option) || !strcmp("y", option)) chrom=0;
+else if(!strcmp("chrom", option) || !strcmp("c", option)) chrom=1;
+else if(!strcmp("noluma", option) || !strcmp("n", option)) luma=0;
+else{
+options[numOfUnknownOptions] = option;
+numOfUnknownOptions++;
+}
+if(numOfUnknownOptions >= OPTIONS_ARRAY_SIZE-1) break;
+}
+options[numOfUnknownOptions] = NULL;
+/* replace stuff from the replace Table */
+for(i=0; replaceTable[2*i]!=NULL; i++){
+if(!strcmp(replaceTable[2*i], filterName)){
+int newlen= strlen(replaceTable[2*i + 1]);
+int plen;
+int spaceLeft;
+if(p==NULL) p= temp, *p=0;      //last filter
+else p--, *p=',';               //not last filter
+plen= strlen(p);
+spaceLeft= p - temp + plen;
+if(spaceLeft + newlen  >= GET_MODE_BUFFER_SIZE){
+ppMode->error++;
+break;
+}
+memmove(p + newlen, p, plen+1);
+memcpy(p, replaceTable[2*i + 1], newlen);
+filterNameOk=1;
+}
+}
+for(i=0; filters[i].shortName!=NULL; i++){
+if(   !strcmp(filters[i].longName, filterName)
+|| !strcmp(filters[i].shortName, filterName)){
+ppMode->lumMode &= ~filters[i].mask;
+ppMode->chromMode &= ~filters[i].mask;
+filterNameOk=1;
+if(!enable) break; // user wants to disable it
+if(q >= filters[i].minLumQuality && luma)
+ppMode->lumMode|= filters[i].mask;
+if(chrom==1 || (chrom==-1 && filters[i].chromDefault))
+if(q >= filters[i].minChromQuality)
+ppMode->chromMode|= filters[i].mask;
+if(filters[i].mask == LEVEL_FIX){
+int o;
+ppMode->minAllowedY= 16;
+ppMode->maxAllowedY= 234;
+for(o=0; options[o]!=NULL; o++){
+if(  !strcmp(options[o],"fullyrange")
+||!strcmp(options[o],"f")){
+ppMode->minAllowedY= 0;
+ppMode->maxAllowedY= 255;
+numOfUnknownOptions--;
+}
+}
+}
+else if(filters[i].mask == TEMP_NOISE_FILTER)
 {
-enable=0;
+int o;
-filterName++;
+int numOfNoises=0;
+for(o=0; options[o]!=NULL; o++){
+char *tail;
+ppMode->maxTmpNoise[numOfNoises]=
+strtol(options[o], &tail, 0);
+if(tail!=options[o]){
+numOfNoises++;
+numOfUnknownOptions--;
+if(numOfNoises >= 3) break;
+}
+}
 }
+else if(filters[i].mask == V_DEBLOCK   || filters[i].mask == H_DEBLOCK
-for(;;){ //for all options
+|| filters[i].mask == V_A_DEBLOCK || filters[i].mask == H_A_DEBLOCK){
-option= strtok(NULL, optionDelimiters);
+int o;
-if(option == NULL) break;
+for(o=0; options[o]!=NULL && o<2; o++){
-av_log(NULL, AV_LOG_DEBUG, "pp: option: %s\n", option);
+char *tail;
-if(!strcmp("autoq", option) || !strcmp("a", option)) q= quality;
+int val= strtol(options[o], &tail, 0);
-else if(!strcmp("nochrom", option) || !strcmp("y", option)) chrom=0;
+if(tail==options[o]) break;
-else if(!strcmp("chrom", option) || !strcmp("c", option)) chrom=1;
-else if(!strcmp("noluma", option) || !strcmp("n", option)) luma=0;
+numOfUnknownOptions--;
-else
+if(o==0) ppMode->baseDcDiff= val;
-{
+else ppMode->flatnessThreshold= val;
-options[numOfUnknownOptions] = option;
+}
-numOfUnknownOptions++;
-}
-if(numOfUnknownOptions >= OPTIONS_ARRAY_SIZE-1) break;
 }
-options[numOfUnknownOptions] = NULL;
+else if(filters[i].mask == FORCE_QUANT){
+int o;
-/* replace stuff from the replace Table */
+ppMode->forcedQuant= 15;
-for(i=0; replaceTable[2*i]!=NULL; i++)
-{
+for(o=0; options[o]!=NULL && o<1; o++){
-if(!strcmp(replaceTable[2*i], filterName))
+char *tail;
-{
+int val= strtol(options[o], &tail, 0);
-int newlen= strlen(replaceTable[2*i + 1]);
+if(tail==options[o]) break;
-int plen;
-int spaceLeft;
+numOfUnknownOptions--;
+ppMode->forcedQuant= val;
-if(p==NULL) p= temp, *p=0;      //last filter
+}
-else p--, *p=',';               //not last filter
-plen= strlen(p);
-spaceLeft= p - temp + plen;
-if(spaceLeft + newlen  >= GET_MODE_BUFFER_SIZE)
-{
-ppMode->error++;
-break;
-}
-memmove(p + newlen, p, plen+1);
-memcpy(p, replaceTable[2*i + 1], newlen);
-filterNameOk=1;
-}
 }
+}
-for(i=0; filters[i].shortName!=NULL; i++)
+}
-{
+if(!filterNameOk) ppMode->error++;
-if(   !strcmp(filters[i].longName, filterName)
+ppMode->error += numOfUnknownOptions;
-|| !strcmp(filters[i].shortName, filterName))
+}
-{
-ppMode->lumMode &= ~filters[i].mask;
+av_log(NULL, AV_LOG_DEBUG, "pp: lumMode=%X, chromMode=%X\n", ppMode->lumMode, ppMode->chromMode);
-ppMode->chromMode &= ~filters[i].mask;
+if(ppMode->error){
+av_log(NULL, AV_LOG_ERROR, "%d errors in postprocess string \"%s\"\n", ppMode->error, name);
-filterNameOk=1;
+av_free(ppMode);
-if(!enable) break; // user wants to disable it
+return NULL;
+}
-if(q >= filters[i].minLumQuality && luma)
+return ppMode;
-ppMode->lumMode|= filters[i].mask;
-if(chrom==1 || (chrom==-1 && filters[i].chromDefault))
-if(q >= filters[i].minChromQuality)
-ppMode->chromMode|= filters[i].mask;
-if(filters[i].mask == LEVEL_FIX)
-{
-int o;
-ppMode->minAllowedY= 16;
-ppMode->maxAllowedY= 234;
-for(o=0; options[o]!=NULL; o++)
-{
-if(  !strcmp(options[o],"fullyrange")
-||!strcmp(options[o],"f"))
-{
-ppMode->minAllowedY= 0;
-ppMode->maxAllowedY= 255;
-numOfUnknownOptions--;
-}
-}
-}
-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]=
-strtol(options[o], &tail, 0);
-if(tail!=options[o])
-{
-numOfNoises++;
-numOfUnknownOptions--;
-if(numOfNoises >= 3) break;
-}
-}
-}
-else if(filters[i].mask == V_DEBLOCK   || filters[i].mask == H_DEBLOCK
-|| filters[i].mask == V_A_DEBLOCK || filters[i].mask == H_A_DEBLOCK)
-{
-int o;
-for(o=0; options[o]!=NULL && o<2; o++)
-{
-char *tail;
-int val= strtol(options[o], &tail, 0);
-if(tail==options[o]) break;
-numOfUnknownOptions--;
-if(o==0) ppMode->baseDcDiff= val;
-else ppMode->flatnessThreshold= val;
-}
-}
-else if(filters[i].mask == FORCE_QUANT)
-{
-int o;
-ppMode->forcedQuant= 15;
-for(o=0; options[o]!=NULL && o<1; o++)
-{
-char *tail;
-int val= strtol(options[o], &tail, 0);
-if(tail==options[o]) break;
-numOfUnknownOptions--;
-ppMode->forcedQuant= val;
-}
-}
-}
-}
-if(!filterNameOk) ppMode->error++;
-ppMode->error += numOfUnknownOptions;
-}
-av_log(NULL, AV_LOG_DEBUG, "pp: lumMode=%X, chromMode=%X\n", ppMode->lumMode, ppMode->chromMode);
-if(ppMode->error)
-{
-av_log(NULL, AV_LOG_ERROR, "%d errors in postprocess string \"%s\"\n", ppMode->error, name);
-av_free(ppMode);
-return NULL;
-}
-return ppMode;
 }
 void pp_free_mode(pp_mode_t *mode){
 av_free(mode);
 }
 static void reallocAlign(void **p, int alignment, int size){
 av_free(*p);
 *p= av_mallocz(size);
 }
 static void reallocBuffers(PPContext *c, int width, int height, int stride, int qpStride){
 int mbWidth = (width+15)>>4;
 int mbHeight= (height+15)>>4;
 int i;
 c->stride= stride;
 c->qpStride= qpStride;
 reallocAlign((void **)&c->tempDst, 8, stride*24);
 reallocAlign((void **)&c->tempSrc, 8, stride*24);
 reallocAlign((void **)&c->tempBlocks, 8, 2*16*8);
 reallocAlign((void **)&c->yHistogram, 8, 256*sizeof(uint64_t));
 for(i=0; i<256; i++)
 c->yHistogram[i]= width*height/64*15/256;
-for(i=0; i<3; i++)
+for(i=0; i<3; i++){
-{
+//Note: The +17*1024 is just there so i do not have to worry about r/w over the end.
-//Note: The +17*1024 is just there so i do not have to worry about r/w over the end.
+reallocAlign((void **)&c->tempBlured[i], 8, stride*mbHeight*16 + 17*1024);
-reallocAlign((void **)&c->tempBlured[i], 8, stride*mbHeight*16 + 17*1024);
+reallocAlign((void **)&c->tempBluredPast[i], 8, 256*((height+7)&(~7))/2 + 17*1024);//FIXME size
-reallocAlign((void **)&c->tempBluredPast[i], 8, 256*((height+7)&(~7))/2 + 17*1024);//FIXME size
+}
-}
+reallocAlign((void **)&c->deintTemp, 8, 2*width+32);
-reallocAlign((void **)&c->deintTemp, 8, 2*width+32);
+reallocAlign((void **)&c->nonBQPTable, 8, qpStride*mbHeight*sizeof(QP_STORE_T));
-reallocAlign((void **)&c->nonBQPTable, 8, qpStride*mbHeight*sizeof(QP_STORE_T));
+reallocAlign((void **)&c->stdQPTable, 8, qpStride*mbHeight*sizeof(QP_STORE_T));
-reallocAlign((void **)&c->stdQPTable, 8, qpStride*mbHeight*sizeof(QP_STORE_T));
+reallocAlign((void **)&c->forcedQPTable, 8, mbWidth*sizeof(QP_STORE_T));
-reallocAlign((void **)&c->forcedQPTable, 8, mbWidth*sizeof(QP_STORE_T));
 }
 static const char * context_to_name(void * ptr) {
 return "postproc";
 }
 static const AVClass av_codec_context_class = { "Postproc", context_to_name, NULL };
 pp_context_t *pp_get_context(int width, int height, int cpuCaps){
 PPContext *c= av_malloc(sizeof(PPContext));
 int stride= (width+15)&(~15);    //assumed / will realloc if needed
 int qpStride= (width+15)/16 + 2; //assumed / will realloc if needed
 memset(c, 0, sizeof(PPContext));
 c->av_class = &av_codec_context_class;
 c->cpuCaps= cpuCaps;
 if(cpuCaps&PP_FORMAT){
 c->hChromaSubSample= cpuCaps&0x3;
 c->vChromaSubSample= (cpuCaps>>4)&0x3;
 }else{
 c->hChromaSubSample= 1;
 c->vChromaSubSample= 1;
 }
 reallocBuffers(c, width, height, stride, qpStride);
 c->frameNum=-1;
 return c;
 }
 void pp_free_context(void *vc){
 PPContext *c = (PPContext*)vc;
+int i;
+for(i=0; i<3; i++) av_free(c->tempBlured[i]);
+for(i=0; i<3; i++) av_free(c->tempBluredPast[i]);
+av_free(c->tempBlocks);
+av_free(c->yHistogram);
+av_free(c->tempDst);
+av_free(c->tempSrc);
+av_free(c->deintTemp);
+av_free(c->stdQPTable);
+av_free(c->nonBQPTable);
+av_free(c->forcedQPTable);
+memset(c, 0, sizeof(PPContext));
+av_free(c);
+}
+void  pp_postprocess(const uint8_t * src[3], const int srcStride[3],
+uint8_t * dst[3], const int dstStride[3],
+int width, int height,
+const QP_STORE_T *QP_store,  int QPStride,
+pp_mode_t *vm,  void *vc, int pict_type)
+{
+int mbWidth = (width+15)>>4;
+int mbHeight= (height+15)>>4;
+PPMode *mode = (PPMode*)vm;
+PPContext *c = (PPContext*)vc;
+int minStride= FFMAX(FFABS(srcStride[0]), FFABS(dstStride[0]));
+int absQPStride = FFABS(QPStride);
+// c->stride and c->QPStride are always positive
+if(c->stride < minStride || c->qpStride < absQPStride)
+reallocBuffers(c, width, height,
+FFMAX(minStride, c->stride),
+FFMAX(c->qpStride, absQPStride));
+if(QP_store==NULL || (mode->lumMode & FORCE_QUANT)){
 int i;
+QP_store= c->forcedQPTable;
-for(i=0; i<3; i++) av_free(c->tempBlured[i]);
+absQPStride = QPStride = 0;
-for(i=0; i<3; i++) av_free(c->tempBluredPast[i]);
+if(mode->lumMode & FORCE_QUANT)
+for(i=0; i<mbWidth; i++) c->forcedQPTable[i]= mode->forcedQuant;
-av_free(c->tempBlocks);
+else
-av_free(c->yHistogram);
+for(i=0; i<mbWidth; i++) c->forcedQPTable[i]= 1;
-av_free(c->tempDst);
+}
-av_free(c->tempSrc);
-av_free(c->deintTemp);
+if(pict_type & PP_PICT_TYPE_QP2){
-av_free(c->stdQPTable);
+int i;
-av_free(c->nonBQPTable);
+const int count= mbHeight * absQPStride;
-av_free(c->forcedQPTable);
+for(i=0; i<(count>>2); i++){
+((uint32_t*)c->stdQPTable)[i] = (((const uint32_t*)QP_store)[i]>>1) & 0x7F7F7F7F;
-memset(c, 0, sizeof(PPContext));
+}
+for(i<<=2; i<count; i++){
-av_free(c);
+c->stdQPTable[i] = QP_store[i]>>1;
 }
+QP_store= c->stdQPTable;
-void  pp_postprocess(const uint8_t * src[3], const int srcStride[3],
+QPStride= absQPStride;
-uint8_t * dst[3], const int dstStride[3],
+}
-int width, int height,
-const QP_STORE_T *QP_store,  int QPStride,
+if(0){
-pp_mode_t *vm,  void *vc, int pict_type)
+int x,y;
-{
+for(y=0; y<mbHeight; y++){
-int mbWidth = (width+15)>>4;
+for(x=0; x<mbWidth; x++){
-int mbHeight= (height+15)>>4;
+av_log(c, AV_LOG_INFO, "%2d ", QP_store[x + y*QPStride]);
-PPMode *mode = (PPMode*)vm;
+}
-PPContext *c = (PPContext*)vc;
+av_log(c, AV_LOG_INFO, "\n");
-int minStride= FFMAX(FFABS(srcStride[0]), FFABS(dstStride[0]));
+}
-int absQPStride = FFABS(QPStride);
+av_log(c, AV_LOG_INFO, "\n");
+}
-// c->stride and c->QPStride are always positive
-if(c->stride < minStride || c->qpStride < absQPStride)
+if((pict_type&7)!=3){
-reallocBuffers(c, width, height,
+if (QPStride >= 0){
-FFMAX(minStride, c->stride),
+int i;
-FFMAX(c->qpStride, absQPStride));
+const int count= mbHeight * QPStride;
+for(i=0; i<(count>>2); i++){
-if(QP_store==NULL || (mode->lumMode & FORCE_QUANT))
+((uint32_t*)c->nonBQPTable)[i] = ((const uint32_t*)QP_store)[i] & 0x3F3F3F3F;
-{
+}
-int i;
+for(i<<=2; i<count; i++){
-QP_store= c->forcedQPTable;
+c->nonBQPTable[i] = QP_store[i] & 0x3F;
-absQPStride = QPStride = 0;
+}
-if(mode->lumMode & FORCE_QUANT)
+} else {
-for(i=0; i<mbWidth; i++) c->forcedQPTable[i]= mode->forcedQuant;
+int i,j;
-else
+for(i=0; i<mbHeight; i++) {
-for(i=0; i<mbWidth; i++) c->forcedQPTable[i]= 1;
+for(j=0; j<absQPStride; j++) {
-}
+c->nonBQPTable[i*absQPStride+j] = QP_store[i*QPStride+j] & 0x3F;
-if(pict_type & PP_PICT_TYPE_QP2){
-int i;
-const int count= mbHeight * absQPStride;
-for(i=0; i<(count>>2); i++){
-((uint32_t*)c->stdQPTable)[i] = (((const uint32_t*)QP_store)[i]>>1) & 0x7F7F7F7F;
 }
-for(i<<=2; i<count; i++){
+}
-c->stdQPTable[i] = QP_store[i]>>1;
+}
 }
-QP_store= c->stdQPTable;
-QPStride= absQPStride;
+av_log(c, AV_LOG_DEBUG, "using npp filters 0x%X/0x%X\n",
-}
+mode->lumMode, mode->chromMode);
-if(0){
+postProcess(src[0], srcStride[0], dst[0], dstStride[0],
-int x,y;
-for(y=0; y<mbHeight; y++){
-for(x=0; x<mbWidth; x++){
-av_log(c, AV_LOG_INFO, "%2d ", QP_store[x + y*QPStride]);
-}
-av_log(c, AV_LOG_INFO, "\n");
-}
-av_log(c, AV_LOG_INFO, "\n");
-}
-if((pict_type&7)!=3)
-{
-if (QPStride >= 0) {
-int i;
-const int count= mbHeight * QPStride;
-for(i=0; i<(count>>2); i++){
-((uint32_t*)c->nonBQPTable)[i] = ((const uint32_t*)QP_store)[i] & 0x3F3F3F3F;
-}
-for(i<<=2; i<count; i++){
-c->nonBQPTable[i] = QP_store[i] & 0x3F;
-}
-} else {
-int i,j;
-for(i=0; i<mbHeight; i++) {
-for(j=0; j<absQPStride; j++) {
-c->nonBQPTable[i*absQPStride+j] = QP_store[i*QPStride+j] & 0x3F;
-}
-}
-}
-}
-av_log(c, AV_LOG_DEBUG, "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);
 width  = (width )>>c->hChromaSubSample;
 height = (height)>>c->vChromaSubSample;
-if(mode->chromMode)
+if(mode->chromMode){
-{
+postProcess(src[1], srcStride[1], dst[1], dstStride[1],
-postProcess(src[1], srcStride[1], dst[1], dstStride[1],
+width, height, QP_store, QPStride, 1, mode, c);
-width, height, QP_store, QPStride, 1, mode, c);
+postProcess(src[2], srcStride[2], dst[2], dstStride[2],
-postProcess(src[2], srcStride[2], dst[2], dstStride[2],
+width, height, QP_store, QPStride, 2, mode, c);
-width, height, QP_store, QPStride, 2, mode, c);
+}
-}
+else if(srcStride[1] == dstStride[1] && srcStride[2] == dstStride[2]){
-else if(srcStride[1] == dstStride[1] && srcStride[2] == dstStride[2])
+linecpy(dst[1], src[1], height, srcStride[1]);
-{
+linecpy(dst[2], src[2], height, srcStride[2]);
-linecpy(dst[1], src[1], height, srcStride[1]);
+}else{
-linecpy(dst[2], src[2], height, srcStride[2]);
+int y;
-}
+for(y=0; y<height; y++){
-else
+memcpy(&(dst[1][y*dstStride[1]]), &(src[1][y*srcStride[1]]), width);
-{
+memcpy(&(dst[2][y*dstStride[2]]), &(src[2][y*srcStride[2]]), width);
-int y;
+}
-for(y=0; y<height; y++)
+}
-{
+}
-memcpy(&(dst[1][y*dstStride[1]]), &(src[1][y*srcStride[1]]), width);
-memcpy(&(dst[2][y*dstStride[2]]), &(src[2][y*srcStride[2]]), width);
-}
-}
-}

Mercurial > libpostproc.hg

comparison postprocess.c @ 95:c24dab9bca80 libpostproc