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