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