avcodec: add a public function, avcodec_fill_audio_frame().
[libav.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 }