libpostproc/postprocess.c

   1 /*
   2  * Copyright (C) 2001-2003 Michael Niedermayer (michaelni@gmx.at)
   3  *
   4  * AltiVec optimizations (C) 2004 Romain Dolbeau <romain@dolbeau.org>
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /**
  24  * @file postprocess.c
  25  * postprocessing.
  26  */
  27
  28 /*
  29                         C       MMX     MMX2    3DNow   AltiVec
  30 isVertDC                Ec      Ec                      Ec
  31 isVertMinMaxOk          Ec      Ec                      Ec
  32 doVertLowPass           E               e       e       Ec
  33 doVertDefFilter         Ec      Ec      e       e       Ec
  34 isHorizDC               Ec      Ec                      Ec
  35 isHorizMinMaxOk         a       E                       Ec
  36 doHorizLowPass          E               e       e       Ec
  37 doHorizDefFilter        Ec      Ec      e       e       Ec
  38 do_a_deblock            Ec      E       Ec      E
  39 deRing                  E               e       e*      Ecp
  40 Vertical RKAlgo1        E               a       a
  41 Horizontal RKAlgo1                      a       a
  42 Vertical X1#            a               E       E
  43 Horizontal X1#          a               E       E
  44 LinIpolDeinterlace      e               E       E*
  45 CubicIpolDeinterlace    a               e       e*
  46 LinBlendDeinterlace     e               E       E*
  47 MedianDeinterlace#      E       Ec      Ec
  48 TempDeNoiser#           E               e       e       Ec
  49
  50 * i dont have a 3dnow CPU -> its untested, but noone said it doesnt work so it seems to work
  51 # more or less selfinvented filters so the exactness isnt too meaningfull
  52 E = Exact implementation
  53 e = allmost exact implementation (slightly different rounding,...)
  54 a = alternative / approximate impl
  55 c = checked against the other implementations (-vo md5)
  56 p = partially optimized, still some work to do
  57 */
  58
  59 /*
  60 TODO:
  61 reduce the time wasted on the mem transfer
  62 unroll stuff if instructions depend too much on the prior one
  63 move YScale thing to the end instead of fixing QP
  64 write a faster and higher quality deblocking filter :)
  65 make the mainloop more flexible (variable number of blocks at once
  66         (the if/else stuff per block is slowing things down)
  67 compare the quality & speed of all filters
  68 split this huge file
  69 optimize c versions
  70 try to unroll inner for(x=0 ... loop to avoid these damn if(x ... checks
  71 ...
  72 */
  73
  74 //Changelog: use the Subversion log
  75
  76 #include "config.h"
  77 #include "avutil.h"
  78 #include <inttypes.h>
  79 #include <stdio.h>
  80 #include <stdlib.h>
  81 #include <string.h>
  82 #ifdef HAVE_MALLOC_H
  83 #include <malloc.h>
  84 #endif
  85 //#undef HAVE_MMX2
  86 //#define HAVE_3DNOW
  87 //#undef HAVE_MMX
  88 //#undef ARCH_X86
  89 //#define DEBUG_BRIGHTNESS
  90 #ifdef USE_FASTMEMCPY
  91 #include "libvo/fastmemcpy.h"
  92 #endif
  93 #include "postprocess.h"
  94 #include "postprocess_internal.h"
  95
  96 #include "mangle.h" //FIXME should be supressed
  97
  98 #ifdef HAVE_ALTIVEC_H
  99 #include <altivec.h>
 100 #endif
 101
 102 #define GET_MODE_BUFFER_SIZE 500
 103 #define OPTIONS_ARRAY_SIZE 10
 104 #define BLOCK_SIZE 8
 105 #define TEMP_STRIDE 8
 106 //#define NUM_BLOCKS_AT_ONCE 16 //not used yet
 107
 108 #if defined(ARCH_X86) || defined(ARCH_X86_64)
 109 static uint64_t __attribute__((aligned(8))) attribute_used w05= 0x0005000500050005LL;
 110 static uint64_t __attribute__((aligned(8))) attribute_used w04= 0x0004000400040004LL;
 111 static uint64_t __attribute__((aligned(8))) attribute_used w20= 0x0020002000200020LL;
 112 static uint64_t __attribute__((aligned(8))) attribute_used b00= 0x0000000000000000LL;
 113 static uint64_t __attribute__((aligned(8))) attribute_used b01= 0x0101010101010101LL;
 114 static uint64_t __attribute__((aligned(8))) attribute_used b02= 0x0202020202020202LL;
 115 static uint64_t __attribute__((aligned(8))) attribute_used b08= 0x0808080808080808LL;
 116 static uint64_t __attribute__((aligned(8))) attribute_used b80= 0x8080808080808080LL;
 117 #endif
 118
 119 static uint8_t clip_table[3*256];
 120 static uint8_t * const clip_tab= clip_table + 256;
 121
 122 static const int attribute_used deringThreshold= 20;
 123
 124
 125 static struct PPFilter filters[]=
 126 {
 127         {"hb", "hdeblock",              1, 1, 3, H_DEBLOCK},
 128         {"vb", "vdeblock",              1, 2, 4, V_DEBLOCK},
 129 /*      {"hr", "rkhdeblock",            1, 1, 3, H_RK1_FILTER},
 130         {"vr", "rkvdeblock",            1, 2, 4, V_RK1_FILTER},*/
 131         {"h1", "x1hdeblock",            1, 1, 3, H_X1_FILTER},
 132         {"v1", "x1vdeblock",            1, 2, 4, V_X1_FILTER},
 133         {"ha", "ahdeblock",             1, 1, 3, H_A_DEBLOCK},
 134         {"va", "avdeblock",             1, 2, 4, V_A_DEBLOCK},
 135         {"dr", "dering",                1, 5, 6, DERING},
 136         {"al", "autolevels",            0, 1, 2, LEVEL_FIX},
 137         {"lb", "linblenddeint",         1, 1, 4, LINEAR_BLEND_DEINT_FILTER},
 138         {"li", "linipoldeint",          1, 1, 4, LINEAR_IPOL_DEINT_FILTER},
 139         {"ci", "cubicipoldeint",        1, 1, 4, CUBIC_IPOL_DEINT_FILTER},
 140         {"md", "mediandeint",           1, 1, 4, MEDIAN_DEINT_FILTER},
 141         {"fd", "ffmpegdeint",           1, 1, 4, FFMPEG_DEINT_FILTER},
 142         {"l5", "lowpass5",              1, 1, 4, LOWPASS5_DEINT_FILTER},
 143         {"tn", "tmpnoise",              1, 7, 8, TEMP_NOISE_FILTER},
 144         {"fq", "forcequant",            1, 0, 0, FORCE_QUANT},
 145         {NULL, NULL,0,0,0,0} //End Marker
 146 };
 147
 148 static const char *replaceTable[]=
 149 {
 150         "default",      "hdeblock:a,vdeblock:a,dering:a",
 151         "de",           "hdeblock:a,vdeblock:a,dering:a",
 152         "fast",         "x1hdeblock:a,x1vdeblock:a,dering:a",
 153         "fa",           "x1hdeblock:a,x1vdeblock:a,dering:a",
 154         "ac",           "ha:a:128:7,va:a,dering:a",
 155         NULL //End Marker
 156 };
 157
 158
 159 #if defined(ARCH_X86) || defined(ARCH_X86_64)
 160 static inline void prefetchnta(void *p)
 161 {
 162         asm volatile(   "prefetchnta (%0)\n\t"
 163                 : : "r" (p)
 164         );
 165 }
 166
 167 static inline void prefetcht0(void *p)
 168 {
 169         asm volatile(   "prefetcht0 (%0)\n\t"
 170                 : : "r" (p)
 171         );
 172 }
 173
 174 static inline void prefetcht1(void *p)
 175 {
 176         asm volatile(   "prefetcht1 (%0)\n\t"
 177                 : : "r" (p)
 178         );
 179 }
 180
 181 static inline void prefetcht2(void *p)
 182 {
 183         asm volatile(   "prefetcht2 (%0)\n\t"
 184                 : : "r" (p)
 185         );
 186 }
 187 #endif
 188
 189 // The horizontal Functions exist only in C cuz the MMX code is faster with vertical filters and transposing
 190
 191 /**
 192  * Check if the given 8x8 Block is mostly "flat"
 193  */
 194 static inline int isHorizDC_C(uint8_t src[], int stride, PPContext *c)
 195 {
 196         int numEq= 0;
 197         int y;
 198         const int dcOffset= ((c->nonBQP*c->ppMode.baseDcDiff)>>8) + 1;
 199         const int dcThreshold= dcOffset*2 + 1;
 200
 201         for(y=0; y<BLOCK_SIZE; y++)
 202         {
 203                 if(((unsigned)(src[0] - src[1] + dcOffset)) < dcThreshold) numEq++;
 204                 if(((unsigned)(src[1] - src[2] + dcOffset)) < dcThreshold) numEq++;
 205                 if(((unsigned)(src[2] - src[3] + dcOffset)) < dcThreshold) numEq++;
 206                 if(((unsigned)(src[3] - src[4] + dcOffset)) < dcThreshold) numEq++;
 207                 if(((unsigned)(src[4] - src[5] + dcOffset)) < dcThreshold) numEq++;
 208                 if(((unsigned)(src[5] - src[6] + dcOffset)) < dcThreshold) numEq++;
 209                 if(((unsigned)(src[6] - src[7] + dcOffset)) < dcThreshold) numEq++;
 210                 src+= stride;
 211         }
 212         return numEq > c->ppMode.flatnessThreshold;
 213 }
 214
 215 /**
 216  * Check if the middle 8x8 Block in the given 8x16 block is flat
 217  */
 218 static inline int isVertDC_C(uint8_t src[], int stride, PPContext *c){
 219         int numEq= 0;
 220         int y;
 221         const int dcOffset= ((c->nonBQP*c->ppMode.baseDcDiff)>>8) + 1;
 222         const int dcThreshold= dcOffset*2 + 1;
 223
 224         src+= stride*4; // src points to begin of the 8x8 Block
 225         for(y=0; y<BLOCK_SIZE-1; y++)
 226         {
 227                 if(((unsigned)(src[0] - src[0+stride] + dcOffset)) < dcThreshold) numEq++;
 228                 if(((unsigned)(src[1] - src[1+stride] + dcOffset)) < dcThreshold) numEq++;
 229                 if(((unsigned)(src[2] - src[2+stride] + dcOffset)) < dcThreshold) numEq++;
 230                 if(((unsigned)(src[3] - src[3+stride] + dcOffset)) < dcThreshold) numEq++;
 231                 if(((unsigned)(src[4] - src[4+stride] + dcOffset)) < dcThreshold) numEq++;
 232                 if(((unsigned)(src[5] - src[5+stride] + dcOffset)) < dcThreshold) numEq++;
 233                 if(((unsigned)(src[6] - src[6+stride] + dcOffset)) < dcThreshold) numEq++;
 234                 if(((unsigned)(src[7] - src[7+stride] + dcOffset)) < dcThreshold) numEq++;
 235                 src+= stride;
 236         }
 237         return numEq > c->ppMode.flatnessThreshold;
 238 }
 239
 240 static inline int isHorizMinMaxOk_C(uint8_t src[], int stride, int QP)
 241 {
 242         int i;
 243 #if 1
 244         for(i=0; i<2; i++){
 245                 if((unsigned)(src[0] - src[5] + 2*QP) > 4*QP) return 0;
 246                 src += stride;
 247                 if((unsigned)(src[2] - src[7] + 2*QP) > 4*QP) return 0;
 248                 src += stride;
 249                 if((unsigned)(src[4] - src[1] + 2*QP) > 4*QP) return 0;
 250                 src += stride;
 251                 if((unsigned)(src[6] - src[3] + 2*QP) > 4*QP) return 0;
 252                 src += stride;
 253         }
 254 #else
 255         for(i=0; i<8; i++){
 256                 if((unsigned)(src[0] - src[7] + 2*QP) > 4*QP) return 0;
 257                 src += stride;
 258         }
 259 #endif
 260         return 1;
 261 }
 262
 263 static inline int isVertMinMaxOk_C(uint8_t src[], int stride, int QP)
 264 {
 265 #if 1
 266 #if 1
 267         int x;
 268         src+= stride*4;
 269         for(x=0; x<BLOCK_SIZE; x+=4)
 270         {
 271                 if((unsigned)(src[  x + 0*stride] - src[  x + 5*stride] + 2*QP) > 4*QP) return 0;
 272                 if((unsigned)(src[1+x + 2*stride] - src[1+x + 7*stride] + 2*QP) > 4*QP) return 0;
 273                 if((unsigned)(src[2+x + 4*stride] - src[2+x + 1*stride] + 2*QP) > 4*QP) return 0;
 274                 if((unsigned)(src[3+x + 6*stride] - src[3+x + 3*stride] + 2*QP) > 4*QP) return 0;
 275         }
 276 #else
 277         int x;
 278         src+= stride*3;
 279         for(x=0; x<BLOCK_SIZE; x++)
 280         {
 281                 if((unsigned)(src[x + stride] - src[x + (stride<<3)] + 2*QP) > 4*QP) return 0;
 282         }
 283 #endif
 284         return 1;
 285 #else
 286         int x;
 287         src+= stride*4;
 288         for(x=0; x<BLOCK_SIZE; x++)
 289         {
 290                 int min=255;
 291                 int max=0;
 292                 int y;
 293                 for(y=0; y<8; y++){
 294                         int v= src[x + y*stride];
 295                         if(v>max) max=v;
 296                         if(v<min) min=v;
 297                 }
 298                 if(max-min > 2*QP) return 0;
 299         }
 300         return 1;
 301 #endif
 302 }
 303
 304 static inline int horizClassify_C(uint8_t src[], int stride, PPContext *c){
 305         if( isHorizDC_C(src, stride, c) ){
 306                 if( isHorizMinMaxOk_C(src, stride, c->QP) )
 307                         return 1;
 308                 else
 309                         return 0;
 310         }else{
 311                 return 2;
 312         }
 313 }
 314
 315 static inline int vertClassify_C(uint8_t src[], int stride, PPContext *c){
 316         if( isVertDC_C(src, stride, c) ){
 317                 if( isVertMinMaxOk_C(src, stride, c->QP) )
 318                         return 1;
 319                 else
 320                         return 0;
 321         }else{
 322                 return 2;
 323         }
 324 }
 325
 326 static inline void doHorizDefFilter_C(uint8_t dst[], int stride, PPContext *c)
 327 {
 328         int y;
 329         for(y=0; y<BLOCK_SIZE; y++)
 330         {
 331                 const int middleEnergy= 5*(dst[4] - dst[3]) + 2*(dst[2] - dst[5]);
 332
 333                 if(FFABS(middleEnergy) < 8*c->QP)
 334                 {
 335                         const int q=(dst[3] - dst[4])/2;
 336                         const int leftEnergy=  5*(dst[2] - dst[1]) + 2*(dst[0] - dst[3]);
 337                         const int rightEnergy= 5*(dst[6] - dst[5]) + 2*(dst[4] - dst[7]);
 338
 339                         int d= FFABS(middleEnergy) - FFMIN( FFABS(leftEnergy), FFABS(rightEnergy) );
 340                         d= FFMAX(d, 0);
 341
 342                         d= (5*d + 32) >> 6;
 343                         d*= FFSIGN(-middleEnergy);
 344
 345                         if(q>0)
 346                         {
 347                                 d= d<0 ? 0 : d;
 348                                 d= d>q ? q : d;
 349                         }
 350                         else
 351                         {
 352                                 d= d>0 ? 0 : d;
 353                                 d= d<q ? q : d;
 354                         }
 355
 356                         dst[3]-= d;
 357                         dst[4]+= d;
 358                 }
 359                 dst+= stride;
 360         }
 361 }
 362
 363 /**
 364  * Do a horizontal low pass filter on the 10x8 block (dst points to middle 8x8 Block)
 365  * using the 9-Tap Filter (1,1,2,2,4,2,2,1,1)/16 (C version)
 366  */
 367 static inline void doHorizLowPass_C(uint8_t dst[], int stride, PPContext *c)
 368 {
 369         int y;
 370         for(y=0; y<BLOCK_SIZE; y++)
 371         {
 372                 const int first= FFABS(dst[-1] - dst[0]) < c->QP ? dst[-1] : dst[0];
 373                 const int last= FFABS(dst[8] - dst[7]) < c->QP ? dst[8] : dst[7];
 374
 375                 int sums[10];
 376                 sums[0] = 4*first + dst[0] + dst[1] + dst[2] + 4;
 377                 sums[1] = sums[0] - first  + dst[3];
 378                 sums[2] = sums[1] - first  + dst[4];
 379                 sums[3] = sums[2] - first  + dst[5];
 380                 sums[4] = sums[3] - first  + dst[6];
 381                 sums[5] = sums[4] - dst[0] + dst[7];
 382                 sums[6] = sums[5] - dst[1] + last;
 383                 sums[7] = sums[6] - dst[2] + last;
 384                 sums[8] = sums[7] - dst[3] + last;
 385                 sums[9] = sums[8] - dst[4] + last;
 386
 387                 dst[0]= (sums[0] + sums[2] + 2*dst[0])>>4;
 388                 dst[1]= (sums[1] + sums[3] + 2*dst[1])>>4;
 389                 dst[2]= (sums[2] + sums[4] + 2*dst[2])>>4;
 390                 dst[3]= (sums[3] + sums[5] + 2*dst[3])>>4;
 391                 dst[4]= (sums[4] + sums[6] + 2*dst[4])>>4;
 392                 dst[5]= (sums[5] + sums[7] + 2*dst[5])>>4;
 393                 dst[6]= (sums[6] + sums[8] + 2*dst[6])>>4;
 394                 dst[7]= (sums[7] + sums[9] + 2*dst[7])>>4;
 395
 396                 dst+= stride;
 397         }
 398 }
 399
 400 /**
 401  * Experimental Filter 1 (Horizontal)
 402  * will not damage linear gradients
 403  * Flat blocks should look like they where passed through the (1,1,2,2,4,2,2,1,1) 9-Tap filter
 404  * can only smooth blocks at the expected locations (it cant smooth them if they did move)
 405  * MMX2 version does correct clipping C version doesnt
 406  * not identical with the vertical one
 407  */
 408 static inline void horizX1Filter(uint8_t *src, int stride, int QP)
 409 {
 410         int y;
 411         static uint64_t *lut= NULL;
 412         if(lut==NULL)
 413         {
 414                 int i;
 415                 lut = av_malloc(256*8);
 416                 for(i=0; i<256; i++)
 417                 {
 418                         int v= i < 128 ? 2*i : 2*(i-256);
 419 /*
 420 //Simulate 112242211 9-Tap filter
 421                         uint64_t a= (v/16) & 0xFF;
 422                         uint64_t b= (v/8) & 0xFF;
 423                         uint64_t c= (v/4) & 0xFF;
 424                         uint64_t d= (3*v/8) & 0xFF;
 425 */
 426 //Simulate piecewise linear interpolation
 427                         uint64_t a= (v/16) & 0xFF;
 428                         uint64_t b= (v*3/16) & 0xFF;
 429                         uint64_t c= (v*5/16) & 0xFF;
 430                         uint64_t d= (7*v/16) & 0xFF;
 431                         uint64_t A= (0x100 - a)&0xFF;
 432                         uint64_t B= (0x100 - b)&0xFF;
 433                         uint64_t C= (0x100 - c)&0xFF;
 434                         uint64_t D= (0x100 - c)&0xFF;
 435
 436                         lut[i]   = (a<<56) | (b<<48) | (c<<40) | (d<<32) |
 437                                 (D<<24) | (C<<16) | (B<<8) | (A);
 438                         //lut[i] = (v<<32) | (v<<24);
 439                 }
 440         }
 441
 442         for(y=0; y<BLOCK_SIZE; y++)
 443         {
 444                 int a= src[1] - src[2];
 445                 int b= src[3] - src[4];
 446                 int c= src[5] - src[6];
 447
 448                 int d= FFMAX(FFABS(b) - (FFABS(a) + FFABS(c))/2, 0);
 449
 450                 if(d < QP)
 451                 {
 452                         int v = d * FFSIGN(-b);
 453
 454                         src[1] +=v/8;
 455                         src[2] +=v/4;
 456                         src[3] +=3*v/8;
 457                         src[4] -=3*v/8;
 458                         src[5] -=v/4;
 459                         src[6] -=v/8;
 460
 461                 }
 462                 src+=stride;
 463         }
 464 }
 465
 466 /**
 467  * accurate deblock filter
 468  */
 469 static always_inline void do_a_deblock_C(uint8_t *src, int step, int stride, PPContext *c){
 470         int y;
 471         const int QP= c->QP;
 472         const int dcOffset= ((c->nonBQP*c->ppMode.baseDcDiff)>>8) + 1;
 473         const int dcThreshold= dcOffset*2 + 1;
 474 //START_TIMER
 475         src+= step*4; // src points to begin of the 8x8 Block
 476         for(y=0; y<8; y++){
 477                 int numEq= 0;
 478
 479                 if(((unsigned)(src[-1*step] - src[0*step] + dcOffset)) < dcThreshold) numEq++;
 480                 if(((unsigned)(src[ 0*step] - src[1*step] + dcOffset)) < dcThreshold) numEq++;
 481                 if(((unsigned)(src[ 1*step] - src[2*step] + dcOffset)) < dcThreshold) numEq++;
 482                 if(((unsigned)(src[ 2*step] - src[3*step] + dcOffset)) < dcThreshold) numEq++;
 483                 if(((unsigned)(src[ 3*step] - src[4*step] + dcOffset)) < dcThreshold) numEq++;
 484                 if(((unsigned)(src[ 4*step] - src[5*step] + dcOffset)) < dcThreshold) numEq++;
 485                 if(((unsigned)(src[ 5*step] - src[6*step] + dcOffset)) < dcThreshold) numEq++;
 486                 if(((unsigned)(src[ 6*step] - src[7*step] + dcOffset)) < dcThreshold) numEq++;
 487                 if(((unsigned)(src[ 7*step] - src[8*step] + dcOffset)) < dcThreshold) numEq++;
 488                 if(numEq > c->ppMode.flatnessThreshold){
 489                         int min, max, x;
 490
 491                         if(src[0] > src[step]){
 492                             max= src[0];
 493                             min= src[step];
 494                         }else{
 495                             max= src[step];
 496                             min= src[0];
 497                         }
 498                         for(x=2; x<8; x+=2){
 499                                 if(src[x*step] > src[(x+1)*step]){
 500                                         if(src[x    *step] > max) max= src[ x   *step];
 501                                         if(src[(x+1)*step] < min) min= src[(x+1)*step];
 502                                 }else{
 503                                         if(src[(x+1)*step] > max) max= src[(x+1)*step];
 504                                         if(src[ x   *step] < min) min= src[ x   *step];
 505                                 }
 506                         }
 507                         if(max-min < 2*QP){
 508                                 const int first= FFABS(src[-1*step] - src[0]) < QP ? src[-1*step] : src[0];
 509                                 const int last= FFABS(src[8*step] - src[7*step]) < QP ? src[8*step] : src[7*step];
 510
 511                                 int sums[10];
 512                                 sums[0] = 4*first + src[0*step] + src[1*step] + src[2*step] + 4;
 513                                 sums[1] = sums[0] - first       + src[3*step];
 514                                 sums[2] = sums[1] - first       + src[4*step];
 515                                 sums[3] = sums[2] - first       + src[5*step];
 516                                 sums[4] = sums[3] - first       + src[6*step];
 517                                 sums[5] = sums[4] - src[0*step] + src[7*step];
 518                                 sums[6] = sums[5] - src[1*step] + last;
 519                                 sums[7] = sums[6] - src[2*step] + last;
 520                                 sums[8] = sums[7] - src[3*step] + last;
 521                                 sums[9] = sums[8] - src[4*step] + last;
 522
 523                                 src[0*step]= (sums[0] + sums[2] + 2*src[0*step])>>4;
 524                                 src[1*step]= (sums[1] + sums[3] + 2*src[1*step])>>4;
 525                                 src[2*step]= (sums[2] + sums[4] + 2*src[2*step])>>4;
 526                                 src[3*step]= (sums[3] + sums[5] + 2*src[3*step])>>4;
 527                                 src[4*step]= (sums[4] + sums[6] + 2*src[4*step])>>4;
 528                                 src[5*step]= (sums[5] + sums[7] + 2*src[5*step])>>4;
 529                                 src[6*step]= (sums[6] + sums[8] + 2*src[6*step])>>4;
 530                                 src[7*step]= (sums[7] + sums[9] + 2*src[7*step])>>4;
 531                         }
 532                 }else{
 533                         const int middleEnergy= 5*(src[4*step] - src[3*step]) + 2*(src[2*step] - src[5*step]);
 534
 535                         if(FFABS(middleEnergy) < 8*QP)
 536                         {
 537                                 const int q=(src[3*step] - src[4*step])/2;
 538                                 const int leftEnergy=  5*(src[2*step] - src[1*step]) + 2*(src[0*step] - src[3*step]);
 539                                 const int rightEnergy= 5*(src[6*step] - src[5*step]) + 2*(src[4*step] - src[7*step]);
 540
 541                                 int d= FFABS(middleEnergy) - FFMIN( FFABS(leftEnergy), FFABS(rightEnergy) );
 542                                 d= FFMAX(d, 0);
 543
 544                                 d= (5*d + 32) >> 6;
 545                                 d*= FFSIGN(-middleEnergy);
 546
 547                                 if(q>0)
 548                                 {
 549                                         d= d<0 ? 0 : d;
 550                                         d= d>q ? q : d;
 551                                 }
 552                                 else
 553                                 {
 554                                         d= d>0 ? 0 : d;
 555                                         d= d<q ? q : d;
 556                                 }
 557
 558                                 src[3*step]-= d;
 559                                 src[4*step]+= d;
 560                         }
 561                 }
 562
 563                 src += stride;
 564         }
 565 /*if(step==16){
 566     STOP_TIMER("step16")
 567 }else{
 568     STOP_TIMER("stepX")
 569 }*/
 570 }
 571
 572 //Note: we have C, MMX, MMX2, 3DNOW version there is no 3DNOW+MMX2 one
 573 //Plain C versions
 574 #if !defined (HAVE_MMX) || defined (RUNTIME_CPUDETECT)
 575 #define COMPILE_C
 576 #endif
 577
 578 #ifdef ARCH_POWERPC
 579 #ifdef HAVE_ALTIVEC
 580 #define COMPILE_ALTIVEC
 581 #endif //HAVE_ALTIVEC
 582 #endif //ARCH_POWERPC
 583
 584 #if defined(ARCH_X86) || defined(ARCH_X86_64)
 585
 586 #if (defined (HAVE_MMX) && !defined (HAVE_3DNOW) && !defined (HAVE_MMX2)) || defined (RUNTIME_CPUDETECT)
 587 #define COMPILE_MMX
 588 #endif
 589
 590 #if defined (HAVE_MMX2) || defined (RUNTIME_CPUDETECT)
 591 #define COMPILE_MMX2
 592 #endif
 593
 594 #if (defined (HAVE_3DNOW) && !defined (HAVE_MMX2)) || defined (RUNTIME_CPUDETECT)
 595 #define COMPILE_3DNOW
 596 #endif
 597 #endif /* defined(ARCH_X86) || defined(ARCH_X86_64) */
 598
 599 #undef HAVE_MMX
 600 #undef HAVE_MMX2
 601 #undef HAVE_3DNOW
 602 #undef HAVE_ALTIVEC
 603
 604 #ifdef COMPILE_C
 605 #undef HAVE_MMX
 606 #undef HAVE_MMX2
 607 #undef HAVE_3DNOW
 608 #define RENAME(a) a ## _C
 609 #include "postprocess_template.c"
 610 #endif
 611
 612 #ifdef ARCH_POWERPC
 613 #ifdef COMPILE_ALTIVEC
 614 #undef RENAME
 615 #define HAVE_ALTIVEC
 616 #define RENAME(a) a ## _altivec
 617 #include "postprocess_altivec_template.c"
 618 #include "postprocess_template.c"
 619 #endif
 620 #endif //ARCH_POWERPC
 621
 622 //MMX versions
 623 #ifdef COMPILE_MMX
 624 #undef RENAME
 625 #define HAVE_MMX
 626 #undef HAVE_MMX2
 627 #undef HAVE_3DNOW
 628 #define RENAME(a) a ## _MMX
 629 #include "postprocess_template.c"
 630 #endif
 631
 632 //MMX2 versions
 633 #ifdef COMPILE_MMX2
 634 #undef RENAME
 635 #define HAVE_MMX
 636 #define HAVE_MMX2
 637 #undef HAVE_3DNOW
 638 #define RENAME(a) a ## _MMX2
 639 #include "postprocess_template.c"
 640 #endif
 641
 642 //3DNOW versions
 643 #ifdef COMPILE_3DNOW
 644 #undef RENAME
 645 #define HAVE_MMX
 646 #undef HAVE_MMX2
 647 #define HAVE_3DNOW
 648 #define RENAME(a) a ## _3DNow
 649 #include "postprocess_template.c"
 650 #endif
 651
 652 // minor note: the HAVE_xyz is messed up after that line so dont use it
 653
 654 static inline void postProcess(uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
 655         QP_STORE_T QPs[], int QPStride, int isColor, pp_mode_t *vm, pp_context_t *vc)
 656 {
 657         PPContext *c= (PPContext *)vc;
 658         PPMode *ppMode= (PPMode *)vm;
 659         c->ppMode= *ppMode; //FIXME
 660
 661         // useing ifs here as they are faster than function pointers allthough the
 662         // difference wouldnt be messureable here but its much better because
 663         // someone might exchange the cpu whithout restarting mplayer ;)
 664 #ifdef RUNTIME_CPUDETECT
 665 #if defined(ARCH_X86) || defined(ARCH_X86_64)
 666         // ordered per speed fasterst first
 667         if(c->cpuCaps & PP_CPU_CAPS_MMX2)
 668                 postProcess_MMX2(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 669         else if(c->cpuCaps & PP_CPU_CAPS_3DNOW)
 670                 postProcess_3DNow(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 671         else if(c->cpuCaps & PP_CPU_CAPS_MMX)
 672                 postProcess_MMX(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 673         else
 674                 postProcess_C(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 675 #else
 676 #ifdef ARCH_POWERPC
 677 #ifdef HAVE_ALTIVEC
 678         if(c->cpuCaps & PP_CPU_CAPS_ALTIVEC)
 679                 postProcess_altivec(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 680         else
 681 #endif
 682 #endif
 683                 postProcess_C(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 684 #endif
 685 #else //RUNTIME_CPUDETECT
 686 #ifdef HAVE_MMX2
 687                 postProcess_MMX2(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 688 #elif defined (HAVE_3DNOW)
 689                 postProcess_3DNow(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 690 #elif defined (HAVE_MMX)
 691                 postProcess_MMX(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 692 #elif defined (HAVE_ALTIVEC)
 693                 postProcess_altivec(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 694 #else
 695                 postProcess_C(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 696 #endif
 697 #endif //!RUNTIME_CPUDETECT
 698 }
 699
 700 //static void postProcess(uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
 701 //        QP_STORE_T QPs[], int QPStride, int isColor, struct PPMode *ppMode);
 702
 703 /* -pp Command line Help
 704 */
 705 char *pp_help=
 706 "Available postprocessing filters:\n"
 707 "Filters                        Options\n"
 708 "short  long name       short   long option     Description\n"
 709 "*      *               a       autoq           CPU power dependent enabler\n"
 710 "                       c       chrom           chrominance filtering enabled\n"
 711 "                       y       nochrom         chrominance filtering disabled\n"
 712 "                       n       noluma          luma filtering disabled\n"
 713 "hb     hdeblock        (2 threshold)           horizontal deblocking filter\n"
 714 "       1. difference factor: default=32, higher -> more deblocking\n"
 715 "       2. flatness threshold: default=39, lower -> more deblocking\n"
 716 "                       the h & v deblocking filters share these\n"
 717 "                       so you can't set different thresholds for h / v\n"
 718 "vb     vdeblock        (2 threshold)           vertical deblocking filter\n"
 719 "ha     hadeblock       (2 threshold)           horizontal deblocking filter\n"
 720 "va     vadeblock       (2 threshold)           vertical deblocking filter\n"
 721 "h1     x1hdeblock                              experimental h deblock filter 1\n"
 722 "v1     x1vdeblock                              experimental v deblock filter 1\n"
 723 "dr     dering                                  deringing filter\n"
 724 "al     autolevels                              automatic brightness / contrast\n"
 725 "                       f        fullyrange     stretch luminance to (0..255)\n"
 726 "lb     linblenddeint                           linear blend deinterlacer\n"
 727 "li     linipoldeint                            linear interpolating deinterlace\n"
 728 "ci     cubicipoldeint                          cubic interpolating deinterlacer\n"
 729 "md     mediandeint                             median deinterlacer\n"
 730 "fd     ffmpegdeint                             ffmpeg deinterlacer\n"
 731 "l5     lowpass5                                FIR lowpass deinterlacer\n"
 732 "de     default                                 hb:a,vb:a,dr:a\n"
 733 "fa     fast                                    h1:a,v1:a,dr:a\n"
 734 "ac                                             ha:a:128:7,va:a,dr:a\n"
 735 "tn     tmpnoise        (3 threshold)           temporal noise reducer\n"
 736 "                     1. <= 2. <= 3.            larger -> stronger filtering\n"
 737 "fq     forceQuant      <quantizer>             force quantizer\n"
 738 "Usage:\n"
 739 "<filterName>[:<option>[:<option>...]][[,|/][-]<filterName>[:<option>...]]...\n"
 740 "long form example:\n"
 741 "vdeblock:autoq/hdeblock:autoq/linblenddeint    default,-vdeblock\n"
 742 "short form example:\n"
 743 "vb:a/hb:a/lb                                   de,-vb\n"
 744 "more examples:\n"
 745 "tn:64:128:256\n"
 746 "\n"
 747 ;
 748
 749 pp_mode_t *pp_get_mode_by_name_and_quality(char *name, int quality)
 750 {
 751         char temp[GET_MODE_BUFFER_SIZE];
 752         char *p= temp;
 753         const char *filterDelimiters= ",/";
 754         const char *optionDelimiters= ":";
 755         struct PPMode *ppMode;
 756         char *filterToken;
 757
 758         ppMode= av_malloc(sizeof(PPMode));
 759
 760         ppMode->lumMode= 0;
 761         ppMode->chromMode= 0;
 762         ppMode->maxTmpNoise[0]= 700;
 763         ppMode->maxTmpNoise[1]= 1500;
 764         ppMode->maxTmpNoise[2]= 3000;
 765         ppMode->maxAllowedY= 234;
 766         ppMode->minAllowedY= 16;
 767         ppMode->baseDcDiff= 256/8;
 768         ppMode->flatnessThreshold= 56-16-1;
 769         ppMode->maxClippedThreshold= 0.01;
 770         ppMode->error=0;
 771
 772         strncpy(temp, name, GET_MODE_BUFFER_SIZE);
 773
 774         av_log(NULL, AV_LOG_DEBUG, "pp: %s\n", name);
 775
 776         for(;;){
 777                 char *filterName;
 778                 int q= 1000000; //PP_QUALITY_MAX;
 779                 int chrom=-1;
 780                 int luma=-1;
 781                 char *option;
 782                 char *options[OPTIONS_ARRAY_SIZE];
 783                 int i;
 784                 int filterNameOk=0;
 785                 int numOfUnknownOptions=0;
 786                 int enable=1; //does the user want us to enabled or disabled the filter
 787
 788                 filterToken= strtok(p, filterDelimiters);
 789                 if(filterToken == NULL) break;
 790                 p+= strlen(filterToken) + 1; // p points to next filterToken
 791                 filterName= strtok(filterToken, optionDelimiters);
 792                 av_log(NULL, AV_LOG_DEBUG, "pp: %s::%s\n", filterToken, filterName);
 793
 794                 if(*filterName == '-')
 795                 {
 796                         enable=0;
 797                         filterName++;
 798                 }
 799
 800                 for(;;){ //for all options
 801                         option= strtok(NULL, optionDelimiters);
 802                         if(option == NULL) break;
 803
 804                         av_log(NULL, AV_LOG_DEBUG, "pp: option: %s\n", option);
 805                         if(!strcmp("autoq", option) || !strcmp("a", option)) q= quality;
 806                         else if(!strcmp("nochrom", option) || !strcmp("y", option)) chrom=0;
 807                         else if(!strcmp("chrom", option) || !strcmp("c", option)) chrom=1;
 808                         else if(!strcmp("noluma", option) || !strcmp("n", option)) luma=0;
 809                         else
 810                         {
 811                                 options[numOfUnknownOptions] = option;
 812                                 numOfUnknownOptions++;
 813                         }
 814                         if(numOfUnknownOptions >= OPTIONS_ARRAY_SIZE-1) break;
 815                 }
 816                 options[numOfUnknownOptions] = NULL;
 817
 818                 /* replace stuff from the replace Table */
 819                 for(i=0; replaceTable[2*i]!=NULL; i++)
 820                 {
 821                         if(!strcmp(replaceTable[2*i], filterName))
 822                         {
 823                                 int newlen= strlen(replaceTable[2*i + 1]);
 824                                 int plen;
 825                                 int spaceLeft;
 826
 827                                 if(p==NULL) p= temp, *p=0;      //last filter
 828                                 else p--, *p=',';               //not last filter
 829
 830                                 plen= strlen(p);
 831                                 spaceLeft= p - temp + plen;
 832                                 if(spaceLeft + newlen  >= GET_MODE_BUFFER_SIZE)
 833                                 {
 834                                         ppMode->error++;
 835                                         break;
 836                                 }
 837                                 memmove(p + newlen, p, plen+1);
 838                                 memcpy(p, replaceTable[2*i + 1], newlen);
 839                                 filterNameOk=1;
 840                         }
 841                 }
 842
 843                 for(i=0; filters[i].shortName!=NULL; i++)
 844                 {
 845                         if(   !strcmp(filters[i].longName, filterName)
 846                            || !strcmp(filters[i].shortName, filterName))
 847                         {
 848                                 ppMode->lumMode &= ~filters[i].mask;
 849                                 ppMode->chromMode &= ~filters[i].mask;
 850
 851                                 filterNameOk=1;
 852                                 if(!enable) break; // user wants to disable it
 853
 854                                 if(q >= filters[i].minLumQuality && luma)
 855                                         ppMode->lumMode|= filters[i].mask;
 856                                 if(chrom==1 || (chrom==-1 && filters[i].chromDefault))
 857                                         if(q >= filters[i].minChromQuality)
 858                                                 ppMode->chromMode|= filters[i].mask;
 859
 860                                 if(filters[i].mask == LEVEL_FIX)
 861                                 {
 862                                         int o;
 863                                         ppMode->minAllowedY= 16;
 864                                         ppMode->maxAllowedY= 234;
 865                                         for(o=0; options[o]!=NULL; o++)
 866                                         {
 867                                                 if(  !strcmp(options[o],"fullyrange")
 868                                                    ||!strcmp(options[o],"f"))
 869                                                 {
 870                                                         ppMode->minAllowedY= 0;
 871                                                         ppMode->maxAllowedY= 255;
 872                                                         numOfUnknownOptions--;
 873                                                 }
 874                                         }
 875                                 }
 876                                 else if(filters[i].mask == TEMP_NOISE_FILTER)
 877                                 {
 878                                         int o;
 879                                         int numOfNoises=0;
 880
 881                                         for(o=0; options[o]!=NULL; o++)
 882                                         {
 883                                                 char *tail;
 884                                                 ppMode->maxTmpNoise[numOfNoises]=
 885                                                         strtol(options[o], &tail, 0);
 886                                                 if(tail!=options[o])
 887                                                 {
 888                                                         numOfNoises++;
 889                                                         numOfUnknownOptions--;
 890                                                         if(numOfNoises >= 3) break;
 891                                                 }
 892                                         }
 893                                 }
 894                                 else if(filters[i].mask == V_DEBLOCK   || filters[i].mask == H_DEBLOCK
 895                                      || filters[i].mask == V_A_DEBLOCK || filters[i].mask == H_A_DEBLOCK)
 896                                 {
 897                                         int o;
 898
 899                                         for(o=0; options[o]!=NULL && o<2; o++)
 900                                         {
 901                                                 char *tail;
 902                                                 int val= strtol(options[o], &tail, 0);
 903                                                 if(tail==options[o]) break;
 904
 905                                                 numOfUnknownOptions--;
 906                                                 if(o==0) ppMode->baseDcDiff= val;
 907                                                 else ppMode->flatnessThreshold= val;
 908                                         }
 909                                 }
 910                                 else if(filters[i].mask == FORCE_QUANT)
 911                                 {
 912                                         int o;
 913                                         ppMode->forcedQuant= 15;
 914
 915                                         for(o=0; options[o]!=NULL && o<1; o++)
 916                                         {
 917                                                 char *tail;
 918                                                 int val= strtol(options[o], &tail, 0);
 919                                                 if(tail==options[o]) break;
 920
 921                                                 numOfUnknownOptions--;
 922                                                 ppMode->forcedQuant= val;
 923                                         }
 924                                 }
 925                         }
 926                 }
 927                 if(!filterNameOk) ppMode->error++;
 928                 ppMode->error += numOfUnknownOptions;
 929         }
 930
 931         av_log(NULL, AV_LOG_DEBUG, "pp: lumMode=%X, chromMode=%X\n", ppMode->lumMode, ppMode->chromMode);
 932         if(ppMode->error)
 933         {
 934                 av_log(NULL, AV_LOG_ERROR, "%d errors in postprocess string \"%s\"\n", ppMode->error, name);
 935                 av_free(ppMode);
 936                 return NULL;
 937         }
 938         return ppMode;
 939 }
 940
 941 void pp_free_mode(pp_mode_t *mode){
 942     av_free(mode);
 943 }
 944
 945 static void reallocAlign(void **p, int alignment, int size){
 946         av_free(*p);
 947         *p= av_mallocz(size);
 948 }
 949
 950 static void reallocBuffers(PPContext *c, int width, int height, int stride, int qpStride){
 951         int mbWidth = (width+15)>>4;
 952         int mbHeight= (height+15)>>4;
 953         int i;
 954
 955         c->stride= stride;
 956         c->qpStride= qpStride;
 957
 958         reallocAlign((void **)&c->tempDst, 8, stride*24);
 959         reallocAlign((void **)&c->tempSrc, 8, stride*24);
 960         reallocAlign((void **)&c->tempBlocks, 8, 2*16*8);
 961         reallocAlign((void **)&c->yHistogram, 8, 256*sizeof(uint64_t));
 962         for(i=0; i<256; i++)
 963                 c->yHistogram[i]= width*height/64*15/256;
 964
 965         for(i=0; i<3; i++)
 966         {
 967                 //Note:the +17*1024 is just there so i dont have to worry about r/w over te end
 968                 reallocAlign((void **)&c->tempBlured[i], 8, stride*mbHeight*16 + 17*1024);
 969                 reallocAlign((void **)&c->tempBluredPast[i], 8, 256*((height+7)&(~7))/2 + 17*1024);//FIXME size
 970         }
 971
 972         reallocAlign((void **)&c->deintTemp, 8, 2*width+32);
 973         reallocAlign((void **)&c->nonBQPTable, 8, qpStride*mbHeight*sizeof(QP_STORE_T));
 974         reallocAlign((void **)&c->stdQPTable, 8, qpStride*mbHeight*sizeof(QP_STORE_T));
 975         reallocAlign((void **)&c->forcedQPTable, 8, mbWidth*sizeof(QP_STORE_T));
 976 }
 977
 978 static void global_init(void){
 979         int i;
 980         memset(clip_table, 0, 256);
 981         for(i=256; i<512; i++)
 982                 clip_table[i]= i;
 983         memset(clip_table+512, 0, 256);
 984 }
 985
 986 static const char * context_to_name(void * ptr) {
 987     return "postproc";
 988 }
 989
 990 static AVClass av_codec_context_class = { "Postproc", context_to_name, NULL };
 991
 992 pp_context_t *pp_get_context(int width, int height, int cpuCaps){
 993         PPContext *c= av_malloc(sizeof(PPContext));
 994         int stride= (width+15)&(~15);    //assumed / will realloc if needed
 995         int qpStride= (width+15)/16 + 2; //assumed / will realloc if needed
 996
 997         global_init();
 998
 999         memset(c, 0, sizeof(PPContext));
1000         c->av_class = &av_codec_context_class;
1001         c->cpuCaps= cpuCaps;
1002         if(cpuCaps&PP_FORMAT){
1003                 c->hChromaSubSample= cpuCaps&0x3;
1004                 c->vChromaSubSample= (cpuCaps>>4)&0x3;
1005         }else{
1006                 c->hChromaSubSample= 1;
1007                 c->vChromaSubSample= 1;
1008         }
1009
1010         reallocBuffers(c, width, height, stride, qpStride);
1011
1012         c->frameNum=-1;
1013
1014         return c;
1015 }
1016
1017 void pp_free_context(void *vc){
1018         PPContext *c = (PPContext*)vc;
1019         int i;
1020
1021         for(i=0; i<3; i++) av_free(c->tempBlured[i]);
1022         for(i=0; i<3; i++) av_free(c->tempBluredPast[i]);
1023
1024         av_free(c->tempBlocks);
1025         av_free(c->yHistogram);
1026         av_free(c->tempDst);
1027         av_free(c->tempSrc);
1028         av_free(c->deintTemp);
1029         av_free(c->stdQPTable);
1030         av_free(c->nonBQPTable);
1031         av_free(c->forcedQPTable);
1032
1033         memset(c, 0, sizeof(PPContext));
1034
1035         av_free(c);
1036 }
1037
1038 void  pp_postprocess(uint8_t * src[3], int srcStride[3],
1039                  uint8_t * dst[3], int dstStride[3],
1040                  int width, int height,
1041                  QP_STORE_T *QP_store,  int QPStride,
1042                  pp_mode_t *vm,  void *vc, int pict_type)
1043 {
1044         int mbWidth = (width+15)>>4;
1045         int mbHeight= (height+15)>>4;
1046         PPMode *mode = (PPMode*)vm;
1047         PPContext *c = (PPContext*)vc;
1048         int minStride= FFMAX(FFABS(srcStride[0]), FFABS(dstStride[0]));
1049         int absQPStride = FFABS(QPStride);
1050
1051         // c->stride and c->QPStride are always positive
1052         if(c->stride < minStride || c->qpStride < absQPStride)
1053                 reallocBuffers(c, width, height,
1054                                 FFMAX(minStride, c->stride),
1055                                 FFMAX(c->qpStride, absQPStride));
1056
1057         if(QP_store==NULL || (mode->lumMode & FORCE_QUANT))
1058         {
1059                 int i;
1060                 QP_store= c->forcedQPTable;
1061                 absQPStride = QPStride = 0;
1062                 if(mode->lumMode & FORCE_QUANT)
1063                         for(i=0; i<mbWidth; i++) QP_store[i]= mode->forcedQuant;
1064                 else
1065                         for(i=0; i<mbWidth; i++) QP_store[i]= 1;
1066         }
1067
1068         if(pict_type & PP_PICT_TYPE_QP2){
1069                 int i;
1070                 const int count= mbHeight * absQPStride;
1071                 for(i=0; i<(count>>2); i++){
1072                         ((uint32_t*)c->stdQPTable)[i] = (((uint32_t*)QP_store)[i]>>1) & 0x7F7F7F7F;
1073                 }
1074                 for(i<<=2; i<count; i++){
1075                         c->stdQPTable[i] = QP_store[i]>>1;
1076                 }
1077                 QP_store= c->stdQPTable;
1078                 QPStride= absQPStride;
1079         }
1080
1081 if(0){
1082 int x,y;
1083 for(y=0; y<mbHeight; y++){
1084         for(x=0; x<mbWidth; x++){
1085                 av_log(c, AV_LOG_INFO, "%2d ", QP_store[x + y*QPStride]);
1086         }
1087         av_log(c, AV_LOG_INFO, "\n");
1088 }
1089         av_log(c, AV_LOG_INFO, "\n");
1090 }
1091
1092         if((pict_type&7)!=3)
1093         {
1094                 if (QPStride >= 0) {
1095                         int i;
1096                         const int count= mbHeight * QPStride;
1097                         for(i=0; i<(count>>2); i++){
1098                                 ((uint32_t*)c->nonBQPTable)[i] = ((uint32_t*)QP_store)[i] & 0x3F3F3F3F;
1099                         }
1100                         for(i<<=2; i<count; i++){
1101                                 c->nonBQPTable[i] = QP_store[i] & 0x3F;
1102                         }
1103                 } else {
1104                         int i,j;
1105                         for(i=0; i<mbHeight; i++) {
1106                                     for(j=0; j<absQPStride; j++) {
1107                                         c->nonBQPTable[i*absQPStride+j] = QP_store[i*QPStride+j] & 0x3F;
1108                                 }
1109                         }
1110                 }
1111         }
1112
1113         av_log(c, AV_LOG_DEBUG, "using npp filters 0x%X/0x%X\n",
1114                mode->lumMode, mode->chromMode);
1115
1116         postProcess(src[0], srcStride[0], dst[0], dstStride[0],
1117                 width, height, QP_store, QPStride, 0, mode, c);
1118
1119         width  = (width )>>c->hChromaSubSample;
1120         height = (height)>>c->vChromaSubSample;
1121
1122         if(mode->chromMode)
1123         {
1124                 postProcess(src[1], srcStride[1], dst[1], dstStride[1],
1125                         width, height, QP_store, QPStride, 1, mode, c);
1126                 postProcess(src[2], srcStride[2], dst[2], dstStride[2],
1127                         width, height, QP_store, QPStride, 2, mode, c);
1128         }
1129         else if(srcStride[1] == dstStride[1] && srcStride[2] == dstStride[2])
1130         {
1131                 linecpy(dst[1], src[1], height, srcStride[1]);
1132                 linecpy(dst[2], src[2], height, srcStride[2]);
1133         }
1134         else
1135         {
1136                 int y;
1137                 for(y=0; y<height; y++)
1138                 {
1139                         memcpy(&(dst[1][y*dstStride[1]]), &(src[1][y*srcStride[1]]), width);
1140                         memcpy(&(dst[2][y*dstStride[2]]), &(src[2][y*srcStride[2]]), width);
1141                 }
1142         }
1143 }
1144