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