Change code style to match the rest of libav.
Signed-off-by: Ronald S. Bultje <rsbultje@gmail.com>
... | ... |
@@ -32,165 +32,161 @@ |
32 | 32 |
#include "video.h" |
33 | 33 |
|
34 | 34 |
typedef struct { |
35 |
- int Coefs[4][512*16]; |
|
36 |
- unsigned int *Line; |
|
37 |
- unsigned short *Frame[3]; |
|
35 |
+ int coefs[4][512*16]; |
|
36 |
+ uint32_t *line; |
|
37 |
+ uint16_t *frame_prev[3]; |
|
38 | 38 |
int hsub, vsub; |
39 | 39 |
} HQDN3DContext; |
40 | 40 |
|
41 |
-static inline unsigned int LowPassMul(unsigned int PrevMul, unsigned int CurrMul, int *Coef) |
|
41 |
+static inline uint32_t lowpass(unsigned int prev, unsigned int cur, int *coef) |
|
42 | 42 |
{ |
43 |
- // int dMul= (PrevMul&0xFFFFFF)-(CurrMul&0xFFFFFF); |
|
44 |
- int dMul= PrevMul-CurrMul; |
|
45 |
- unsigned int d=((dMul+0x10007FF)>>12); |
|
46 |
- return CurrMul + Coef[d]; |
|
43 |
+ int dmul = prev-cur; |
|
44 |
+ unsigned int d = (dmul+0x10007FF)>>12; // 0x1000 to convert to unsigned, 7FF for rounding |
|
45 |
+ return cur + coef[d]; |
|
47 | 46 |
} |
48 | 47 |
|
49 |
-static void deNoiseTemporal(unsigned char *FrameSrc, |
|
50 |
- unsigned char *FrameDest, |
|
51 |
- unsigned short *FrameAnt, |
|
52 |
- int W, int H, int sStride, int dStride, |
|
53 |
- int *Temporal) |
|
48 |
+static void denoise_temporal(uint8_t *src, uint8_t *dst, |
|
49 |
+ uint16_t *frame_ant, |
|
50 |
+ int w, int h, int sstride, int dstride, |
|
51 |
+ int *temporal) |
|
54 | 52 |
{ |
55 |
- long X, Y; |
|
56 |
- unsigned int PixelDst; |
|
57 |
- |
|
58 |
- for (Y = 0; Y < H; Y++) { |
|
59 |
- for (X = 0; X < W; X++) { |
|
60 |
- PixelDst = LowPassMul(FrameAnt[X]<<8, FrameSrc[X]<<16, Temporal); |
|
61 |
- FrameAnt[X] = ((PixelDst+0x1000007F)>>8); |
|
62 |
- FrameDest[X]= ((PixelDst+0x10007FFF)>>16); |
|
53 |
+ long x, y; |
|
54 |
+ uint32_t pixel; |
|
55 |
+ |
|
56 |
+ for (y = 0; y < h; y++) { |
|
57 |
+ for (x = 0; x < w; x++) { |
|
58 |
+ pixel = lowpass(frame_ant[x]<<8, src[x]<<16, temporal); |
|
59 |
+ frame_ant[x] = ((pixel+0x1000007F)>>8); |
|
60 |
+ dst[x]= ((pixel+0x10007FFF)>>16); |
|
63 | 61 |
} |
64 |
- FrameSrc += sStride; |
|
65 |
- FrameDest += dStride; |
|
66 |
- FrameAnt += W; |
|
62 |
+ src += sstride; |
|
63 |
+ dst += dstride; |
|
64 |
+ frame_ant += w; |
|
67 | 65 |
} |
68 | 66 |
} |
69 | 67 |
|
70 |
-static void deNoiseSpacial(unsigned char *Frame, |
|
71 |
- unsigned char *FrameDest, |
|
72 |
- unsigned int *LineAnt, |
|
73 |
- int W, int H, int sStride, int dStride, |
|
74 |
- int *Horizontal, int *Vertical) |
|
68 |
+static void denoise_spatial(uint8_t *src, uint8_t *dst, |
|
69 |
+ uint32_t *line_ant, |
|
70 |
+ int w, int h, int sstride, int dstride, |
|
71 |
+ int *horizontal, int *vertical) |
|
75 | 72 |
{ |
76 |
- long X, Y; |
|
77 |
- long sLineOffs = 0, dLineOffs = 0; |
|
78 |
- unsigned int PixelAnt; |
|
79 |
- unsigned int PixelDst; |
|
73 |
+ long x, y; |
|
74 |
+ long sline_offs = 0, dline_offs = 0; |
|
75 |
+ uint32_t pixel_ant; |
|
76 |
+ uint32_t pixel; |
|
80 | 77 |
|
81 | 78 |
/* First pixel has no left nor top neighbor. */ |
82 |
- PixelDst = LineAnt[0] = PixelAnt = Frame[0]<<16; |
|
83 |
- FrameDest[0]= ((PixelDst+0x10007FFF)>>16); |
|
79 |
+ pixel = line_ant[0] = pixel_ant = src[0]<<16; |
|
80 |
+ dst[0]= ((pixel+0x10007FFF)>>16); |
|
84 | 81 |
|
85 | 82 |
/* First line has no top neighbor, only left. */ |
86 |
- for (X = 1; X < W; X++) { |
|
87 |
- PixelDst = LineAnt[X] = LowPassMul(PixelAnt, Frame[X]<<16, Horizontal); |
|
88 |
- FrameDest[X]= ((PixelDst+0x10007FFF)>>16); |
|
83 |
+ for (x = 1; x < w; x++) { |
|
84 |
+ pixel = line_ant[x] = lowpass(pixel_ant, src[x]<<16, horizontal); |
|
85 |
+ dst[x]= ((pixel+0x10007FFF)>>16); |
|
89 | 86 |
} |
90 | 87 |
|
91 |
- for (Y = 1; Y < H; Y++) { |
|
92 |
- unsigned int PixelAnt; |
|
93 |
- sLineOffs += sStride, dLineOffs += dStride; |
|
88 |
+ for (y = 1; y < h; y++) { |
|
89 |
+ uint32_t pixel_ant; |
|
90 |
+ sline_offs += sstride, dline_offs += dstride; |
|
94 | 91 |
/* First pixel on each line doesn't have previous pixel */ |
95 |
- PixelAnt = Frame[sLineOffs]<<16; |
|
96 |
- PixelDst = LineAnt[0] = LowPassMul(LineAnt[0], PixelAnt, Vertical); |
|
97 |
- FrameDest[dLineOffs]= ((PixelDst+0x10007FFF)>>16); |
|
92 |
+ pixel_ant = src[sline_offs]<<16; |
|
93 |
+ pixel = line_ant[0] = lowpass(line_ant[0], pixel_ant, vertical); |
|
94 |
+ dst[dline_offs]= ((pixel+0x10007FFF)>>16); |
|
98 | 95 |
|
99 |
- for (X = 1; X < W; X++) { |
|
100 |
- unsigned int PixelDst; |
|
96 |
+ for (x = 1; x < w; x++) { |
|
97 |
+ uint32_t pixel; |
|
101 | 98 |
/* The rest are normal */ |
102 |
- PixelAnt = LowPassMul(PixelAnt, Frame[sLineOffs+X]<<16, Horizontal); |
|
103 |
- PixelDst = LineAnt[X] = LowPassMul(LineAnt[X], PixelAnt, Vertical); |
|
104 |
- FrameDest[dLineOffs+X]= ((PixelDst+0x10007FFF)>>16); |
|
99 |
+ pixel_ant = lowpass(pixel_ant, src[sline_offs+x]<<16, horizontal); |
|
100 |
+ pixel = line_ant[x] = lowpass(line_ant[x], pixel_ant, vertical); |
|
101 |
+ dst[dline_offs+x]= ((pixel+0x10007FFF)>>16); |
|
105 | 102 |
} |
106 | 103 |
} |
107 | 104 |
} |
108 | 105 |
|
109 |
-static void deNoise(unsigned char *Frame, |
|
110 |
- unsigned char *FrameDest, |
|
111 |
- unsigned int *LineAnt, |
|
112 |
- unsigned short **FrameAntPtr, |
|
113 |
- int W, int H, int sStride, int dStride, |
|
114 |
- int *Horizontal, int *Vertical, int *Temporal) |
|
106 |
+static void denoise(uint8_t *src, uint8_t *dst, |
|
107 |
+ uint32_t *line_ant, uint16_t **frame_ant_ptr, |
|
108 |
+ int w, int h, int sstride, int dstride, |
|
109 |
+ int *horizontal, int *vertical, int *temporal) |
|
115 | 110 |
{ |
116 |
- long X, Y; |
|
117 |
- long sLineOffs = 0, dLineOffs = 0; |
|
118 |
- unsigned int PixelAnt; |
|
119 |
- unsigned int PixelDst; |
|
120 |
- unsigned short* FrameAnt=(*FrameAntPtr); |
|
121 |
- |
|
122 |
- if (!FrameAnt) { |
|
123 |
- (*FrameAntPtr) = FrameAnt = av_malloc(W*H*sizeof(unsigned short)); |
|
124 |
- for (Y = 0; Y < H; Y++) { |
|
125 |
- unsigned short* dst=&FrameAnt[Y*W]; |
|
126 |
- unsigned char* src=Frame+Y*sStride; |
|
127 |
- for (X = 0; X < W; X++) dst[X]=src[X]<<8; |
|
111 |
+ long x, y; |
|
112 |
+ long sline_offs = 0, dline_offs = 0; |
|
113 |
+ uint32_t pixel_ant; |
|
114 |
+ uint32_t pixel; |
|
115 |
+ uint16_t *frame_ant = *frame_ant_ptr; |
|
116 |
+ |
|
117 |
+ if (!frame_ant) { |
|
118 |
+ *frame_ant_ptr = frame_ant = av_malloc(w*h*sizeof(uint16_t)); |
|
119 |
+ for (y = 0; y < h; y++) { |
|
120 |
+ uint16_t *frame_dst = frame_ant+y*w; |
|
121 |
+ uint8_t *frame_src = src+y*sstride; |
|
122 |
+ for (x = 0; x < w; x++) |
|
123 |
+ frame_dst[x] = frame_src[x]<<8; |
|
128 | 124 |
} |
129 | 125 |
} |
130 | 126 |
|
131 |
- if (!Horizontal[0] && !Vertical[0]) { |
|
132 |
- deNoiseTemporal(Frame, FrameDest, FrameAnt, |
|
133 |
- W, H, sStride, dStride, Temporal); |
|
127 |
+ if (!horizontal[0] && !vertical[0]) { |
|
128 |
+ denoise_temporal(src, dst, frame_ant, |
|
129 |
+ w, h, sstride, dstride, temporal); |
|
134 | 130 |
return; |
135 | 131 |
} |
136 |
- if (!Temporal[0]) { |
|
137 |
- deNoiseSpacial(Frame, FrameDest, LineAnt, |
|
138 |
- W, H, sStride, dStride, Horizontal, Vertical); |
|
132 |
+ if (!temporal[0]) { |
|
133 |
+ denoise_spatial(src, dst, line_ant, |
|
134 |
+ w, h, sstride, dstride, horizontal, vertical); |
|
139 | 135 |
return; |
140 | 136 |
} |
141 | 137 |
|
142 | 138 |
/* First pixel has no left nor top neighbor. Only previous frame */ |
143 |
- LineAnt[0] = PixelAnt = Frame[0]<<16; |
|
144 |
- PixelDst = LowPassMul(FrameAnt[0]<<8, PixelAnt, Temporal); |
|
145 |
- FrameAnt[0] = ((PixelDst+0x1000007F)>>8); |
|
146 |
- FrameDest[0]= ((PixelDst+0x10007FFF)>>16); |
|
139 |
+ line_ant[0] = pixel_ant = src[0]<<16; |
|
140 |
+ pixel = lowpass(frame_ant[0]<<8, pixel_ant, temporal); |
|
141 |
+ frame_ant[0] = ((pixel+0x1000007F)>>8); |
|
142 |
+ dst[0]= ((pixel+0x10007FFF)>>16); |
|
147 | 143 |
|
148 | 144 |
/* First line has no top neighbor. Only left one for each pixel and |
149 | 145 |
* last frame */ |
150 |
- for (X = 1; X < W; X++) { |
|
151 |
- LineAnt[X] = PixelAnt = LowPassMul(PixelAnt, Frame[X]<<16, Horizontal); |
|
152 |
- PixelDst = LowPassMul(FrameAnt[X]<<8, PixelAnt, Temporal); |
|
153 |
- FrameAnt[X] = ((PixelDst+0x1000007F)>>8); |
|
154 |
- FrameDest[X]= ((PixelDst+0x10007FFF)>>16); |
|
146 |
+ for (x = 1; x < w; x++) { |
|
147 |
+ line_ant[x] = pixel_ant = lowpass(pixel_ant, src[x]<<16, horizontal); |
|
148 |
+ pixel = lowpass(frame_ant[x]<<8, pixel_ant, temporal); |
|
149 |
+ frame_ant[x] = ((pixel+0x1000007F)>>8); |
|
150 |
+ dst[x]= ((pixel+0x10007FFF)>>16); |
|
155 | 151 |
} |
156 | 152 |
|
157 |
- for (Y = 1; Y < H; Y++) { |
|
158 |
- unsigned int PixelAnt; |
|
159 |
- unsigned short* LinePrev=&FrameAnt[Y*W]; |
|
160 |
- sLineOffs += sStride, dLineOffs += dStride; |
|
153 |
+ for (y = 1; y < h; y++) { |
|
154 |
+ uint32_t pixel_ant; |
|
155 |
+ uint16_t *line_prev = frame_ant+y*w; |
|
156 |
+ sline_offs += sstride, dline_offs += dstride; |
|
161 | 157 |
/* First pixel on each line doesn't have previous pixel */ |
162 |
- PixelAnt = Frame[sLineOffs]<<16; |
|
163 |
- LineAnt[0] = LowPassMul(LineAnt[0], PixelAnt, Vertical); |
|
164 |
- PixelDst = LowPassMul(LinePrev[0]<<8, LineAnt[0], Temporal); |
|
165 |
- LinePrev[0] = ((PixelDst+0x1000007F)>>8); |
|
166 |
- FrameDest[dLineOffs]= ((PixelDst+0x10007FFF)>>16); |
|
167 |
- |
|
168 |
- for (X = 1; X < W; X++) { |
|
169 |
- unsigned int PixelDst; |
|
158 |
+ pixel_ant = src[sline_offs]<<16; |
|
159 |
+ line_ant[0] = lowpass(line_ant[0], pixel_ant, vertical); |
|
160 |
+ pixel = lowpass(line_prev[0]<<8, line_ant[0], temporal); |
|
161 |
+ line_prev[0] = ((pixel+0x1000007F)>>8); |
|
162 |
+ dst[dline_offs]= ((pixel+0x10007FFF)>>16); |
|
163 |
+ |
|
164 |
+ for (x = 1; x < w; x++) { |
|
165 |
+ uint32_t pixel; |
|
170 | 166 |
/* The rest are normal */ |
171 |
- PixelAnt = LowPassMul(PixelAnt, Frame[sLineOffs+X]<<16, Horizontal); |
|
172 |
- LineAnt[X] = LowPassMul(LineAnt[X], PixelAnt, Vertical); |
|
173 |
- PixelDst = LowPassMul(LinePrev[X]<<8, LineAnt[X], Temporal); |
|
174 |
- LinePrev[X] = ((PixelDst+0x1000007F)>>8); |
|
175 |
- FrameDest[dLineOffs+X]= ((PixelDst+0x10007FFF)>>16); |
|
167 |
+ pixel_ant = lowpass(pixel_ant, src[sline_offs+x]<<16, horizontal); |
|
168 |
+ line_ant[x] = lowpass(line_ant[x], pixel_ant, vertical); |
|
169 |
+ pixel = lowpass(line_prev[x]<<8, line_ant[x], temporal); |
|
170 |
+ line_prev[x] = ((pixel+0x1000007F)>>8); |
|
171 |
+ dst[dline_offs+x]= ((pixel+0x10007FFF)>>16); |
|
176 | 172 |
} |
177 | 173 |
} |
178 | 174 |
} |
179 | 175 |
|
180 |
-static void PrecalcCoefs(int *Ct, double Dist25) |
|
176 |
+static void precalc_coefs(int *ct, double dist25) |
|
181 | 177 |
{ |
182 | 178 |
int i; |
183 |
- double Gamma, Simil, C; |
|
179 |
+ double gamma, simil, C; |
|
184 | 180 |
|
185 |
- Gamma = log(0.25) / log(1.0 - Dist25/255.0 - 0.00001); |
|
181 |
+ gamma = log(0.25) / log(1.0 - dist25/255.0 - 0.00001); |
|
186 | 182 |
|
187 | 183 |
for (i = -255*16; i <= 255*16; i++) { |
188 |
- Simil = 1.0 - FFABS(i) / (16*255.0); |
|
189 |
- C = pow(Simil, Gamma) * 65536.0 * i / 16.0; |
|
190 |
- Ct[16*256+i] = lrint(C); |
|
184 |
+ simil = 1.0 - FFABS(i) / (16*255.0); |
|
185 |
+ C = pow(simil, gamma) * 65536.0 * i / 16.0; |
|
186 |
+ ct[16*256+i] = lrint(C); |
|
191 | 187 |
} |
192 | 188 |
|
193 |
- Ct[0] = !!Dist25; |
|
189 |
+ ct[0] = !!dist25; |
|
194 | 190 |
} |
195 | 191 |
|
196 | 192 |
#define PARAM1_DEFAULT 4.0 |
... | ... |
@@ -200,57 +196,57 @@ static void PrecalcCoefs(int *Ct, double Dist25) |
200 | 200 |
static int init(AVFilterContext *ctx, const char *args) |
201 | 201 |
{ |
202 | 202 |
HQDN3DContext *hqdn3d = ctx->priv; |
203 |
- double LumSpac, LumTmp, ChromSpac, ChromTmp; |
|
204 |
- double Param1, Param2, Param3, Param4; |
|
203 |
+ double lum_spac, lum_tmp, chrom_spac, chrom_tmp; |
|
204 |
+ double param1, param2, param3, param4; |
|
205 | 205 |
|
206 |
- LumSpac = PARAM1_DEFAULT; |
|
207 |
- ChromSpac = PARAM2_DEFAULT; |
|
208 |
- LumTmp = PARAM3_DEFAULT; |
|
209 |
- ChromTmp = LumTmp * ChromSpac / LumSpac; |
|
206 |
+ lum_spac = PARAM1_DEFAULT; |
|
207 |
+ chrom_spac = PARAM2_DEFAULT; |
|
208 |
+ lum_tmp = PARAM3_DEFAULT; |
|
209 |
+ chrom_tmp = lum_tmp * chrom_spac / lum_spac; |
|
210 | 210 |
|
211 | 211 |
if (args) { |
212 | 212 |
switch (sscanf(args, "%lf:%lf:%lf:%lf", |
213 |
- &Param1, &Param2, &Param3, &Param4)) { |
|
213 |
+ ¶m1, ¶m2, ¶m3, ¶m4)) { |
|
214 | 214 |
case 1: |
215 |
- LumSpac = Param1; |
|
216 |
- ChromSpac = PARAM2_DEFAULT * Param1 / PARAM1_DEFAULT; |
|
217 |
- LumTmp = PARAM3_DEFAULT * Param1 / PARAM1_DEFAULT; |
|
218 |
- ChromTmp = LumTmp * ChromSpac / LumSpac; |
|
215 |
+ lum_spac = param1; |
|
216 |
+ chrom_spac = PARAM2_DEFAULT * param1 / PARAM1_DEFAULT; |
|
217 |
+ lum_tmp = PARAM3_DEFAULT * param1 / PARAM1_DEFAULT; |
|
218 |
+ chrom_tmp = lum_tmp * chrom_spac / lum_spac; |
|
219 | 219 |
break; |
220 | 220 |
case 2: |
221 |
- LumSpac = Param1; |
|
222 |
- ChromSpac = Param2; |
|
223 |
- LumTmp = PARAM3_DEFAULT * Param1 / PARAM1_DEFAULT; |
|
224 |
- ChromTmp = LumTmp * ChromSpac / LumSpac; |
|
221 |
+ lum_spac = param1; |
|
222 |
+ chrom_spac = param2; |
|
223 |
+ lum_tmp = PARAM3_DEFAULT * param1 / PARAM1_DEFAULT; |
|
224 |
+ chrom_tmp = lum_tmp * chrom_spac / lum_spac; |
|
225 | 225 |
break; |
226 | 226 |
case 3: |
227 |
- LumSpac = Param1; |
|
228 |
- ChromSpac = Param2; |
|
229 |
- LumTmp = Param3; |
|
230 |
- ChromTmp = LumTmp * ChromSpac / LumSpac; |
|
227 |
+ lum_spac = param1; |
|
228 |
+ chrom_spac = param2; |
|
229 |
+ lum_tmp = param3; |
|
230 |
+ chrom_tmp = lum_tmp * chrom_spac / lum_spac; |
|
231 | 231 |
break; |
232 | 232 |
case 4: |
233 |
- LumSpac = Param1; |
|
234 |
- ChromSpac = Param2; |
|
235 |
- LumTmp = Param3; |
|
236 |
- ChromTmp = Param4; |
|
233 |
+ lum_spac = param1; |
|
234 |
+ chrom_spac = param2; |
|
235 |
+ lum_tmp = param3; |
|
236 |
+ chrom_tmp = param4; |
|
237 | 237 |
break; |
238 | 238 |
} |
239 | 239 |
} |
240 | 240 |
|
241 | 241 |
av_log(ctx, AV_LOG_VERBOSE, "ls:%lf cs:%lf lt:%lf ct:%lf\n", |
242 |
- LumSpac, ChromSpac, LumTmp, ChromTmp); |
|
243 |
- if (LumSpac < 0 || ChromSpac < 0 || isnan(ChromTmp)) { |
|
242 |
+ lum_spac, chrom_spac, lum_tmp, chrom_tmp); |
|
243 |
+ if (lum_spac < 0 || chrom_spac < 0 || isnan(chrom_tmp)) { |
|
244 | 244 |
av_log(ctx, AV_LOG_ERROR, |
245 | 245 |
"Invalid negative value for luma or chroma spatial strength, " |
246 | 246 |
"or resulting value for chroma temporal strength is nan.\n"); |
247 | 247 |
return AVERROR(EINVAL); |
248 | 248 |
} |
249 | 249 |
|
250 |
- PrecalcCoefs(hqdn3d->Coefs[0], LumSpac); |
|
251 |
- PrecalcCoefs(hqdn3d->Coefs[1], LumTmp); |
|
252 |
- PrecalcCoefs(hqdn3d->Coefs[2], ChromSpac); |
|
253 |
- PrecalcCoefs(hqdn3d->Coefs[3], ChromTmp); |
|
250 |
+ precalc_coefs(hqdn3d->coefs[0], lum_spac); |
|
251 |
+ precalc_coefs(hqdn3d->coefs[1], lum_tmp); |
|
252 |
+ precalc_coefs(hqdn3d->coefs[2], chrom_spac); |
|
253 |
+ precalc_coefs(hqdn3d->coefs[3], chrom_tmp); |
|
254 | 254 |
|
255 | 255 |
return 0; |
256 | 256 |
} |
... | ... |
@@ -259,10 +255,10 @@ static void uninit(AVFilterContext *ctx) |
259 | 259 |
{ |
260 | 260 |
HQDN3DContext *hqdn3d = ctx->priv; |
261 | 261 |
|
262 |
- av_freep(&hqdn3d->Line); |
|
263 |
- av_freep(&hqdn3d->Frame[0]); |
|
264 |
- av_freep(&hqdn3d->Frame[1]); |
|
265 |
- av_freep(&hqdn3d->Frame[2]); |
|
262 |
+ av_freep(&hqdn3d->line); |
|
263 |
+ av_freep(&hqdn3d->frame_prev[0]); |
|
264 |
+ av_freep(&hqdn3d->frame_prev[1]); |
|
265 |
+ av_freep(&hqdn3d->frame_prev[2]); |
|
266 | 266 |
} |
267 | 267 |
|
268 | 268 |
static int query_formats(AVFilterContext *ctx) |
... | ... |
@@ -283,8 +279,8 @@ static int config_input(AVFilterLink *inlink) |
283 | 283 |
hqdn3d->hsub = av_pix_fmt_descriptors[inlink->format].log2_chroma_w; |
284 | 284 |
hqdn3d->vsub = av_pix_fmt_descriptors[inlink->format].log2_chroma_h; |
285 | 285 |
|
286 |
- hqdn3d->Line = av_malloc(inlink->w * sizeof(*hqdn3d->Line)); |
|
287 |
- if (!hqdn3d->Line) |
|
286 |
+ hqdn3d->line = av_malloc(inlink->w * sizeof(*hqdn3d->line)); |
|
287 |
+ if (!hqdn3d->line) |
|
288 | 288 |
return AVERROR(ENOMEM); |
289 | 289 |
|
290 | 290 |
return 0; |
... | ... |
@@ -305,24 +301,24 @@ static int end_frame(AVFilterLink *inlink) |
305 | 305 |
int ch = inpic->video->h >> hqdn3d->vsub; |
306 | 306 |
int ret; |
307 | 307 |
|
308 |
- deNoise(inpic->data[0], outpic->data[0], |
|
309 |
- hqdn3d->Line, &hqdn3d->Frame[0], inpic->video->w, inpic->video->h, |
|
308 |
+ denoise(inpic->data[0], outpic->data[0], |
|
309 |
+ hqdn3d->line, &hqdn3d->frame_prev[0], inpic->video->w, inpic->video->h, |
|
310 | 310 |
inpic->linesize[0], outpic->linesize[0], |
311 |
- hqdn3d->Coefs[0], |
|
312 |
- hqdn3d->Coefs[0], |
|
313 |
- hqdn3d->Coefs[1]); |
|
314 |
- deNoise(inpic->data[1], outpic->data[1], |
|
315 |
- hqdn3d->Line, &hqdn3d->Frame[1], cw, ch, |
|
311 |
+ hqdn3d->coefs[0], |
|
312 |
+ hqdn3d->coefs[0], |
|
313 |
+ hqdn3d->coefs[1]); |
|
314 |
+ denoise(inpic->data[1], outpic->data[1], |
|
315 |
+ hqdn3d->line, &hqdn3d->frame_prev[1], cw, ch, |
|
316 | 316 |
inpic->linesize[1], outpic->linesize[1], |
317 |
- hqdn3d->Coefs[2], |
|
318 |
- hqdn3d->Coefs[2], |
|
319 |
- hqdn3d->Coefs[3]); |
|
320 |
- deNoise(inpic->data[2], outpic->data[2], |
|
321 |
- hqdn3d->Line, &hqdn3d->Frame[2], cw, ch, |
|
317 |
+ hqdn3d->coefs[2], |
|
318 |
+ hqdn3d->coefs[2], |
|
319 |
+ hqdn3d->coefs[3]); |
|
320 |
+ denoise(inpic->data[2], outpic->data[2], |
|
321 |
+ hqdn3d->line, &hqdn3d->frame_prev[2], cw, ch, |
|
322 | 322 |
inpic->linesize[2], outpic->linesize[2], |
323 |
- hqdn3d->Coefs[2], |
|
324 |
- hqdn3d->Coefs[2], |
|
325 |
- hqdn3d->Coefs[3]); |
|
323 |
+ hqdn3d->coefs[2], |
|
324 |
+ hqdn3d->coefs[2], |
|
325 |
+ hqdn3d->coefs[3]); |
|
326 | 326 |
|
327 | 327 |
if ((ret = ff_draw_slice(outlink, 0, inpic->video->h, 1)) < 0 || |
328 | 328 |
(ret = ff_end_frame(outlink)) < 0) |