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