git.sesse.net Git - ffmpeg/blob - 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
  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 do not have a 3DNow! CPU -> it is untested, but no one said it does not work so it seems to work
  51 # more or less selfinvented filters so the exactness is not too meaningful
  52 E = Exact implementation
  53 e = almost 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 git log
  75
  76 #include "config.h"
  77 #include "libavutil/avutil.h"
  78 #include "libavutil/avassert.h"
  79 #include <inttypes.h>
  80 #include <stdio.h>
  81 #include <stdlib.h>
  82 #include <string.h>
  83 //#undef HAVE_MMXEXT_INLINE
  84 //#define HAVE_AMD3DNOW_INLINE
  85 //#undef HAVE_MMX_INLINE
  86 //#undef ARCH_X86
  87 //#define DEBUG_BRIGHTNESS
  88 #include "postprocess.h"
  89 #include "postprocess_internal.h"
  90 #include "libavutil/avstring.h"
  91
  92 unsigned postproc_version(void)
  93 {
  94     av_assert0(LIBPOSTPROC_VERSION_MICRO >= 100);
  95     return LIBPOSTPROC_VERSION_INT;
  96 }
  97
  98 const char *postproc_configuration(void)
  99 {
 100     return FFMPEG_CONFIGURATION;
 101 }
 102
 103 const char *postproc_license(void)
 104 {
 105 #define LICENSE_PREFIX "libpostproc license: "
 106     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
 107 }
 108
 109 #if HAVE_ALTIVEC_H
 110 #include <altivec.h>
 111 #endif
 112
 113 #define GET_MODE_BUFFER_SIZE 500
 114 #define OPTIONS_ARRAY_SIZE 10
 115 #define BLOCK_SIZE 8
 116 #define TEMP_STRIDE 8
 117 //#define NUM_BLOCKS_AT_ONCE 16 //not used yet
 118
 119 #if ARCH_X86 && HAVE_INLINE_ASM
 120 DECLARE_ASM_CONST(8, uint64_t, w05)= 0x0005000500050005LL;
 121 DECLARE_ASM_CONST(8, uint64_t, w04)= 0x0004000400040004LL;
 122 DECLARE_ASM_CONST(8, uint64_t, w20)= 0x0020002000200020LL;
 123 DECLARE_ASM_CONST(8, uint64_t, b00)= 0x0000000000000000LL;
 124 DECLARE_ASM_CONST(8, uint64_t, b01)= 0x0101010101010101LL;
 125 DECLARE_ASM_CONST(8, uint64_t, b02)= 0x0202020202020202LL;
 126 DECLARE_ASM_CONST(8, uint64_t, b08)= 0x0808080808080808LL;
 127 DECLARE_ASM_CONST(8, uint64_t, b80)= 0x8080808080808080LL;
 128 #endif
 129
 130 DECLARE_ASM_CONST(8, int, deringThreshold)= 20;
 131
 132
 133 static const struct PPFilter filters[]=
 134 {
 135     {"hb", "hdeblock",              1, 1, 3, H_DEBLOCK},
 136     {"vb", "vdeblock",              1, 2, 4, V_DEBLOCK},
 137 /*  {"hr", "rkhdeblock",            1, 1, 3, H_RK1_FILTER},
 138     {"vr", "rkvdeblock",            1, 2, 4, V_RK1_FILTER},*/
 139     {"h1", "x1hdeblock",            1, 1, 3, H_X1_FILTER},
 140     {"v1", "x1vdeblock",            1, 2, 4, V_X1_FILTER},
 141     {"ha", "ahdeblock",             1, 1, 3, H_A_DEBLOCK},
 142     {"va", "avdeblock",             1, 2, 4, V_A_DEBLOCK},
 143     {"dr", "dering",                1, 5, 6, DERING},
 144     {"al", "autolevels",            0, 1, 2, LEVEL_FIX},
 145     {"lb", "linblenddeint",         1, 1, 4, LINEAR_BLEND_DEINT_FILTER},
 146     {"li", "linipoldeint",          1, 1, 4, LINEAR_IPOL_DEINT_FILTER},
 147     {"ci", "cubicipoldeint",        1, 1, 4, CUBIC_IPOL_DEINT_FILTER},
 148     {"md", "mediandeint",           1, 1, 4, MEDIAN_DEINT_FILTER},
 149     {"fd", "ffmpegdeint",           1, 1, 4, FFMPEG_DEINT_FILTER},
 150     {"l5", "lowpass5",              1, 1, 4, LOWPASS5_DEINT_FILTER},
 151     {"tn", "tmpnoise",              1, 7, 8, TEMP_NOISE_FILTER},
 152     {"fq", "forcequant",            1, 0, 0, FORCE_QUANT},
 153     {"be", "bitexact",              1, 0, 0, BITEXACT},
 154     {"vi", "visualize",             1, 0, 0, VISUALIZE},
 155     {NULL, NULL,0,0,0,0} //End Marker
 156 };
 157
 158 static const char * const replaceTable[]=
 159 {
 160     "default",      "hb:a,vb:a,dr:a",
 161     "de",           "hb:a,vb:a,dr:a",
 162     "fast",         "h1:a,v1:a,dr:a",
 163     "fa",           "h1:a,v1:a,dr:a",
 164     "ac",           "ha:a:128:7,va:a,dr:a",
 165     NULL //End Marker
 166 };
 167
 168
 169 #if ARCH_X86 && HAVE_INLINE_ASM
 170 static inline void prefetchnta(const void *p)
 171 {
 172     __asm__ volatile(   "prefetchnta (%0)\n\t"
 173         : : "r" (p)
 174     );
 175 }
 176
 177 static inline void prefetcht0(const void *p)
 178 {
 179     __asm__ volatile(   "prefetcht0 (%0)\n\t"
 180         : : "r" (p)
 181     );
 182 }
 183
 184 static inline void prefetcht1(const void *p)
 185 {
 186     __asm__ volatile(   "prefetcht1 (%0)\n\t"
 187         : : "r" (p)
 188     );
 189 }
 190
 191 static inline void prefetcht2(const void *p)
 192 {
 193     __asm__ volatile(   "prefetcht2 (%0)\n\t"
 194         : : "r" (p)
 195     );
 196 }
 197 #endif
 198
 199 /* The horizontal functions exist only in C because the MMX
 200  * code is faster with vertical filters and transposing. */
 201
 202 /**
 203  * Check if the given 8x8 Block is mostly "flat"
 204  */
 205 static inline int isHorizDC_C(const uint8_t src[], int stride, const PPContext *c)
 206 {
 207     int numEq= 0;
 208     int y;
 209     const int dcOffset= ((c->nonBQP*c->ppMode.baseDcDiff)>>8) + 1;
 210     const int dcThreshold= dcOffset*2 + 1;
 211
 212     for(y=0; y<BLOCK_SIZE; y++){
 213         numEq += ((unsigned)(src[0] - src[1] + dcOffset)) < dcThreshold;
 214         numEq += ((unsigned)(src[1] - src[2] + dcOffset)) < dcThreshold;
 215         numEq += ((unsigned)(src[2] - src[3] + dcOffset)) < dcThreshold;
 216         numEq += ((unsigned)(src[3] - src[4] + dcOffset)) < dcThreshold;
 217         numEq += ((unsigned)(src[4] - src[5] + dcOffset)) < dcThreshold;
 218         numEq += ((unsigned)(src[5] - src[6] + dcOffset)) < dcThreshold;
 219         numEq += ((unsigned)(src[6] - src[7] + dcOffset)) < dcThreshold;
 220         src+= stride;
 221     }
 222     return numEq > c->ppMode.flatnessThreshold;
 223 }
 224
 225 /**
 226  * Check if the middle 8x8 Block in the given 8x16 block is flat
 227  */
 228 static inline int isVertDC_C(const uint8_t src[], int stride, const PPContext *c)
 229 {
 230     int numEq= 0;
 231     int y;
 232     const int dcOffset= ((c->nonBQP*c->ppMode.baseDcDiff)>>8) + 1;
 233     const int dcThreshold= dcOffset*2 + 1;
 234
 235     src+= stride*4; // src points to begin of the 8x8 Block
 236     for(y=0; y<BLOCK_SIZE-1; y++){
 237         numEq += ((unsigned)(src[0] - src[0+stride] + dcOffset)) < dcThreshold;
 238         numEq += ((unsigned)(src[1] - src[1+stride] + dcOffset)) < dcThreshold;
 239         numEq += ((unsigned)(src[2] - src[2+stride] + dcOffset)) < dcThreshold;
 240         numEq += ((unsigned)(src[3] - src[3+stride] + dcOffset)) < dcThreshold;
 241         numEq += ((unsigned)(src[4] - src[4+stride] + dcOffset)) < dcThreshold;
 242         numEq += ((unsigned)(src[5] - src[5+stride] + dcOffset)) < dcThreshold;
 243         numEq += ((unsigned)(src[6] - src[6+stride] + dcOffset)) < dcThreshold;
 244         numEq += ((unsigned)(src[7] - src[7+stride] + dcOffset)) < dcThreshold;
 245         src+= stride;
 246     }
 247     return numEq > c->ppMode.flatnessThreshold;
 248 }
 249
 250 static inline int isHorizMinMaxOk_C(const uint8_t src[], int stride, int QP)
 251 {
 252     int i;
 253     for(i=0; i<2; i++){
 254         if((unsigned)(src[0] - src[5] + 2*QP) > 4*QP) return 0;
 255         src += stride;
 256         if((unsigned)(src[2] - src[7] + 2*QP) > 4*QP) return 0;
 257         src += stride;
 258         if((unsigned)(src[4] - src[1] + 2*QP) > 4*QP) return 0;
 259         src += stride;
 260         if((unsigned)(src[6] - src[3] + 2*QP) > 4*QP) return 0;
 261         src += stride;
 262     }
 263     return 1;
 264 }
 265
 266 static inline int isVertMinMaxOk_C(const uint8_t src[], int stride, int QP)
 267 {
 268     int x;
 269     src+= stride*4;
 270     for(x=0; x<BLOCK_SIZE; x+=4){
 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     return 1;
 277 }
 278
 279 static inline int horizClassify_C(const uint8_t src[], int stride, const PPContext *c)
 280 {
 281     if( isHorizDC_C(src, stride, c) ){
 282         return isHorizMinMaxOk_C(src, stride, c->QP);
 283     }else{
 284         return 2;
 285     }
 286 }
 287
 288 static inline int vertClassify_C(const uint8_t src[], int stride, const PPContext *c)
 289 {
 290     if( isVertDC_C(src, stride, c) ){
 291         return isVertMinMaxOk_C(src, stride, c->QP);
 292     }else{
 293         return 2;
 294     }
 295 }
 296
 297 static inline void doHorizDefFilter_C(uint8_t dst[], int stride, const PPContext *c)
 298 {
 299     int y;
 300     for(y=0; y<BLOCK_SIZE; y++){
 301         const int middleEnergy= 5*(dst[4] - dst[3]) + 2*(dst[2] - dst[5]);
 302
 303         if(FFABS(middleEnergy) < 8*c->QP){
 304             const int q=(dst[3] - dst[4])/2;
 305             const int leftEnergy=  5*(dst[2] - dst[1]) + 2*(dst[0] - dst[3]);
 306             const int rightEnergy= 5*(dst[6] - dst[5]) + 2*(dst[4] - dst[7]);
 307
 308             int d= FFABS(middleEnergy) - FFMIN( FFABS(leftEnergy), FFABS(rightEnergy) );
 309             d= FFMAX(d, 0);
 310
 311             d= (5*d + 32) >> 6;
 312             d*= FFSIGN(-middleEnergy);
 313
 314             if(q>0)
 315             {
 316                 d = FFMAX(d, 0);
 317                 d = FFMIN(d, q);
 318             }
 319             else
 320             {
 321                 d = FFMIN(d, 0);
 322                 d = FFMAX(d, q);
 323             }
 324
 325             dst[3]-= d;
 326             dst[4]+= d;
 327         }
 328         dst+= stride;
 329     }
 330 }
 331
 332 /**
 333  * Do a horizontal low pass filter on the 10x8 block (dst points to middle 8x8 Block)
 334  * using the 9-Tap Filter (1,1,2,2,4,2,2,1,1)/16 (C version)
 335  */
 336 static inline void doHorizLowPass_C(uint8_t dst[], int stride, const PPContext *c)
 337 {
 338     int y;
 339     for(y=0; y<BLOCK_SIZE; y++){
 340         const int first= FFABS(dst[-1] - dst[0]) < c->QP ? dst[-1] : dst[0];
 341         const int last= FFABS(dst[8] - dst[7]) < c->QP ? dst[8] : dst[7];
 342
 343         int sums[10];
 344         sums[0] = 4*first + dst[0] + dst[1] + dst[2] + 4;
 345         sums[1] = sums[0] - first  + dst[3];
 346         sums[2] = sums[1] - first  + dst[4];
 347         sums[3] = sums[2] - first  + dst[5];
 348         sums[4] = sums[3] - first  + dst[6];
 349         sums[5] = sums[4] - dst[0] + dst[7];
 350         sums[6] = sums[5] - dst[1] + last;
 351         sums[7] = sums[6] - dst[2] + last;
 352         sums[8] = sums[7] - dst[3] + last;
 353         sums[9] = sums[8] - dst[4] + last;
 354
 355         dst[0]= (sums[0] + sums[2] + 2*dst[0])>>4;
 356         dst[1]= (sums[1] + sums[3] + 2*dst[1])>>4;
 357         dst[2]= (sums[2] + sums[4] + 2*dst[2])>>4;
 358         dst[3]= (sums[3] + sums[5] + 2*dst[3])>>4;
 359         dst[4]= (sums[4] + sums[6] + 2*dst[4])>>4;
 360         dst[5]= (sums[5] + sums[7] + 2*dst[5])>>4;
 361         dst[6]= (sums[6] + sums[8] + 2*dst[6])>>4;
 362         dst[7]= (sums[7] + sums[9] + 2*dst[7])>>4;
 363
 364         dst+= stride;
 365     }
 366 }
 367
 368 /**
 369  * Experimental Filter 1 (Horizontal)
 370  * will not damage linear gradients
 371  * Flat blocks should look like they were passed through the (1,1,2,2,4,2,2,1,1) 9-Tap filter
 372  * can only smooth blocks at the expected locations (it cannot smooth them if they did move)
 373  * MMX2 version does correct clipping C version does not
 374  * not identical with the vertical one
 375  */
 376 static inline void horizX1Filter(uint8_t *src, int stride, int QP)
 377 {
 378     int y;
 379     static uint64_t lut[256];
 380     if(!lut[255])
 381     {
 382         int i;
 383         for(i=0; i<256; i++)
 384         {
 385             int v= i < 128 ? 2*i : 2*(i-256);
 386 /*
 387 //Simulate 112242211 9-Tap filter
 388             uint64_t a= (v/16)  & 0xFF;
 389             uint64_t b= (v/8)   & 0xFF;
 390             uint64_t c= (v/4)   & 0xFF;
 391             uint64_t d= (3*v/8) & 0xFF;
 392 */
 393 //Simulate piecewise linear interpolation
 394             uint64_t a= (v/16)   & 0xFF;
 395             uint64_t b= (v*3/16) & 0xFF;
 396             uint64_t c= (v*5/16) & 0xFF;
 397             uint64_t d= (7*v/16) & 0xFF;
 398             uint64_t A= (0x100 - a)&0xFF;
 399             uint64_t B= (0x100 - b)&0xFF;
 400             uint64_t C= (0x100 - c)&0xFF;
 401             uint64_t D= (0x100 - c)&0xFF;
 402
 403             lut[i]   = (a<<56) | (b<<48) | (c<<40) | (d<<32) |
 404                        (D<<24) | (C<<16) | (B<<8)  | (A);
 405             //lut[i] = (v<<32) | (v<<24);
 406         }
 407     }
 408
 409     for(y=0; y<BLOCK_SIZE; y++){
 410         int a= src[1] - src[2];
 411         int b= src[3] - src[4];
 412         int c= src[5] - src[6];
 413
 414         int d= FFMAX(FFABS(b) - (FFABS(a) + FFABS(c))/2, 0);
 415
 416         if(d < QP){
 417             int v = d * FFSIGN(-b);
 418
 419             src[1] +=v/8;
 420             src[2] +=v/4;
 421             src[3] +=3*v/8;
 422             src[4] -=3*v/8;
 423             src[5] -=v/4;
 424             src[6] -=v/8;
 425         }
 426         src+=stride;
 427     }
 428 }
 429
 430 /**
 431  * accurate deblock filter
 432  */
 433 static av_always_inline void do_a_deblock_C(uint8_t *src, int step,
 434                                             int stride, const PPContext *c, int mode)
 435 {
 436     int y;
 437     const int QP= c->QP;
 438     const int dcOffset= ((c->nonBQP*c->ppMode.baseDcDiff)>>8) + 1;
 439     const int dcThreshold= dcOffset*2 + 1;
 440 //START_TIMER
 441     src+= step*4; // src points to begin of the 8x8 Block
 442     for(y=0; y<8; y++){
 443         int numEq= 0;
 444
 445         numEq += ((unsigned)(src[-1*step] - src[0*step] + dcOffset)) < dcThreshold;
 446         numEq += ((unsigned)(src[ 0*step] - src[1*step] + dcOffset)) < dcThreshold;
 447         numEq += ((unsigned)(src[ 1*step] - src[2*step] + dcOffset)) < dcThreshold;
 448         numEq += ((unsigned)(src[ 2*step] - src[3*step] + dcOffset)) < dcThreshold;
 449         numEq += ((unsigned)(src[ 3*step] - src[4*step] + dcOffset)) < dcThreshold;
 450         numEq += ((unsigned)(src[ 4*step] - src[5*step] + dcOffset)) < dcThreshold;
 451         numEq += ((unsigned)(src[ 5*step] - src[6*step] + dcOffset)) < dcThreshold;
 452         numEq += ((unsigned)(src[ 6*step] - src[7*step] + dcOffset)) < dcThreshold;
 453         numEq += ((unsigned)(src[ 7*step] - src[8*step] + dcOffset)) < dcThreshold;
 454         if(numEq > c->ppMode.flatnessThreshold){
 455             int min, max, x;
 456
 457             if(src[0] > src[step]){
 458                 max= src[0];
 459                 min= src[step];
 460             }else{
 461                 max= src[step];
 462                 min= src[0];
 463             }
 464             for(x=2; x<8; x+=2){
 465                 if(src[x*step] > src[(x+1)*step]){
 466                         if(src[x    *step] > max) max= src[ x   *step];
 467                         if(src[(x+1)*step] < min) min= src[(x+1)*step];
 468                 }else{
 469                         if(src[(x+1)*step] > max) max= src[(x+1)*step];
 470                         if(src[ x   *step] < min) min= src[ x   *step];
 471                 }
 472             }
 473             if(max-min < 2*QP){
 474                 const int first= FFABS(src[-1*step] - src[0]) < QP ? src[-1*step] : src[0];
 475                 const int last= FFABS(src[8*step] - src[7*step]) < QP ? src[8*step] : src[7*step];
 476
 477                 int sums[10];
 478                 sums[0] = 4*first + src[0*step] + src[1*step] + src[2*step] + 4;
 479                 sums[1] = sums[0] - first       + src[3*step];
 480                 sums[2] = sums[1] - first       + src[4*step];
 481                 sums[3] = sums[2] - first       + src[5*step];
 482                 sums[4] = sums[3] - first       + src[6*step];
 483                 sums[5] = sums[4] - src[0*step] + src[7*step];
 484                 sums[6] = sums[5] - src[1*step] + last;
 485                 sums[7] = sums[6] - src[2*step] + last;
 486                 sums[8] = sums[7] - src[3*step] + last;
 487                 sums[9] = sums[8] - src[4*step] + last;
 488
 489                 if (mode & VISUALIZE) {
 490                     src[0*step] =
 491                     src[1*step] =
 492                     src[2*step] =
 493                     src[3*step] =
 494                     src[4*step] =
 495                     src[5*step] =
 496                     src[6*step] =
 497                     src[7*step] = 128;
 498                 }
 499                 src[0*step]= (sums[0] + sums[2] + 2*src[0*step])>>4;
 500                 src[1*step]= (sums[1] + sums[3] + 2*src[1*step])>>4;
 501                 src[2*step]= (sums[2] + sums[4] + 2*src[2*step])>>4;
 502                 src[3*step]= (sums[3] + sums[5] + 2*src[3*step])>>4;
 503                 src[4*step]= (sums[4] + sums[6] + 2*src[4*step])>>4;
 504                 src[5*step]= (sums[5] + sums[7] + 2*src[5*step])>>4;
 505                 src[6*step]= (sums[6] + sums[8] + 2*src[6*step])>>4;
 506                 src[7*step]= (sums[7] + sums[9] + 2*src[7*step])>>4;
 507             }
 508         }else{
 509             const int middleEnergy= 5*(src[4*step] - src[3*step]) + 2*(src[2*step] - src[5*step]);
 510
 511             if(FFABS(middleEnergy) < 8*QP){
 512                 const int q=(src[3*step] - src[4*step])/2;
 513                 const int leftEnergy=  5*(src[2*step] - src[1*step]) + 2*(src[0*step] - src[3*step]);
 514                 const int rightEnergy= 5*(src[6*step] - src[5*step]) + 2*(src[4*step] - src[7*step]);
 515
 516                 int d= FFABS(middleEnergy) - FFMIN( FFABS(leftEnergy), FFABS(rightEnergy) );
 517                 d= FFMAX(d, 0);
 518
 519                 d= (5*d + 32) >> 6;
 520                 d*= FFSIGN(-middleEnergy);
 521
 522                 if(q>0){
 523                     d = FFMAX(d, 0);
 524                     d = FFMIN(d, q);
 525                 }else{
 526                     d = FFMIN(d, 0);
 527                     d = FFMAX(d, q);
 528                 }
 529
 530                 if ((mode & VISUALIZE) && d) {
 531                     d= (d < 0) ? 32 : -32;
 532                     src[3*step]= av_clip_uint8(src[3*step] - d);
 533                     src[4*step]= av_clip_uint8(src[4*step] + d);
 534                     d = 0;
 535                 }
 536
 537                 src[3*step]-= d;
 538                 src[4*step]+= d;
 539             }
 540         }
 541
 542         src += stride;
 543     }
 544 /*if(step==16){
 545     STOP_TIMER("step16")
 546 }else{
 547     STOP_TIMER("stepX")
 548 }*/
 549 }
 550
 551 //Note: we have C, MMX, MMX2, 3DNOW version there is no 3DNOW+MMX2 one
 552 //Plain C versions
 553 //we always compile C for testing which needs bitexactness
 554 #define TEMPLATE_PP_C 1
 555 #include "postprocess_template.c"
 556
 557 #if HAVE_ALTIVEC
 558 #   define TEMPLATE_PP_ALTIVEC 1
 559 #   include "postprocess_altivec_template.c"
 560 #   include "postprocess_template.c"
 561 #endif
 562
 563 #if ARCH_X86 && HAVE_INLINE_ASM
 564 #    if CONFIG_RUNTIME_CPUDETECT
 565 #        define TEMPLATE_PP_MMX 1
 566 #        include "postprocess_template.c"
 567 #        define TEMPLATE_PP_MMXEXT 1
 568 #        include "postprocess_template.c"
 569 #        define TEMPLATE_PP_3DNOW 1
 570 #        include "postprocess_template.c"
 571 #        define TEMPLATE_PP_SSE2 1
 572 #        include "postprocess_template.c"
 573 #    else
 574 #        if HAVE_SSE2_INLINE
 575 #            define TEMPLATE_PP_SSE2 1
 576 #            include "postprocess_template.c"
 577 #        elif HAVE_MMXEXT_INLINE
 578 #            define TEMPLATE_PP_MMXEXT 1
 579 #            include "postprocess_template.c"
 580 #        elif HAVE_AMD3DNOW_INLINE
 581 #            define TEMPLATE_PP_3DNOW 1
 582 #            include "postprocess_template.c"
 583 #        elif HAVE_MMX_INLINE
 584 #            define TEMPLATE_PP_MMX 1
 585 #            include "postprocess_template.c"
 586 #        endif
 587 #    endif
 588 #endif
 589
 590 typedef void (*pp_fn)(const uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
 591                       const QP_STORE_T QPs[], int QPStride, int isColor, PPContext *c2);
 592
 593 static inline void postProcess(const uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
 594         const QP_STORE_T QPs[], int QPStride, int isColor, pp_mode *vm, pp_context *vc)
 595 {
 596     pp_fn pp = postProcess_C;
 597     PPContext *c= (PPContext *)vc;
 598     PPMode *ppMode= (PPMode *)vm;
 599     c->ppMode= *ppMode; //FIXME
 600
 601     if (!(ppMode->lumMode & BITEXACT)) {
 602 #if CONFIG_RUNTIME_CPUDETECT
 603 #if ARCH_X86 && HAVE_INLINE_ASM
 604         // ordered per speed fastest first
 605         if      (c->cpuCaps & AV_CPU_FLAG_SSE2)     pp = postProcess_SSE2;
 606         else if (c->cpuCaps & AV_CPU_FLAG_MMXEXT)   pp = postProcess_MMX2;
 607         else if (c->cpuCaps & AV_CPU_FLAG_3DNOW)    pp = postProcess_3DNow;
 608         else if (c->cpuCaps & AV_CPU_FLAG_MMX)      pp = postProcess_MMX;
 609 #elif HAVE_ALTIVEC
 610         if      (c->cpuCaps & AV_CPU_FLAG_ALTIVEC)  pp = postProcess_altivec;
 611 #endif
 612 #else /* CONFIG_RUNTIME_CPUDETECT */
 613 #if     HAVE_SSE2_INLINE
 614         pp = postProcess_SSE2;
 615 #elif   HAVE_MMXEXT_INLINE
 616         pp = postProcess_MMX2;
 617 #elif HAVE_AMD3DNOW_INLINE
 618         pp = postProcess_3DNow;
 619 #elif HAVE_MMX_INLINE
 620         pp = postProcess_MMX;
 621 #elif HAVE_ALTIVEC
 622         pp = postProcess_altivec;
 623 #endif
 624 #endif /* !CONFIG_RUNTIME_CPUDETECT */
 625     }
 626
 627     pp(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
 628 }
 629
 630 /* -pp Command line Help
 631 */
 632 const char pp_help[] =
 633 "Available postprocessing filters:\n"
 634 "Filters                        Options\n"
 635 "short  long name       short   long option     Description\n"
 636 "*      *               a       autoq           CPU power dependent enabler\n"
 637 "                       c       chrom           chrominance filtering enabled\n"
 638 "                       y       nochrom         chrominance filtering disabled\n"
 639 "                       n       noluma          luma filtering disabled\n"
 640 "hb     hdeblock        (2 threshold)           horizontal deblocking filter\n"
 641 "       1. difference factor: default=32, higher -> more deblocking\n"
 642 "       2. flatness threshold: default=39, lower -> more deblocking\n"
 643 "                       the h & v deblocking filters share these\n"
 644 "                       so you can't set different thresholds for h / v\n"
 645 "vb     vdeblock        (2 threshold)           vertical deblocking filter\n"
 646 "ha     hadeblock       (2 threshold)           horizontal deblocking filter\n"
 647 "va     vadeblock       (2 threshold)           vertical deblocking filter\n"
 648 "h1     x1hdeblock                              experimental h deblock filter 1\n"
 649 "v1     x1vdeblock                              experimental v deblock filter 1\n"
 650 "dr     dering                                  deringing filter\n"
 651 "al     autolevels                              automatic brightness / contrast\n"
 652 "                       f        fullyrange     stretch luminance to (0..255)\n"
 653 "lb     linblenddeint                           linear blend deinterlacer\n"
 654 "li     linipoldeint                            linear interpolating deinterlace\n"
 655 "ci     cubicipoldeint                          cubic interpolating deinterlacer\n"
 656 "md     mediandeint                             median deinterlacer\n"
 657 "fd     ffmpegdeint                             ffmpeg deinterlacer\n"
 658 "l5     lowpass5                                FIR lowpass deinterlacer\n"
 659 "de     default                                 hb:a,vb:a,dr:a\n"
 660 "fa     fast                                    h1:a,v1:a,dr:a\n"
 661 "ac                                             ha:a:128:7,va:a,dr:a\n"
 662 "tn     tmpnoise        (3 threshold)           temporal noise reducer\n"
 663 "                     1. <= 2. <= 3.            larger -> stronger filtering\n"
 664 "fq     forceQuant      <quantizer>             force quantizer\n"
 665 "Usage:\n"
 666 "<filterName>[:<option>[:<option>...]][[,|/][-]<filterName>[:<option>...]]...\n"
 667 "long form example:\n"
 668 "vdeblock:autoq/hdeblock:autoq/linblenddeint    default,-vdeblock\n"
 669 "short form example:\n"
 670 "vb:a/hb:a/lb                                   de,-vb\n"
 671 "more examples:\n"
 672 "tn:64:128:256\n"
 673 "\n"
 674 ;
 675
 676 pp_mode *pp_get_mode_by_name_and_quality(const char *name, int quality)
 677 {
 678     char temp[GET_MODE_BUFFER_SIZE];
 679     char *p= temp;
 680     static const char filterDelimiters[] = ",/";
 681     static const char optionDelimiters[] = ":|";
 682     struct PPMode *ppMode;
 683     char *filterToken;
 684
 685     if (!name)  {
 686         av_log(NULL, AV_LOG_ERROR, "pp: Missing argument\n");
 687         return NULL;
 688     }
 689
 690     if (!strcmp(name, "help")) {
 691         const char *p;
 692         for (p = pp_help; strchr(p, '\n'); p = strchr(p, '\n') + 1) {
 693             av_strlcpy(temp, p, FFMIN(sizeof(temp), strchr(p, '\n') - p + 2));
 694             av_log(NULL, AV_LOG_INFO, "%s", temp);
 695         }
 696         return NULL;
 697     }
 698
 699     ppMode= av_malloc(sizeof(PPMode));
 700
 701     ppMode->lumMode= 0;
 702     ppMode->chromMode= 0;
 703     ppMode->maxTmpNoise[0]= 700;
 704     ppMode->maxTmpNoise[1]= 1500;
 705     ppMode->maxTmpNoise[2]= 3000;
 706     ppMode->maxAllowedY= 234;
 707     ppMode->minAllowedY= 16;
 708     ppMode->baseDcDiff= 256/8;
 709     ppMode->flatnessThreshold= 56-16-1;
 710     ppMode->maxClippedThreshold= 0.01;
 711     ppMode->error=0;
 712
 713     memset(temp, 0, GET_MODE_BUFFER_SIZE);
 714     av_strlcpy(temp, name, GET_MODE_BUFFER_SIZE - 1);
 715
 716     av_log(NULL, AV_LOG_DEBUG, "pp: %s\n", name);
 717
 718     for(;;){
 719         const char *filterName;
 720         int q= 1000000; //PP_QUALITY_MAX;
 721         int chrom=-1;
 722         int luma=-1;
 723         const char *option;
 724         const char *options[OPTIONS_ARRAY_SIZE];
 725         int i;
 726         int filterNameOk=0;
 727         int numOfUnknownOptions=0;
 728         int enable=1; //does the user want us to enabled or disabled the filter
 729         char *tokstate;
 730
 731         filterToken= av_strtok(p, filterDelimiters, &tokstate);
 732         if(!filterToken) break;
 733         p+= strlen(filterToken) + 1; // p points to next filterToken
 734         filterName= av_strtok(filterToken, optionDelimiters, &tokstate);
 735         if (!filterName) {
 736             ppMode->error++;
 737             break;
 738         }
 739         av_log(NULL, AV_LOG_DEBUG, "pp: %s::%s\n", filterToken, filterName);
 740
 741         if(*filterName == '-'){
 742             enable=0;
 743             filterName++;
 744         }
 745
 746         for(;;){ //for all options
 747             option= av_strtok(NULL, optionDelimiters, &tokstate);
 748             if(!option) break;
 749
 750             av_log(NULL, AV_LOG_DEBUG, "pp: option: %s\n", option);
 751             if(!strcmp("autoq", option) || !strcmp("a", option)) q= quality;
 752             else if(!strcmp("nochrom", option) || !strcmp("y", option)) chrom=0;
 753             else if(!strcmp("chrom", option) || !strcmp("c", option)) chrom=1;
 754             else if(!strcmp("noluma", option) || !strcmp("n", option)) luma=0;
 755             else{
 756                 options[numOfUnknownOptions] = option;
 757                 numOfUnknownOptions++;
 758             }
 759             if(numOfUnknownOptions >= OPTIONS_ARRAY_SIZE-1) break;
 760         }
 761         options[numOfUnknownOptions] = NULL;
 762
 763         /* replace stuff from the replace Table */
 764         for(i=0; replaceTable[2*i]; i++){
 765             if(!strcmp(replaceTable[2*i], filterName)){
 766                 int newlen= strlen(replaceTable[2*i + 1]);
 767                 int plen;
 768                 int spaceLeft;
 769
 770                 p--, *p=',';
 771
 772                 plen= strlen(p);
 773                 spaceLeft= p - temp + plen;
 774                 if(spaceLeft + newlen  >= GET_MODE_BUFFER_SIZE - 1){
 775                     ppMode->error++;
 776                     break;
 777                 }
 778                 memmove(p + newlen, p, plen+1);
 779                 memcpy(p, replaceTable[2*i + 1], newlen);
 780                 filterNameOk=1;
 781             }
 782         }
 783
 784         for(i=0; filters[i].shortName; i++){
 785             if(   !strcmp(filters[i].longName, filterName)
 786                || !strcmp(filters[i].shortName, filterName)){
 787                 ppMode->lumMode &= ~filters[i].mask;
 788                 ppMode->chromMode &= ~filters[i].mask;
 789
 790                 filterNameOk=1;
 791                 if(!enable) break; // user wants to disable it
 792
 793                 if(q >= filters[i].minLumQuality && luma)
 794                     ppMode->lumMode|= filters[i].mask;
 795                 if(chrom==1 || (chrom==-1 && filters[i].chromDefault))
 796                     if(q >= filters[i].minChromQuality)
 797                             ppMode->chromMode|= filters[i].mask;
 798
 799                 if(filters[i].mask == LEVEL_FIX){
 800                     int o;
 801                     ppMode->minAllowedY= 16;
 802                     ppMode->maxAllowedY= 234;
 803                     for(o=0; options[o]; o++){
 804                         if(  !strcmp(options[o],"fullyrange")
 805                            ||!strcmp(options[o],"f")){
 806                             ppMode->minAllowedY= 0;
 807                             ppMode->maxAllowedY= 255;
 808                             numOfUnknownOptions--;
 809                         }
 810                     }
 811                 }
 812                 else if(filters[i].mask == TEMP_NOISE_FILTER)
 813                 {
 814                     int o;
 815                     int numOfNoises=0;
 816
 817                     for(o=0; options[o]; o++){
 818                         char *tail;
 819                         ppMode->maxTmpNoise[numOfNoises]=
 820                             strtol(options[o], &tail, 0);
 821                         if(tail!=options[o]){
 822                             numOfNoises++;
 823                             numOfUnknownOptions--;
 824                             if(numOfNoises >= 3) break;
 825                         }
 826                     }
 827                 }
 828                 else if(filters[i].mask == V_DEBLOCK   || filters[i].mask == H_DEBLOCK
 829                      || filters[i].mask == V_A_DEBLOCK || filters[i].mask == H_A_DEBLOCK){
 830                     int o;
 831
 832                     for(o=0; options[o] && o<2; o++){
 833                         char *tail;
 834                         int val= strtol(options[o], &tail, 0);
 835                         if(tail==options[o]) break;
 836
 837                         numOfUnknownOptions--;
 838                         if(o==0) ppMode->baseDcDiff= val;
 839                         else ppMode->flatnessThreshold= val;
 840                     }
 841                 }
 842                 else if(filters[i].mask == FORCE_QUANT){
 843                     int o;
 844                     ppMode->forcedQuant= 15;
 845
 846                     for(o=0; options[o] && o<1; o++){
 847                         char *tail;
 848                         int val= strtol(options[o], &tail, 0);
 849                         if(tail==options[o]) break;
 850
 851                         numOfUnknownOptions--;
 852                         ppMode->forcedQuant= val;
 853                     }
 854                 }
 855             }
 856         }
 857         if(!filterNameOk) ppMode->error++;
 858         ppMode->error += numOfUnknownOptions;
 859     }
 860
 861     av_log(NULL, AV_LOG_DEBUG, "pp: lumMode=%X, chromMode=%X\n", ppMode->lumMode, ppMode->chromMode);
 862     if(ppMode->error){
 863         av_log(NULL, AV_LOG_ERROR, "%d errors in postprocess string \"%s\"\n", ppMode->error, name);
 864         av_free(ppMode);
 865         return NULL;
 866     }
 867     return ppMode;
 868 }
 869
 870 void pp_free_mode(pp_mode *mode){
 871     av_free(mode);
 872 }
 873
 874 static void reallocAlign(void **p, int size){
 875     av_free(*p);
 876     *p= av_mallocz(size);
 877 }
 878
 879 static void reallocBuffers(PPContext *c, int width, int height, int stride, int qpStride){
 880     int mbWidth = (width+15)>>4;
 881     int mbHeight= (height+15)>>4;
 882     int i;
 883
 884     c->stride= stride;
 885     c->qpStride= qpStride;
 886
 887     reallocAlign((void **)&c->tempDst, stride*24+32);
 888     reallocAlign((void **)&c->tempSrc, stride*24);
 889     reallocAlign((void **)&c->tempBlocks, 2*16*8);
 890     reallocAlign((void **)&c->yHistogram, 256*sizeof(uint64_t));
 891     for(i=0; i<256; i++)
 892             c->yHistogram[i]= width*height/64*15/256;
 893
 894     for(i=0; i<3; i++){
 895         //Note: The +17*1024 is just there so I do not have to worry about r/w over the end.
 896         reallocAlign((void **)&c->tempBlurred[i], stride*mbHeight*16 + 17*1024);
 897         reallocAlign((void **)&c->tempBlurredPast[i], 256*((height+7)&(~7))/2 + 17*1024);//FIXME size
 898     }
 899
 900     reallocAlign((void **)&c->deintTemp, 2*width+32);
 901     reallocAlign((void **)&c->nonBQPTable, qpStride*mbHeight*sizeof(QP_STORE_T));
 902     reallocAlign((void **)&c->stdQPTable, qpStride*mbHeight*sizeof(QP_STORE_T));
 903     reallocAlign((void **)&c->forcedQPTable, mbWidth*sizeof(QP_STORE_T));
 904 }
 905
 906 static const char * context_to_name(void * ptr) {
 907     return "postproc";
 908 }
 909
 910 static const AVClass av_codec_context_class = { "Postproc", context_to_name, NULL };
 911
 912 pp_context *pp_get_context(int width, int height, int cpuCaps){
 913     PPContext *c= av_malloc(sizeof(PPContext));
 914     int stride= FFALIGN(width, 16);  //assumed / will realloc if needed
 915     int qpStride= (width+15)/16 + 2; //assumed / will realloc if needed
 916
 917     memset(c, 0, sizeof(PPContext));
 918     c->av_class = &av_codec_context_class;
 919     if(cpuCaps&PP_FORMAT){
 920         c->hChromaSubSample= cpuCaps&0x3;
 921         c->vChromaSubSample= (cpuCaps>>4)&0x3;
 922     }else{
 923         c->hChromaSubSample= 1;
 924         c->vChromaSubSample= 1;
 925     }
 926     if (cpuCaps & PP_CPU_CAPS_AUTO) {
 927         c->cpuCaps = av_get_cpu_flags();
 928     } else {
 929         c->cpuCaps = 0;
 930         if (cpuCaps & PP_CPU_CAPS_MMX)      c->cpuCaps |= AV_CPU_FLAG_MMX;
 931         if (cpuCaps & PP_CPU_CAPS_MMX2)     c->cpuCaps |= AV_CPU_FLAG_MMXEXT;
 932         if (cpuCaps & PP_CPU_CAPS_3DNOW)    c->cpuCaps |= AV_CPU_FLAG_3DNOW;
 933         if (cpuCaps & PP_CPU_CAPS_ALTIVEC)  c->cpuCaps |= AV_CPU_FLAG_ALTIVEC;
 934     }
 935
 936     reallocBuffers(c, width, height, stride, qpStride);
 937
 938     c->frameNum=-1;
 939
 940     return c;
 941 }
 942
 943 void pp_free_context(void *vc){
 944     PPContext *c = (PPContext*)vc;
 945     int i;
 946
 947     for(i=0; i<FF_ARRAY_ELEMS(c->tempBlurred); i++)
 948         av_free(c->tempBlurred[i]);
 949     for(i=0; i<FF_ARRAY_ELEMS(c->tempBlurredPast); i++)
 950         av_free(c->tempBlurredPast[i]);
 951
 952     av_free(c->tempBlocks);
 953     av_free(c->yHistogram);
 954     av_free(c->tempDst);
 955     av_free(c->tempSrc);
 956     av_free(c->deintTemp);
 957     av_free(c->stdQPTable);
 958     av_free(c->nonBQPTable);
 959     av_free(c->forcedQPTable);
 960
 961     memset(c, 0, sizeof(PPContext));
 962
 963     av_free(c);
 964 }
 965
 966 void  pp_postprocess(const uint8_t * src[3], const int srcStride[3],
 967                      uint8_t * dst[3], const int dstStride[3],
 968                      int width, int height,
 969                      const QP_STORE_T *QP_store,  int QPStride,
 970                      pp_mode *vm,  void *vc, int pict_type)
 971 {
 972     int mbWidth = (width+15)>>4;
 973     int mbHeight= (height+15)>>4;
 974     PPMode *mode = vm;
 975     PPContext *c = vc;
 976     int minStride= FFMAX(FFABS(srcStride[0]), FFABS(dstStride[0]));
 977     int absQPStride = FFABS(QPStride);
 978
 979     // c->stride and c->QPStride are always positive
 980     if(c->stride < minStride || c->qpStride < absQPStride)
 981         reallocBuffers(c, width, height,
 982                        FFMAX(minStride, c->stride),
 983                        FFMAX(c->qpStride, absQPStride));
 984
 985     if(!QP_store || (mode->lumMode & FORCE_QUANT)){
 986         int i;
 987         QP_store= c->forcedQPTable;
 988         absQPStride = QPStride = 0;
 989         if(mode->lumMode & FORCE_QUANT)
 990             for(i=0; i<mbWidth; i++) c->forcedQPTable[i]= mode->forcedQuant;
 991         else
 992             for(i=0; i<mbWidth; i++) c->forcedQPTable[i]= 1;
 993     }
 994
 995     if(pict_type & PP_PICT_TYPE_QP2){
 996         int i;
 997         const int count= FFMAX(mbHeight * absQPStride, mbWidth);
 998         for(i=0; i<(count>>2); i++){
 999             ((uint32_t*)c->stdQPTable)[i] = (((const uint32_t*)QP_store)[i]>>1) & 0x7F7F7F7F;
1000         }
1001         for(i<<=2; i<count; i++){
1002             c->stdQPTable[i] = QP_store[i]>>1;
1003         }
1004         QP_store= c->stdQPTable;
1005         QPStride= absQPStride;
1006     }
1007
1008     if(0){
1009         int x,y;
1010         for(y=0; y<mbHeight; y++){
1011             for(x=0; x<mbWidth; x++){
1012                 av_log(c, AV_LOG_INFO, "%2d ", QP_store[x + y*QPStride]);
1013             }
1014             av_log(c, AV_LOG_INFO, "\n");
1015         }
1016         av_log(c, AV_LOG_INFO, "\n");
1017     }
1018
1019     if((pict_type&7)!=3){
1020         if (QPStride >= 0){
1021             int i;
1022             const int count= FFMAX(mbHeight * QPStride, mbWidth);
1023             for(i=0; i<(count>>2); i++){
1024                 ((uint32_t*)c->nonBQPTable)[i] = ((const uint32_t*)QP_store)[i] & 0x3F3F3F3F;
1025             }
1026             for(i<<=2; i<count; i++){
1027                 c->nonBQPTable[i] = QP_store[i] & 0x3F;
1028             }
1029         } else {
1030             int i,j;
1031             for(i=0; i<mbHeight; i++) {
1032                 for(j=0; j<absQPStride; j++) {
1033                     c->nonBQPTable[i*absQPStride+j] = QP_store[i*QPStride+j] & 0x3F;
1034                 }
1035             }
1036         }
1037     }
1038
1039     av_log(c, AV_LOG_DEBUG, "using npp filters 0x%X/0x%X\n",
1040            mode->lumMode, mode->chromMode);
1041
1042     postProcess(src[0], srcStride[0], dst[0], dstStride[0],
1043                 width, height, QP_store, QPStride, 0, mode, c);
1044
1045     if (!(src[1] && src[2] && dst[1] && dst[2]))
1046         return;
1047
1048     width  = (width )>>c->hChromaSubSample;
1049     height = (height)>>c->vChromaSubSample;
1050
1051     if(mode->chromMode){
1052         postProcess(src[1], srcStride[1], dst[1], dstStride[1],
1053                     width, height, QP_store, QPStride, 1, mode, c);
1054         postProcess(src[2], srcStride[2], dst[2], dstStride[2],
1055                     width, height, QP_store, QPStride, 2, mode, c);
1056     }
1057     else if(srcStride[1] == dstStride[1] && srcStride[2] == dstStride[2]){
1058         linecpy(dst[1], src[1], height, srcStride[1]);
1059         linecpy(dst[2], src[2], height, srcStride[2]);
1060     }else{
1061         int y;
1062         for(y=0; y<height; y++){
1063             memcpy(&(dst[1][y*dstStride[1]]), &(src[1][y*srcStride[1]]), width);
1064             memcpy(&(dst[2][y*dstStride[2]]), &(src[2][y*srcStride[2]]), width);
1065         }
1066     }
1067 }