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