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