Clarify comment about parity nibble.
[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 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