Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * Copyright (c) 2007 Michael Niedermayer <michaelni@gmx.at> | |
3 | * Copyright (c) 2013 Clément Bœsch <u pkh me> | |
4 | * | |
5 | * This file is part of FFmpeg. | |
6 | * | |
7 | * FFmpeg is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | * | |
12 | * FFmpeg is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License along | |
18 | * with FFmpeg; if not, write to the Free Software Foundation, Inc., | |
19 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | |
20 | */ | |
21 | ||
22 | /** | |
23 | * @todo try to change to int | |
24 | * @todo try lifting based implementation | |
25 | * @todo optimize optimize optimize | |
26 | * @todo hard thresholding | |
27 | * @todo use QP to decide filter strength | |
28 | * @todo wavelet normalization / least squares optimal signal vs. noise thresholds | |
29 | */ | |
30 | ||
31 | #include "libavutil/imgutils.h" | |
32 | #include "libavutil/opt.h" | |
33 | #include "libavutil/pixdesc.h" | |
34 | #include "avfilter.h" | |
35 | #include "internal.h" | |
36 | ||
37 | typedef struct { | |
38 | const AVClass *class; | |
39 | double luma_strength; | |
40 | double chroma_strength; | |
41 | int depth; | |
42 | float *plane[16+1][4]; | |
43 | int linesize; | |
44 | int hsub, vsub; | |
45 | } OWDenoiseContext; | |
46 | ||
47 | #define OFFSET(x) offsetof(OWDenoiseContext, x) | |
48 | #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM | |
49 | static const AVOption owdenoise_options[] = { | |
50 | { "depth", "set depth", OFFSET(depth), AV_OPT_TYPE_INT, {.i64 = 8}, 8, 16, FLAGS }, | |
51 | { "luma_strength", "set luma strength", OFFSET(luma_strength), AV_OPT_TYPE_DOUBLE, {.dbl = 1.0}, 0, 1000, FLAGS }, | |
52 | { "ls", "set luma strength", OFFSET(luma_strength), AV_OPT_TYPE_DOUBLE, {.dbl = 1.0}, 0, 1000, FLAGS }, | |
53 | { "chroma_strength", "set chroma strength", OFFSET(chroma_strength), AV_OPT_TYPE_DOUBLE, {.dbl = 1.0}, 0, 1000, FLAGS }, | |
54 | { "cs", "set chroma strength", OFFSET(chroma_strength), AV_OPT_TYPE_DOUBLE, {.dbl = 1.0}, 0, 1000, FLAGS }, | |
55 | { NULL } | |
56 | }; | |
57 | ||
58 | AVFILTER_DEFINE_CLASS(owdenoise); | |
59 | ||
60 | DECLARE_ALIGNED(8, static const uint8_t, dither)[8][8] = { | |
61 | { 0, 48, 12, 60, 3, 51, 15, 63 }, | |
62 | { 32, 16, 44, 28, 35, 19, 47, 31 }, | |
63 | { 8, 56, 4, 52, 11, 59, 7, 55 }, | |
64 | { 40, 24, 36, 20, 43, 27, 39, 23 }, | |
65 | { 2, 50, 14, 62, 1, 49, 13, 61 }, | |
66 | { 34, 18, 46, 30, 33, 17, 45, 29 }, | |
67 | { 10, 58, 6, 54, 9, 57, 5, 53 }, | |
68 | { 42, 26, 38, 22, 41, 25, 37, 21 }, | |
69 | }; | |
70 | ||
71 | static const double coeff[2][5] = { | |
72 | { | |
73 | 0.6029490182363579 * M_SQRT2, | |
74 | 0.2668641184428723 * M_SQRT2, | |
75 | -0.07822326652898785 * M_SQRT2, | |
76 | -0.01686411844287495 * M_SQRT2, | |
77 | 0.02674875741080976 * M_SQRT2, | |
78 | },{ | |
79 | 1.115087052456994 / M_SQRT2, | |
80 | -0.5912717631142470 / M_SQRT2, | |
81 | -0.05754352622849957 / M_SQRT2, | |
82 | 0.09127176311424948 / M_SQRT2, | |
83 | } | |
84 | }; | |
85 | ||
86 | static const double icoeff[2][5] = { | |
87 | { | |
88 | 1.115087052456994 / M_SQRT2, | |
89 | 0.5912717631142470 / M_SQRT2, | |
90 | -0.05754352622849957 / M_SQRT2, | |
91 | -0.09127176311424948 / M_SQRT2, | |
92 | },{ | |
93 | 0.6029490182363579 * M_SQRT2, | |
94 | -0.2668641184428723 * M_SQRT2, | |
95 | -0.07822326652898785 * M_SQRT2, | |
96 | 0.01686411844287495 * M_SQRT2, | |
97 | 0.02674875741080976 * M_SQRT2, | |
98 | } | |
99 | }; | |
100 | ||
101 | static inline int mirror(int x, int w) | |
102 | { | |
103 | while ((unsigned)x > (unsigned)w) { | |
104 | x = -x; | |
105 | if (x < 0) | |
106 | x += 2 * w; | |
107 | } | |
108 | return x; | |
109 | } | |
110 | ||
111 | static inline void decompose(float *dst_l, float *dst_h, const float *src, | |
112 | int linesize, int w) | |
113 | { | |
114 | int x, i; | |
115 | for (x = 0; x < w; x++) { | |
116 | double sum_l = src[x * linesize] * coeff[0][0]; | |
117 | double sum_h = src[x * linesize] * coeff[1][0]; | |
118 | for (i = 1; i <= 4; i++) { | |
119 | const double s = src[mirror(x - i, w - 1) * linesize] | |
120 | + src[mirror(x + i, w - 1) * linesize]; | |
121 | ||
122 | sum_l += coeff[0][i] * s; | |
123 | sum_h += coeff[1][i] * s; | |
124 | } | |
125 | dst_l[x * linesize] = sum_l; | |
126 | dst_h[x * linesize] = sum_h; | |
127 | } | |
128 | } | |
129 | ||
130 | static inline void compose(float *dst, const float *src_l, const float *src_h, | |
131 | int linesize, int w) | |
132 | { | |
133 | int x, i; | |
134 | for (x = 0; x < w; x++) { | |
135 | double sum_l = src_l[x * linesize] * icoeff[0][0]; | |
136 | double sum_h = src_h[x * linesize] * icoeff[1][0]; | |
137 | for (i = 1; i <= 4; i++) { | |
138 | const int x0 = mirror(x - i, w - 1) * linesize; | |
139 | const int x1 = mirror(x + i, w - 1) * linesize; | |
140 | ||
141 | sum_l += icoeff[0][i] * (src_l[x0] + src_l[x1]); | |
142 | sum_h += icoeff[1][i] * (src_h[x0] + src_h[x1]); | |
143 | } | |
144 | dst[x * linesize] = (sum_l + sum_h) * 0.5; | |
145 | } | |
146 | } | |
147 | ||
148 | static inline void decompose2D(float *dst_l, float *dst_h, const float *src, | |
149 | int xlinesize, int ylinesize, | |
150 | int step, int w, int h) | |
151 | { | |
152 | int y, x; | |
153 | for (y = 0; y < h; y++) | |
154 | for (x = 0; x < step; x++) | |
155 | decompose(dst_l + ylinesize*y + xlinesize*x, | |
156 | dst_h + ylinesize*y + xlinesize*x, | |
157 | src + ylinesize*y + xlinesize*x, | |
158 | step * xlinesize, (w - x + step - 1) / step); | |
159 | } | |
160 | ||
161 | static inline void compose2D(float *dst, const float *src_l, const float *src_h, | |
162 | int xlinesize, int ylinesize, | |
163 | int step, int w, int h) | |
164 | { | |
165 | int y, x; | |
166 | for (y = 0; y < h; y++) | |
167 | for (x = 0; x < step; x++) | |
168 | compose(dst + ylinesize*y + xlinesize*x, | |
169 | src_l + ylinesize*y + xlinesize*x, | |
170 | src_h + ylinesize*y + xlinesize*x, | |
171 | step * xlinesize, (w - x + step - 1) / step); | |
172 | } | |
173 | ||
174 | static void decompose2D2(float *dst[4], float *src, float *temp[2], | |
175 | int linesize, int step, int w, int h) | |
176 | { | |
177 | decompose2D(temp[0], temp[1], src, 1, linesize, step, w, h); | |
178 | decompose2D( dst[0], dst[1], temp[0], linesize, 1, step, h, w); | |
179 | decompose2D( dst[2], dst[3], temp[1], linesize, 1, step, h, w); | |
180 | } | |
181 | ||
182 | static void compose2D2(float *dst, float *src[4], float *temp[2], | |
183 | int linesize, int step, int w, int h) | |
184 | { | |
185 | compose2D(temp[0], src[0], src[1], linesize, 1, step, h, w); | |
186 | compose2D(temp[1], src[2], src[3], linesize, 1, step, h, w); | |
187 | compose2D(dst, temp[0], temp[1], 1, linesize, step, w, h); | |
188 | } | |
189 | ||
190 | static void filter(OWDenoiseContext *s, | |
191 | uint8_t *dst, int dst_linesize, | |
192 | const uint8_t *src, int src_linesize, | |
193 | int width, int height, double strength) | |
194 | { | |
195 | int x, y, i, j, depth = s->depth; | |
196 | ||
197 | while (1<<depth > width || 1<<depth > height) | |
198 | depth--; | |
199 | ||
200 | for (y = 0; y < height; y++) | |
201 | for(x = 0; x < width; x++) | |
202 | s->plane[0][0][y*s->linesize + x] = src[y*src_linesize + x]; | |
203 | ||
204 | for (i = 0; i < depth; i++) | |
205 | decompose2D2(s->plane[i + 1], s->plane[i][0], s->plane[0] + 1, s->linesize, 1<<i, width, height); | |
206 | ||
207 | for (i = 0; i < depth; i++) { | |
208 | for (j = 1; j < 4; j++) { | |
209 | for (y = 0; y < height; y++) { | |
210 | for (x = 0; x < width; x++) { | |
211 | double v = s->plane[i + 1][j][y*s->linesize + x]; | |
212 | if (v > strength) v -= strength; | |
213 | else if (v < -strength) v += strength; | |
214 | else v = 0; | |
215 | s->plane[i + 1][j][x + y*s->linesize] = v; | |
216 | } | |
217 | } | |
218 | } | |
219 | } | |
220 | for (i = depth-1; i >= 0; i--) | |
221 | compose2D2(s->plane[i][0], s->plane[i + 1], s->plane[0] + 1, s->linesize, 1<<i, width, height); | |
222 | ||
223 | for (y = 0; y < height; y++) { | |
224 | for (x = 0; x < width; x++) { | |
225 | i = s->plane[0][0][y*s->linesize + x] + dither[x&7][y&7]*(1.0/64) + 1.0/128; // yes the rounding is insane but optimal :) | |
226 | if ((unsigned)i > 255U) i = ~(i >> 31); | |
227 | dst[y*dst_linesize + x] = i; | |
228 | } | |
229 | } | |
230 | } | |
231 | ||
232 | static int filter_frame(AVFilterLink *inlink, AVFrame *in) | |
233 | { | |
234 | int direct = 0; | |
235 | AVFilterContext *ctx = inlink->dst; | |
236 | OWDenoiseContext *s = ctx->priv; | |
237 | AVFilterLink *outlink = ctx->outputs[0]; | |
238 | AVFrame *out; | |
239 | const int cw = FF_CEIL_RSHIFT(inlink->w, s->hsub); | |
240 | const int ch = FF_CEIL_RSHIFT(inlink->h, s->vsub); | |
241 | ||
242 | if (av_frame_is_writable(in)) { | |
243 | direct = 1; | |
244 | out = in; | |
245 | } else { | |
246 | out = ff_get_video_buffer(outlink, outlink->w, outlink->h); | |
247 | if (!out) { | |
248 | av_frame_free(&in); | |
249 | return AVERROR(ENOMEM); | |
250 | } | |
251 | av_frame_copy_props(out, in); | |
252 | } | |
253 | ||
254 | filter(s, out->data[0], out->linesize[0], in->data[0], in->linesize[0], inlink->w, inlink->h, s->luma_strength); | |
255 | filter(s, out->data[1], out->linesize[1], in->data[1], in->linesize[1], cw, ch, s->chroma_strength); | |
256 | filter(s, out->data[2], out->linesize[2], in->data[2], in->linesize[2], cw, ch, s->chroma_strength); | |
257 | ||
258 | if (!direct) { | |
259 | if (in->data[3]) | |
260 | av_image_copy_plane(out->data[3], out->linesize[3], | |
261 | in ->data[3], in ->linesize[3], | |
262 | inlink->w, inlink->h); | |
263 | av_frame_free(&in); | |
264 | } | |
265 | ||
266 | return ff_filter_frame(outlink, out); | |
267 | } | |
268 | ||
269 | static int query_formats(AVFilterContext *ctx) | |
270 | { | |
271 | static const enum AVPixelFormat pix_fmts[] = { | |
272 | AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, | |
273 | AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P, | |
274 | AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV440P, | |
275 | AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, | |
276 | AV_PIX_FMT_YUVA420P, | |
277 | AV_PIX_FMT_NONE | |
278 | }; | |
279 | ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); | |
280 | return 0; | |
281 | } | |
282 | ||
283 | static int config_input(AVFilterLink *inlink) | |
284 | { | |
285 | int i, j; | |
286 | OWDenoiseContext *s = inlink->dst->priv; | |
287 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format); | |
288 | const int h = FFALIGN(inlink->h, 16); | |
289 | ||
290 | s->hsub = desc->log2_chroma_w; | |
291 | s->vsub = desc->log2_chroma_h; | |
292 | ||
293 | s->linesize = FFALIGN(inlink->w, 16); | |
294 | for (j = 0; j < 4; j++) { | |
295 | for (i = 0; i <= s->depth; i++) { | |
296 | s->plane[i][j] = av_malloc_array(s->linesize, h * sizeof(s->plane[0][0][0])); | |
297 | if (!s->plane[i][j]) | |
298 | return AVERROR(ENOMEM); | |
299 | } | |
300 | } | |
301 | return 0; | |
302 | } | |
303 | ||
304 | static av_cold void uninit(AVFilterContext *ctx) | |
305 | { | |
306 | int i, j; | |
307 | OWDenoiseContext *s = ctx->priv; | |
308 | ||
309 | for (j = 0; j < 4; j++) | |
310 | for (i = 0; i <= s->depth; i++) | |
311 | av_freep(&s->plane[i][j]); | |
312 | } | |
313 | ||
314 | static const AVFilterPad owdenoise_inputs[] = { | |
315 | { | |
316 | .name = "default", | |
317 | .type = AVMEDIA_TYPE_VIDEO, | |
318 | .filter_frame = filter_frame, | |
319 | .config_props = config_input, | |
320 | }, | |
321 | { NULL } | |
322 | }; | |
323 | ||
324 | static const AVFilterPad owdenoise_outputs[] = { | |
325 | { | |
326 | .name = "default", | |
327 | .type = AVMEDIA_TYPE_VIDEO, | |
328 | }, | |
329 | { NULL } | |
330 | }; | |
331 | ||
332 | AVFilter ff_vf_owdenoise = { | |
333 | .name = "owdenoise", | |
334 | .description = NULL_IF_CONFIG_SMALL("Denoise using wavelets."), | |
335 | .priv_size = sizeof(OWDenoiseContext), | |
336 | .uninit = uninit, | |
337 | .query_formats = query_formats, | |
338 | .inputs = owdenoise_inputs, | |
339 | .outputs = owdenoise_outputs, | |
340 | .priv_class = &owdenoise_class, | |
341 | .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, | |
342 | }; |