Mercurial > libpostproc.hg

comparison postprocess.c @ 0:7c419ceafa6a libpostproc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
libavcodec/libpostproc ---> libpostproc
author diego
date Thu, 01 Jun 2006 21:37:48 +0000
parents
children 7e8d09893454
comparison
equal deleted inserted replaced
-1:000000000000 0:7c419ceafa6a
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 program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /**
22 * @file postprocess.c
23 * postprocessing.
24 */
25
26 /*
27 C MMX MMX2 3DNow AltiVec
28 isVertDC Ec Ec Ec
29 isVertMinMaxOk Ec Ec Ec
30 doVertLowPass E e e Ec
31 doVertDefFilter Ec Ec e e Ec
32 isHorizDC Ec Ec Ec
33 isHorizMinMaxOk a E Ec
34 doHorizLowPass E e e Ec
35 doHorizDefFilter Ec Ec e e Ec
36 do_a_deblock Ec E Ec E
37 deRing E e e* Ecp
38 Vertical RKAlgo1 E a a
39 Horizontal RKAlgo1 a a
40 Vertical X1# a E E
41 Horizontal X1# a E E
42 LinIpolDeinterlace e E E*
43 CubicIpolDeinterlace a e e*
44 LinBlendDeinterlace e E E*
45 MedianDeinterlace# E Ec Ec
46 TempDeNoiser# E e e Ec
47
48 * i dont have a 3dnow CPU -> its untested, but noone said it doesnt work so it seems to work
49 # more or less selfinvented filters so the exactness isnt too meaningfull
50 E = Exact implementation
51 e = allmost exact implementation (slightly different rounding,...)
52 a = alternative / approximate impl
53 c = checked against the other implementations (-vo md5)
54 p = partially optimized, still some work to do
55 */
56
57 /*
58 TODO:
59 reduce the time wasted on the mem transfer
60 unroll stuff if instructions depend too much on the prior one
61 move YScale thing to the end instead of fixing QP
62 write a faster and higher quality deblocking filter :)
63 make the mainloop more flexible (variable number of blocks at once
64 (the if/else stuff per block is slowing things down)
65 compare the quality & speed of all filters
66 split this huge file
67 optimize c versions
68 try to unroll inner for(x=0 ... loop to avoid these damn if(x ... checks
69 ...
70 */
71
72 //Changelog: use the CVS log
73
74 #include "config.h"
75 #include <inttypes.h>
76 #include <stdio.h>
77 #include <stdlib.h>
78 #include <string.h>
79 #ifdef HAVE_MALLOC_H
80 #include <malloc.h>
81 #endif
82 //#undef HAVE_MMX2
83 //#define HAVE_3DNOW
84 //#undef HAVE_MMX
85 //#undef ARCH_X86
86 //#define DEBUG_BRIGHTNESS
87 #ifdef USE_FASTMEMCPY
88 #include "fastmemcpy.h"
89 #endif
90 #include "postprocess.h"
91 #include "postprocess_internal.h"
92
93 #include "mangle.h" //FIXME should be supressed
94
95 #ifdef HAVE_ALTIVEC_H
96 #include <altivec.h>
97 #endif
98
99 #ifndef HAVE_MEMALIGN
100 #define memalign(a,b) malloc(b)
101 #endif
102
103 #define MIN(a,b) ((a) > (b) ? (b) : (a))
104 #define MAX(a,b) ((a) < (b) ? (b) : (a))
105 #define ABS(a) ((a) > 0 ? (a) : (-(a)))
106 #define SIGN(a) ((a) > 0 ? 1 : -1)
107
108 #define GET_MODE_BUFFER_SIZE 500
109 #define OPTIONS_ARRAY_SIZE 10
110 #define BLOCK_SIZE 8
111 #define TEMP_STRIDE 8
112 //#define NUM_BLOCKS_AT_ONCE 16 //not used yet
113
114 #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
115 # define attribute_used __attribute__((used))
116 # define always_inline __attribute__((always_inline)) inline
117 #else
118 # define attribute_used
119 # define always_inline inline
120 #endif
121
122 #if defined(ARCH_X86) || defined(ARCH_X86_64)
123 static uint64_t __attribute__((aligned(8))) attribute_used w05= 0x0005000500050005LL;
124 static uint64_t __attribute__((aligned(8))) attribute_used w04= 0x0004000400040004LL;
125 static uint64_t __attribute__((aligned(8))) attribute_used w20= 0x0020002000200020LL;
126 static uint64_t __attribute__((aligned(8))) attribute_used b00= 0x0000000000000000LL;
127 static uint64_t __attribute__((aligned(8))) attribute_used b01= 0x0101010101010101LL;
128 static uint64_t __attribute__((aligned(8))) attribute_used b02= 0x0202020202020202LL;
129 static uint64_t __attribute__((aligned(8))) attribute_used b08= 0x0808080808080808LL;
130 static uint64_t __attribute__((aligned(8))) attribute_used b80= 0x8080808080808080LL;
131 #endif
132
133 static uint8_t clip_table[3*256];
134 static uint8_t * const clip_tab= clip_table + 256;
135
136 static const int verbose= 0;
137
138 static const int attribute_used deringThreshold= 20;
139
140
141 static struct PPFilter filters[]=
142 {
143 {"hb", "hdeblock", 1, 1, 3, H_DEBLOCK},
144 {"vb", "vdeblock", 1, 2, 4, V_DEBLOCK},
145 /* {"hr", "rkhdeblock", 1, 1, 3, H_RK1_FILTER},
146 {"vr", "rkvdeblock", 1, 2, 4, V_RK1_FILTER},*/
147 {"h1", "x1hdeblock", 1, 1, 3, H_X1_FILTER},
148 {"v1", "x1vdeblock", 1, 2, 4, V_X1_FILTER},
149 {"ha", "ahdeblock", 1, 1, 3, H_A_DEBLOCK},
150 {"va", "avdeblock", 1, 2, 4, V_A_DEBLOCK},
151 {"dr", "dering", 1, 5, 6, DERING},
152 {"al", "autolevels", 0, 1, 2, LEVEL_FIX},
153 {"lb", "linblenddeint", 1, 1, 4, LINEAR_BLEND_DEINT_FILTER},
154 {"li", "linipoldeint", 1, 1, 4, LINEAR_IPOL_DEINT_FILTER},
155 {"ci", "cubicipoldeint", 1, 1, 4, CUBIC_IPOL_DEINT_FILTER},
156 {"md", "mediandeint", 1, 1, 4, MEDIAN_DEINT_FILTER},
157 {"fd", "ffmpegdeint", 1, 1, 4, FFMPEG_DEINT_FILTER},
158 {"l5", "lowpass5", 1, 1, 4, LOWPASS5_DEINT_FILTER},
159 {"tn", "tmpnoise", 1, 7, 8, TEMP_NOISE_FILTER},
160 {"fq", "forcequant", 1, 0, 0, FORCE_QUANT},
161 {NULL, NULL,0,0,0,0} //End Marker
162 };
163
164 static char *replaceTable[]=
165 {
166 "default", "hdeblock:a,vdeblock:a,dering:a",
167 "de", "hdeblock:a,vdeblock:a,dering:a",
168 "fast", "x1hdeblock:a,x1vdeblock:a,dering:a",
169 "fa", "x1hdeblock:a,x1vdeblock:a,dering:a",
170 "ac", "ha:a:128:7,va:a,dering:a",
171 NULL //End Marker
172 };
173
174
175 #if defined(ARCH_X86) || defined(ARCH_X86_64)
176 static inline void prefetchnta(void *p)
177 {
178 asm volatile( "prefetchnta (%0)\n\t"
179 : : "r" (p)
180 );
181 }
182
183 static inline void prefetcht0(void *p)
184 {
185 asm volatile( "prefetcht0 (%0)\n\t"
186 : : "r" (p)
187 );
188 }
189
190 static inline void prefetcht1(void *p)
191 {
192 asm volatile( "prefetcht1 (%0)\n\t"
193 : : "r" (p)
194 );
195 }
196
197 static inline void prefetcht2(void *p)
198 {
199 asm volatile( "prefetcht2 (%0)\n\t"
200 : : "r" (p)
201 );
202 }
203 #endif
204
205 // The horizontal Functions exist only in C cuz the MMX code is faster with vertical filters and transposing
206
207 /**
208 * Check if the given 8x8 Block is mostly "flat"
209 */
210 static inline int isHorizDC_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 for(y=0; y<BLOCK_SIZE; y++)
218 {
219 if(((unsigned)(src[0] - src[1] + dcOffset)) < dcThreshold) numEq++;
220 if(((unsigned)(src[1] - src[2] + dcOffset)) < dcThreshold) numEq++;
221 if(((unsigned)(src[2] - src[3] + dcOffset)) < dcThreshold) numEq++;
222 if(((unsigned)(src[3] - src[4] + dcOffset)) < dcThreshold) numEq++;
223 if(((unsigned)(src[4] - src[5] + dcOffset)) < dcThreshold) numEq++;
224 if(((unsigned)(src[5] - src[6] + dcOffset)) < dcThreshold) numEq++;
225 if(((unsigned)(src[6] - src[7] + dcOffset)) < dcThreshold) numEq++;
226 src+= stride;
227 }
228 return numEq > c->ppMode.flatnessThreshold;
229 }
230
231 /**
232 * Check if the middle 8x8 Block in the given 8x16 block is flat
233 */
234 static inline int isVertDC_C(uint8_t src[], int stride, PPContext *c){
235 int numEq= 0;
236 int y;
237 const int dcOffset= ((c->nonBQP*c->ppMode.baseDcDiff)>>8) + 1;
238 const int dcThreshold= dcOffset*2 + 1;
239
240 src+= stride*4; // src points to begin of the 8x8 Block
241 for(y=0; y<BLOCK_SIZE-1; y++)
242 {
243 if(((unsigned)(src[0] - src[0+stride] + dcOffset)) < dcThreshold) numEq++;
244 if(((unsigned)(src[1] - src[1+stride] + dcOffset)) < dcThreshold) numEq++;
245 if(((unsigned)(src[2] - src[2+stride] + dcOffset)) < dcThreshold) numEq++;
246 if(((unsigned)(src[3] - src[3+stride] + dcOffset)) < dcThreshold) numEq++;
247 if(((unsigned)(src[4] - src[4+stride] + dcOffset)) < dcThreshold) numEq++;
248 if(((unsigned)(src[5] - src[5+stride] + dcOffset)) < dcThreshold) numEq++;
249 if(((unsigned)(src[6] - src[6+stride] + dcOffset)) < dcThreshold) numEq++;
250 if(((unsigned)(src[7] - src[7+stride] + dcOffset)) < dcThreshold) numEq++;
251 src+= stride;
252 }
253 return numEq > c->ppMode.flatnessThreshold;
254 }
255
256 static inline int isHorizMinMaxOk_C(uint8_t src[], int stride, int QP)
257 {
258 int i;
259 #if 1
260 for(i=0; i<2; i++){
261 if((unsigned)(src[0] - src[5] + 2*QP) > 4*QP) return 0;
262 src += stride;
263 if((unsigned)(src[2] - src[7] + 2*QP) > 4*QP) return 0;
264 src += stride;
265 if((unsigned)(src[4] - src[1] + 2*QP) > 4*QP) return 0;
266 src += stride;
267 if((unsigned)(src[6] - src[3] + 2*QP) > 4*QP) return 0;
268 src += stride;
269 }
270 #else
271 for(i=0; i<8; i++){
272 if((unsigned)(src[0] - src[7] + 2*QP) > 4*QP) return 0;
273 src += stride;
274 }
275 #endif
276 return 1;
277 }
278
279 static inline int isVertMinMaxOk_C(uint8_t src[], int stride, int QP)
280 {
281 #if 1
282 #if 1
283 int x;
284 src+= stride*4;
285 for(x=0; x<BLOCK_SIZE; x+=4)
286 {
287 if((unsigned)(src[ x + 0*stride] - src[ x + 5*stride] + 2*QP) > 4*QP) return 0;
288 if((unsigned)(src[1+x + 2*stride] - src[1+x + 7*stride] + 2*QP) > 4*QP) return 0;
289 if((unsigned)(src[2+x + 4*stride] - src[2+x + 1*stride] + 2*QP) > 4*QP) return 0;
290 if((unsigned)(src[3+x + 6*stride] - src[3+x + 3*stride] + 2*QP) > 4*QP) return 0;
291 }
292 #else
293 int x;
294 src+= stride*3;
295 for(x=0; x<BLOCK_SIZE; x++)
296 {
297 if((unsigned)(src[x + stride] - src[x + (stride<<3)] + 2*QP) > 4*QP) return 0;
298 }
299 #endif
300 return 1;
301 #else
302 int x;
303 src+= stride*4;
304 for(x=0; x<BLOCK_SIZE; x++)
305 {
306 int min=255;
307 int max=0;
308 int y;
309 for(y=0; y<8; y++){
310 int v= src[x + y*stride];
311 if(v>max) max=v;
312 if(v<min) min=v;
313 }
314 if(max-min > 2*QP) return 0;
315 }
316 return 1;
317 #endif
318 }
319
320 static inline int horizClassify_C(uint8_t src[], int stride, PPContext *c){
321 if( isHorizDC_C(src, stride, c) ){
322 if( isHorizMinMaxOk_C(src, stride, c->QP) )
323 return 1;
324 else
325 return 0;
326 }else{
327 return 2;
328 }
329 }
330
331 static inline int vertClassify_C(uint8_t src[], int stride, PPContext *c){
332 if( isVertDC_C(src, stride, c) ){
333 if( isVertMinMaxOk_C(src, stride, c->QP) )
334 return 1;
335 else
336 return 0;
337 }else{
338 return 2;
339 }
340 }
341
342 static inline void doHorizDefFilter_C(uint8_t dst[], int stride, PPContext *c)
343 {
344 int y;
345 for(y=0; y<BLOCK_SIZE; y++)
346 {
347 const int middleEnergy= 5*(dst[4] - dst[3]) + 2*(dst[2] - dst[5]);
348
349 if(ABS(middleEnergy) < 8*c->QP)
350 {
351 const int q=(dst[3] - dst[4])/2;
352 const int leftEnergy= 5*(dst[2] - dst[1]) + 2*(dst[0] - dst[3]);
353 const int rightEnergy= 5*(dst[6] - dst[5]) + 2*(dst[4] - dst[7]);
354
355 int d= ABS(middleEnergy) - MIN( ABS(leftEnergy), ABS(rightEnergy) );
356 d= MAX(d, 0);
357
358 d= (5*d + 32) >> 6;
359 d*= SIGN(-middleEnergy);
360
361 if(q>0)
362 {
363 d= d<0 ? 0 : d;
364 d= d>q ? q : d;
365 }
366 else
367 {
368 d= d>0 ? 0 : d;
369 d= d<q ? q : d;
370 }
371
372 dst[3]-= d;
373 dst[4]+= d;
374 }
375 dst+= stride;
376 }
377 }
378
379 /**
380 * Do a horizontal low pass filter on the 10x8 block (dst points to middle 8x8 Block)
381 * using the 9-Tap Filter (1,1,2,2,4,2,2,1,1)/16 (C version)
382 */
383 static inline void doHorizLowPass_C(uint8_t dst[], int stride, PPContext *c)
384 {
385 int y;
386 for(y=0; y<BLOCK_SIZE; y++)
387 {
388 const int first= ABS(dst[-1] - dst[0]) < c->QP ? dst[-1] : dst[0];
389 const int last= ABS(dst[8] - dst[7]) < c->QP ? dst[8] : dst[7];
390
391 int sums[10];
392 sums[0] = 4*first + dst[0] + dst[1] + dst[2] + 4;
393 sums[1] = sums[0] - first + dst[3];
394 sums[2] = sums[1] - first + dst[4];
395 sums[3] = sums[2] - first + dst[5];
396 sums[4] = sums[3] - first + dst[6];
397 sums[5] = sums[4] - dst[0] + dst[7];
398 sums[6] = sums[5] - dst[1] + last;
399 sums[7] = sums[6] - dst[2] + last;
400 sums[8] = sums[7] - dst[3] + last;
401 sums[9] = sums[8] - dst[4] + last;
402
403 dst[0]= (sums[0] + sums[2] + 2*dst[0])>>4;
404 dst[1]= (sums[1] + sums[3] + 2*dst[1])>>4;
405 dst[2]= (sums[2] + sums[4] + 2*dst[2])>>4;
406 dst[3]= (sums[3] + sums[5] + 2*dst[3])>>4;
407 dst[4]= (sums[4] + sums[6] + 2*dst[4])>>4;
408 dst[5]= (sums[5] + sums[7] + 2*dst[5])>>4;
409 dst[6]= (sums[6] + sums[8] + 2*dst[6])>>4;
410 dst[7]= (sums[7] + sums[9] + 2*dst[7])>>4;
411
412 dst+= stride;
413 }
414 }
415
416 /**
417 * Experimental Filter 1 (Horizontal)
418 * will not damage linear gradients
419 * Flat blocks should look like they where passed through the (1,1,2,2,4,2,2,1,1) 9-Tap filter
420 * can only smooth blocks at the expected locations (it cant smooth them if they did move)
421 * MMX2 version does correct clipping C version doesnt
422 * not identical with the vertical one
423 */
424 static inline void horizX1Filter(uint8_t *src, int stride, int QP)
425 {
426 int y;
427 static uint64_t *lut= NULL;
428 if(lut==NULL)
429 {
430 int i;
431 lut= (uint64_t*)memalign(8, 256*8);
432 for(i=0; i<256; i++)
433 {
434 int v= i < 128 ? 2*i : 2*(i-256);
435 /*
436 //Simulate 112242211 9-Tap filter
437 uint64_t a= (v/16) & 0xFF;
438 uint64_t b= (v/8) & 0xFF;
439 uint64_t c= (v/4) & 0xFF;
440 uint64_t d= (3*v/8) & 0xFF;
441 */
442 //Simulate piecewise linear interpolation
443 uint64_t a= (v/16) & 0xFF;
444 uint64_t b= (v*3/16) & 0xFF;
445 uint64_t c= (v*5/16) & 0xFF;
446 uint64_t d= (7*v/16) & 0xFF;
447 uint64_t A= (0x100 - a)&0xFF;
448 uint64_t B= (0x100 - b)&0xFF;
449 uint64_t C= (0x100 - c)&0xFF;
450 uint64_t D= (0x100 - c)&0xFF;
451
452 lut[i] = (a<<56) | (b<<48) | (c<<40) | (d<<32) |
453 (D<<24) | (C<<16) | (B<<8) | (A);
454 //lut[i] = (v<<32) | (v<<24);
455 }
456 }
457
458 for(y=0; y<BLOCK_SIZE; y++)
459 {
460 int a= src[1] - src[2];
461 int b= src[3] - src[4];
462 int c= src[5] - src[6];
463
464 int d= MAX(ABS(b) - (ABS(a) + ABS(c))/2, 0);
465
466 if(d < QP)
467 {
468 int v = d * SIGN(-b);
469
470 src[1] +=v/8;
471 src[2] +=v/4;
472 src[3] +=3*v/8;
473 src[4] -=3*v/8;
474 src[5] -=v/4;
475 src[6] -=v/8;
476
477 }
478 src+=stride;
479 }
480 }
481
482 /**
483 * accurate deblock filter
484 */
485 static always_inline void do_a_deblock_C(uint8_t *src, int step, int stride, PPContext *c){
486 int y;
487 const int QP= c->QP;
488 const int dcOffset= ((c->nonBQP*c->ppMode.baseDcDiff)>>8) + 1;
489 const int dcThreshold= dcOffset*2 + 1;
490 //START_TIMER
491 src+= step*4; // src points to begin of the 8x8 Block
492 for(y=0; y<8; y++){
493 int numEq= 0;
494
495 if(((unsigned)(src[-1*step] - src[0*step] + dcOffset)) < dcThreshold) numEq++;
496 if(((unsigned)(src[ 0*step] - src[1*step] + dcOffset)) < dcThreshold) numEq++;
497 if(((unsigned)(src[ 1*step] - src[2*step] + dcOffset)) < dcThreshold) numEq++;
498 if(((unsigned)(src[ 2*step] - src[3*step] + dcOffset)) < dcThreshold) numEq++;
499 if(((unsigned)(src[ 3*step] - src[4*step] + dcOffset)) < dcThreshold) numEq++;
500 if(((unsigned)(src[ 4*step] - src[5*step] + dcOffset)) < dcThreshold) numEq++;
501 if(((unsigned)(src[ 5*step] - src[6*step] + dcOffset)) < dcThreshold) numEq++;
502 if(((unsigned)(src[ 6*step] - src[7*step] + dcOffset)) < dcThreshold) numEq++;
503 if(((unsigned)(src[ 7*step] - src[8*step] + dcOffset)) < dcThreshold) numEq++;
504 if(numEq > c->ppMode.flatnessThreshold){
505 int min, max, x;
506
507 if(src[0] > src[step]){
508 max= src[0];
509 min= src[step];
510 }else{
511 max= src[step];
512 min= src[0];
513 }
514 for(x=2; x<8; x+=2){
515 if(src[x*step] > src[(x+1)*step]){
516 if(src[x *step] > max) max= src[ x *step];
517 if(src[(x+1)*step] < min) min= src[(x+1)*step];
518 }else{
519 if(src[(x+1)*step] > max) max= src[(x+1)*step];
520 if(src[ x *step] < min) min= src[ x *step];
521 }
522 }
523 if(max-min < 2*QP){
524 const int first= ABS(src[-1*step] - src[0]) < QP ? src[-1*step] : src[0];
525 const int last= ABS(src[8*step] - src[7*step]) < QP ? src[8*step] : src[7*step];
526
527 int sums[10];
528 sums[0] = 4*first + src[0*step] + src[1*step] + src[2*step] + 4;
529 sums[1] = sums[0] - first + src[3*step];
530 sums[2] = sums[1] - first + src[4*step];
531 sums[3] = sums[2] - first + src[5*step];
532 sums[4] = sums[3] - first + src[6*step];
533 sums[5] = sums[4] - src[0*step] + src[7*step];
534 sums[6] = sums[5] - src[1*step] + last;
535 sums[7] = sums[6] - src[2*step] + last;
536 sums[8] = sums[7] - src[3*step] + last;
537 sums[9] = sums[8] - src[4*step] + last;
538
539 src[0*step]= (sums[0] + sums[2] + 2*src[0*step])>>4;
540 src[1*step]= (sums[1] + sums[3] + 2*src[1*step])>>4;
541 src[2*step]= (sums[2] + sums[4] + 2*src[2*step])>>4;
542 src[3*step]= (sums[3] + sums[5] + 2*src[3*step])>>4;
543 src[4*step]= (sums[4] + sums[6] + 2*src[4*step])>>4;
544 src[5*step]= (sums[5] + sums[7] + 2*src[5*step])>>4;
545 src[6*step]= (sums[6] + sums[8] + 2*src[6*step])>>4;
546 src[7*step]= (sums[7] + sums[9] + 2*src[7*step])>>4;
547 }
548 }else{
549 const int middleEnergy= 5*(src[4*step] - src[3*step]) + 2*(src[2*step] - src[5*step]);
550
551 if(ABS(middleEnergy) < 8*QP)
552 {
553 const int q=(src[3*step] - src[4*step])/2;
554 const int leftEnergy= 5*(src[2*step] - src[1*step]) + 2*(src[0*step] - src[3*step]);
555 const int rightEnergy= 5*(src[6*step] - src[5*step]) + 2*(src[4*step] - src[7*step]);
556
557 int d= ABS(middleEnergy) - MIN( ABS(leftEnergy), ABS(rightEnergy) );
558 d= MAX(d, 0);
559
560 d= (5*d + 32) >> 6;
561 d*= SIGN(-middleEnergy);
562
563 if(q>0)
564 {
565 d= d<0 ? 0 : d;
566 d= d>q ? q : d;
567 }
568 else
569 {
570 d= d>0 ? 0 : d;
571 d= d<q ? q : d;
572 }
573
574 src[3*step]-= d;
575 src[4*step]+= d;
576 }
577 }
578
579 src += stride;
580 }
581 /*if(step==16){
582 STOP_TIMER("step16")
583 }else{
584 STOP_TIMER("stepX")
585 }*/
586 }
587
588 //Note: we have C, MMX, MMX2, 3DNOW version there is no 3DNOW+MMX2 one
589 //Plain C versions
590 #if !defined (HAVE_MMX) || defined (RUNTIME_CPUDETECT)
591 #define COMPILE_C
592 #endif
593
594 #ifdef ARCH_POWERPC
595 #ifdef HAVE_ALTIVEC
596 #define COMPILE_ALTIVEC
597 #endif //HAVE_ALTIVEC
598 #endif //ARCH_POWERPC
599
600 #if defined(ARCH_X86) || defined(ARCH_X86_64)
601
602 #if (defined (HAVE_MMX) && !defined (HAVE_3DNOW) && !defined (HAVE_MMX2)) || defined (RUNTIME_CPUDETECT)
603 #define COMPILE_MMX
604 #endif
605
606 #if defined (HAVE_MMX2) || defined (RUNTIME_CPUDETECT)
607 #define COMPILE_MMX2
608 #endif
609
610 #if (defined (HAVE_3DNOW) && !defined (HAVE_MMX2)) || defined (RUNTIME_CPUDETECT)
611 #define COMPILE_3DNOW
612 #endif
613 #endif //ARCH_X86
614
615 #undef HAVE_MMX
616 #undef HAVE_MMX2
617 #undef HAVE_3DNOW
618 #undef HAVE_ALTIVEC
619
620 #ifdef COMPILE_C
621 #undef HAVE_MMX
622 #undef HAVE_MMX2
623 #undef HAVE_3DNOW
624 #define RENAME(a) a ## _C
625 #include "postprocess_template.c"
626 #endif
627
628 #ifdef ARCH_POWERPC
629 #ifdef COMPILE_ALTIVEC
630 #undef RENAME
631 #define HAVE_ALTIVEC
632 #define RENAME(a) a ## _altivec
633 #include "postprocess_altivec_template.c"
634 #include "postprocess_template.c"
635 #endif
636 #endif //ARCH_POWERPC
637
638 //MMX versions
639 #ifdef COMPILE_MMX
640 #undef RENAME
641 #define HAVE_MMX
642 #undef HAVE_MMX2
643 #undef HAVE_3DNOW
644 #define RENAME(a) a ## _MMX
645 #include "postprocess_template.c"
646 #endif
647
648 //MMX2 versions
649 #ifdef COMPILE_MMX2
650 #undef RENAME
651 #define HAVE_MMX
652 #define HAVE_MMX2
653 #undef HAVE_3DNOW
654 #define RENAME(a) a ## _MMX2
655 #include "postprocess_template.c"
656 #endif
657
658 //3DNOW versions
659 #ifdef COMPILE_3DNOW
660 #undef RENAME
661 #define HAVE_MMX
662 #undef HAVE_MMX2
663 #define HAVE_3DNOW
664 #define RENAME(a) a ## _3DNow
665 #include "postprocess_template.c"
666 #endif
667
668 // minor note: the HAVE_xyz is messed up after that line so dont use it
669
670 static inline void postProcess(uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
671 QP_STORE_T QPs[], int QPStride, int isColor, pp_mode_t *vm, pp_context_t *vc)
672 {
673 PPContext *c= (PPContext *)vc;
674 PPMode *ppMode= (PPMode *)vm;
675 c->ppMode= *ppMode; //FIXME
676
677 // useing ifs here as they are faster than function pointers allthough the
678 // difference wouldnt be messureable here but its much better because
679 // someone might exchange the cpu whithout restarting mplayer ;)
680 #ifdef RUNTIME_CPUDETECT
681 #if defined(ARCH_X86) || defined(ARCH_X86_64)
682 // ordered per speed fasterst first
683 if(c->cpuCaps & PP_CPU_CAPS_MMX2)
684 postProcess_MMX2(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
685 else if(c->cpuCaps & PP_CPU_CAPS_3DNOW)
686 postProcess_3DNow(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
687 else if(c->cpuCaps & PP_CPU_CAPS_MMX)
688 postProcess_MMX(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
689 else
690 postProcess_C(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
691 #else
692 #ifdef ARCH_POWERPC
693 #ifdef HAVE_ALTIVEC
694 if(c->cpuCaps & PP_CPU_CAPS_ALTIVEC)
695 postProcess_altivec(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
696 else
697 #endif
698 #endif
699 postProcess_C(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
700 #endif
701 #else //RUNTIME_CPUDETECT
702 #ifdef HAVE_MMX2
703 postProcess_MMX2(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
704 #elif defined (HAVE_3DNOW)
705 postProcess_3DNow(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
706 #elif defined (HAVE_MMX)
707 postProcess_MMX(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
708 #elif defined (HAVE_ALTIVEC)
709 postProcess_altivec(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
710 #else
711 postProcess_C(src, srcStride, dst, dstStride, width, height, QPs, QPStride, isColor, c);
712 #endif
713 #endif //!RUNTIME_CPUDETECT
714 }
715
716 //static void postProcess(uint8_t src[], int srcStride, uint8_t dst[], int dstStride, int width, int height,
717 // QP_STORE_T QPs[], int QPStride, int isColor, struct PPMode *ppMode);
718
719 /* -pp Command line Help
720 */
721 char *pp_help=
722 "Available postprocessing filters:\n"
723 "Filters Options\n"
724 "short long name short long option Description\n"
725 "* * a autoq CPU power dependent enabler\n"
726 " c chrom chrominance filtering enabled\n"
727 " y nochrom chrominance filtering disabled\n"
728 " n noluma luma filtering disabled\n"
729 "hb hdeblock (2 threshold) horizontal deblocking filter\n"
730 " 1. difference factor: default=32, higher -> more deblocking\n"
731 " 2. flatness threshold: default=39, lower -> more deblocking\n"
732 " the h & v deblocking filters share these\n"
733 " so you can't set different thresholds for h / v\n"
734 "vb vdeblock (2 threshold) vertical deblocking filter\n"
735 "ha hadeblock (2 threshold) horizontal deblocking filter\n"
736 "va vadeblock (2 threshold) vertical deblocking filter\n"
737 "h1 x1hdeblock experimental h deblock filter 1\n"
738 "v1 x1vdeblock experimental v deblock filter 1\n"
739 "dr dering deringing filter\n"
740 "al autolevels automatic brightness / contrast\n"
741 " f fullyrange stretch luminance to (0..255)\n"
742 "lb linblenddeint linear blend deinterlacer\n"
743 "li linipoldeint linear interpolating deinterlace\n"
744 "ci cubicipoldeint cubic interpolating deinterlacer\n"
745 "md mediandeint median deinterlacer\n"
746 "fd ffmpegdeint ffmpeg deinterlacer\n"
747 "l5 lowpass5 FIR lowpass deinterlacer\n"
748 "de default hb:a,vb:a,dr:a\n"
749 "fa fast h1:a,v1:a,dr:a\n"
750 "ac ha:a:128:7,va:a,dr:a\n"
751 "tn tmpnoise (3 threshold) temporal noise reducer\n"
752 " 1. <= 2. <= 3. larger -> stronger filtering\n"
753 "fq forceQuant <quantizer> force quantizer\n"
754 "Usage:\n"
755 "<filterName>[:<option>[:<option>...]][[,|/][-]<filterName>[:<option>...]]...\n"
756 "long form example:\n"
757 "vdeblock:autoq/hdeblock:autoq/linblenddeint default,-vdeblock\n"
758 "short form example:\n"
759 "vb:a/hb:a/lb de,-vb\n"
760 "more examples:\n"
761 "tn:64:128:256\n"
762 "\n"
763 ;
764
765 pp_mode_t *pp_get_mode_by_name_and_quality(char *name, int quality)
766 {
767 char temp[GET_MODE_BUFFER_SIZE];
768 char *p= temp;
769 char *filterDelimiters= ",/";
770 char *optionDelimiters= ":";
771 struct PPMode *ppMode;
772 char *filterToken;
773
774 ppMode= memalign(8, sizeof(PPMode));
775
776 ppMode->lumMode= 0;
777 ppMode->chromMode= 0;
778 ppMode->maxTmpNoise[0]= 700;
779 ppMode->maxTmpNoise[1]= 1500;
780 ppMode->maxTmpNoise[2]= 3000;
781 ppMode->maxAllowedY= 234;
782 ppMode->minAllowedY= 16;
783 ppMode->baseDcDiff= 256/8;
784 ppMode->flatnessThreshold= 56-16-1;
785 ppMode->maxClippedThreshold= 0.01;
786 ppMode->error=0;
787
788 strncpy(temp, name, GET_MODE_BUFFER_SIZE);
789
790 if(verbose>1) printf("pp: %s\n", name);
791
792 for(;;){
793 char *filterName;
794 int q= 1000000; //PP_QUALITY_MAX;
795 int chrom=-1;
796 int luma=-1;
797 char *option;
798 char *options[OPTIONS_ARRAY_SIZE];
799 int i;
800 int filterNameOk=0;
801 int numOfUnknownOptions=0;
802 int enable=1; //does the user want us to enabled or disabled the filter
803
804 filterToken= strtok(p, filterDelimiters);
805 if(filterToken == NULL) break;
806 p+= strlen(filterToken) + 1; // p points to next filterToken
807 filterName= strtok(filterToken, optionDelimiters);
808 if(verbose>1) printf("pp: %s::%s\n", filterToken, filterName);
809
810 if(*filterName == '-')
811 {
812 enable=0;
813 filterName++;
814 }
815
816 for(;;){ //for all options
817 option= strtok(NULL, optionDelimiters);
818 if(option == NULL) break;
819
820 if(verbose>1) printf("pp: option: %s\n", option);
821 if(!strcmp("autoq", option) || !strcmp("a", option)) q= quality;
822 else if(!strcmp("nochrom", option) || !strcmp("y", option)) chrom=0;
823 else if(!strcmp("chrom", option) || !strcmp("c", option)) chrom=1;
824 else if(!strcmp("noluma", option) || !strcmp("n", option)) luma=0;
825 else
826 {
827 options[numOfUnknownOptions] = option;
828 numOfUnknownOptions++;
829 }
830 if(numOfUnknownOptions >= OPTIONS_ARRAY_SIZE-1) break;
831 }
832 options[numOfUnknownOptions] = NULL;
833
834 /* replace stuff from the replace Table */
835 for(i=0; replaceTable[2*i]!=NULL; i++)
836 {
837 if(!strcmp(replaceTable[2*i], filterName))
838 {
839 int newlen= strlen(replaceTable[2*i + 1]);
840 int plen;
841 int spaceLeft;
842
843 if(p==NULL) p= temp, *p=0; //last filter
844 else p--, *p=','; //not last filter
845
846 plen= strlen(p);
847 spaceLeft= p - temp + plen;
848 if(spaceLeft + newlen >= GET_MODE_BUFFER_SIZE)
849 {
850 ppMode->error++;
851 break;
852 }
853 memmove(p + newlen, p, plen+1);
854 memcpy(p, replaceTable[2*i + 1], newlen);
855 filterNameOk=1;
856 }
857 }
858
859 for(i=0; filters[i].shortName!=NULL; i++)
860 {
861 // printf("Compareing %s, %s, %s\n", filters[i].shortName,filters[i].longName, filterName);
862 if( !strcmp(filters[i].longName, filterName)
863 || !strcmp(filters[i].shortName, filterName))
864 {
865 ppMode->lumMode &= ~filters[i].mask;
866 ppMode->chromMode &= ~filters[i].mask;
867
868 filterNameOk=1;
869 if(!enable) break; // user wants to disable it
870
871 if(q >= filters[i].minLumQuality && luma)
872 ppMode->lumMode|= filters[i].mask;
873 if(chrom==1 || (chrom==-1 && filters[i].chromDefault))
874 if(q >= filters[i].minChromQuality)
875 ppMode->chromMode|= filters[i].mask;
876
877 if(filters[i].mask == LEVEL_FIX)
878 {
879 int o;
880 ppMode->minAllowedY= 16;
881 ppMode->maxAllowedY= 234;
882 for(o=0; options[o]!=NULL; o++)
883 {
884 if( !strcmp(options[o],"fullyrange")
885 ||!strcmp(options[o],"f"))
886 {
887 ppMode->minAllowedY= 0;
888 ppMode->maxAllowedY= 255;
889 numOfUnknownOptions--;
890 }
891 }
892 }
893 else if(filters[i].mask == TEMP_NOISE_FILTER)
894 {
895 int o;
896 int numOfNoises=0;
897
898 for(o=0; options[o]!=NULL; o++)
899 {
900 char *tail;
901 ppMode->maxTmpNoise[numOfNoises]=
902 strtol(options[o], &tail, 0);
903 if(tail!=options[o])
904 {
905 numOfNoises++;
906 numOfUnknownOptions--;
907 if(numOfNoises >= 3) break;
908 }
909 }
910 }
911 else if(filters[i].mask == V_DEBLOCK || filters[i].mask == H_DEBLOCK
912 || filters[i].mask == V_A_DEBLOCK || filters[i].mask == H_A_DEBLOCK)
913 {
914 int o;
915
916 for(o=0; options[o]!=NULL && o<2; o++)
917 {
918 char *tail;
919 int val= strtol(options[o], &tail, 0);
920 if(tail==options[o]) break;
921
922 numOfUnknownOptions--;
923 if(o==0) ppMode->baseDcDiff= val;
924 else ppMode->flatnessThreshold= val;
925 }
926 }
927 else if(filters[i].mask == FORCE_QUANT)
928 {
929 int o;
930 ppMode->forcedQuant= 15;
931
932 for(o=0; options[o]!=NULL && o<1; o++)
933 {
934 char *tail;
935 int val= strtol(options[o], &tail, 0);
936 if(tail==options[o]) break;
937
938 numOfUnknownOptions--;
939 ppMode->forcedQuant= val;
940 }
941 }
942 }
943 }
944 if(!filterNameOk) ppMode->error++;
945 ppMode->error += numOfUnknownOptions;
946 }
947
948 if(verbose>1) printf("pp: lumMode=%X, chromMode=%X\n", ppMode->lumMode, ppMode->chromMode);
949 if(ppMode->error)
950 {
951 fprintf(stderr, "%d errors in postprocess string \"%s\"\n", ppMode->error, name);
952 free(ppMode);
953 return NULL;
954 }
955 return ppMode;
956 }
957
958 void pp_free_mode(pp_mode_t *mode){
959 if(mode) free(mode);
960 }
961
962 static void reallocAlign(void **p, int alignment, int size){
963 if(*p) free(*p);
964 *p= memalign(alignment, size);
965 memset(*p, 0, size);
966 }
967
968 static void reallocBuffers(PPContext *c, int width, int height, int stride, int qpStride){
969 int mbWidth = (width+15)>>4;
970 int mbHeight= (height+15)>>4;
971 int i;
972
973 c->stride= stride;
974 c->qpStride= qpStride;
975
976 reallocAlign((void **)&c->tempDst, 8, stride*24);
977 reallocAlign((void **)&c->tempSrc, 8, stride*24);
978 reallocAlign((void **)&c->tempBlocks, 8, 2*16*8);
979 reallocAlign((void **)&c->yHistogram, 8, 256*sizeof(uint64_t));
980 for(i=0; i<256; i++)
981 c->yHistogram[i]= width*height/64*15/256;
982
983 for(i=0; i<3; i++)
984 {
985 //Note:the +17*1024 is just there so i dont have to worry about r/w over te end
986 reallocAlign((void **)&c->tempBlured[i], 8, stride*mbHeight*16 + 17*1024);
987 reallocAlign((void **)&c->tempBluredPast[i], 8, 256*((height+7)&(~7))/2 + 17*1024);//FIXME size
988 }
989
990 reallocAlign((void **)&c->deintTemp, 8, 2*width+32);
991 reallocAlign((void **)&c->nonBQPTable, 8, qpStride*mbHeight*sizeof(QP_STORE_T));
992 reallocAlign((void **)&c->stdQPTable, 8, qpStride*mbHeight*sizeof(QP_STORE_T));
993 reallocAlign((void **)&c->forcedQPTable, 8, mbWidth*sizeof(QP_STORE_T));
994 }
995
996 static void global_init(void){
997 int i;
998 memset(clip_table, 0, 256);
999 for(i=256; i<512; i++)
1000 clip_table[i]= i;
1001 memset(clip_table+512, 0, 256);
1002 }
1003
1004 pp_context_t *pp_get_context(int width, int height, int cpuCaps){
1005 PPContext *c= memalign(32, sizeof(PPContext));
1006 int stride= (width+15)&(~15); //assumed / will realloc if needed
1007 int qpStride= (width+15)/16 + 2; //assumed / will realloc if needed
1008
1009 global_init();
1010
1011 memset(c, 0, sizeof(PPContext));
1012 c->cpuCaps= cpuCaps;
1013 if(cpuCaps&PP_FORMAT){
1014 c->hChromaSubSample= cpuCaps&0x3;
1015 c->vChromaSubSample= (cpuCaps>>4)&0x3;
1016 }else{
1017 c->hChromaSubSample= 1;
1018 c->vChromaSubSample= 1;
1019 }
1020
1021 reallocBuffers(c, width, height, stride, qpStride);
1022
1023 c->frameNum=-1;
1024
1025 return c;
1026 }
1027
1028 void pp_free_context(void *vc){
1029 PPContext *c = (PPContext*)vc;
1030 int i;
1031
1032 for(i=0; i<3; i++) free(c->tempBlured[i]);
1033 for(i=0; i<3; i++) free(c->tempBluredPast[i]);
1034
1035 free(c->tempBlocks);
1036 free(c->yHistogram);
1037 free(c->tempDst);
1038 free(c->tempSrc);
1039 free(c->deintTemp);
1040 free(c->stdQPTable);
1041 free(c->nonBQPTable);
1042 free(c->forcedQPTable);
1043
1044 memset(c, 0, sizeof(PPContext));
1045
1046 free(c);
1047 }
1048
1049 void pp_postprocess(uint8_t * src[3], int srcStride[3],
1050 uint8_t * dst[3], int dstStride[3],
1051 int width, int height,
1052 QP_STORE_T *QP_store, int QPStride,
1053 pp_mode_t *vm, void *vc, int pict_type)
1054 {
1055 int mbWidth = (width+15)>>4;
1056 int mbHeight= (height+15)>>4;
1057 PPMode *mode = (PPMode*)vm;
1058 PPContext *c = (PPContext*)vc;
1059 int minStride= MAX(ABS(srcStride[0]), ABS(dstStride[0]));
1060 int absQPStride = ABS(QPStride);
1061
1062 // c->stride and c->QPStride are always positive
1063 if(c->stride < minStride || c->qpStride < absQPStride)
1064 reallocBuffers(c, width, height,
1065 MAX(minStride, c->stride),
1066 MAX(c->qpStride, absQPStride));
1067
1068 if(QP_store==NULL || (mode->lumMode & FORCE_QUANT))
1069 {
1070 int i;
1071 QP_store= c->forcedQPTable;
1072 absQPStride = QPStride = 0;
1073 if(mode->lumMode & FORCE_QUANT)
1074 for(i=0; i<mbWidth; i++) QP_store[i]= mode->forcedQuant;
1075 else
1076 for(i=0; i<mbWidth; i++) QP_store[i]= 1;
1077 }
1078 //printf("pict_type:%d\n", pict_type);
1079
1080 if(pict_type & PP_PICT_TYPE_QP2){
1081 int i;
1082 const int count= mbHeight * absQPStride;
1083 for(i=0; i<(count>>2); i++){
1084 ((uint32_t*)c->stdQPTable)[i] = (((uint32_t*)QP_store)[i]>>1) & 0x7F7F7F7F;
1085 }
1086 for(i<<=2; i<count; i++){
1087 c->stdQPTable[i] = QP_store[i]>>1;
1088 }
1089 QP_store= c->stdQPTable;
1090 QPStride= absQPStride;
1091 }
1092
1093 if(0){
1094 int x,y;
1095 for(y=0; y<mbHeight; y++){
1096 for(x=0; x<mbWidth; x++){
1097 printf("%2d ", QP_store[x + y*QPStride]);
1098 }
1099 printf("\n");
1100 }
1101 printf("\n");
1102 }
1103
1104 if((pict_type&7)!=3)
1105 {
1106 if (QPStride >= 0) {
1107 int i;
1108 const int count= mbHeight * QPStride;
1109 for(i=0; i<(count>>2); i++){
1110 ((uint32_t*)c->nonBQPTable)[i] = ((uint32_t*)QP_store)[i] & 0x3F3F3F3F;
1111 }
1112 for(i<<=2; i<count; i++){
1113 c->nonBQPTable[i] = QP_store[i] & 0x3F;
1114 }
1115 } else {
1116 int i,j;
1117 for(i=0; i<mbHeight; i++) {
1118 for(j=0; j<absQPStride; j++) {
1119 c->nonBQPTable[i*absQPStride+j] = QP_store[i*QPStride+j] & 0x3F;
1120 }
1121 }
1122 }
1123 }
1124
1125 if(verbose>2)
1126 {
1127 printf("using npp filters 0x%X/0x%X\n", mode->lumMode, mode->chromMode);
1128 }
1129
1130 postProcess(src[0], srcStride[0], dst[0], dstStride[0],
1131 width, height, QP_store, QPStride, 0, mode, c);
1132
1133 width = (width )>>c->hChromaSubSample;
1134 height = (height)>>c->vChromaSubSample;
1135
1136 if(mode->chromMode)
1137 {
1138 postProcess(src[1], srcStride[1], dst[1], dstStride[1],
1139 width, height, QP_store, QPStride, 1, mode, c);
1140 postProcess(src[2], srcStride[2], dst[2], dstStride[2],
1141 width, height, QP_store, QPStride, 2, mode, c);
1142 }
1143 else if(srcStride[1] == dstStride[1] && srcStride[2] == dstStride[2])
1144 {
1145 linecpy(dst[1], src[1], height, srcStride[1]);
1146 linecpy(dst[2], src[2], height, srcStride[2]);
1147 }
1148 else
1149 {
1150 int y;
1151 for(y=0; y<height; y++)
1152 {
1153 memcpy(&(dst[1][y*dstStride[1]]), &(src[1][y*srcStride[1]]), width);
1154 memcpy(&(dst[2][y*dstStride[2]]), &(src[2][y*srcStride[2]]), width);
1155 }
1156 }
1157 }
1158