1. ffmpeg
  2. Commit 544fde1bf827a9664f0c091dda78248573d1701d
Browse code

avfilter: add bm3d filter

Signed-off-by: Paul B Mahol <onemda@gmail.com>

Paul B Mahol authored on 2018/05/09 19:58:23
Showing 6 changed files
Changelog
History View file @ 544fde1
... ... 
@@ -28,6 +28,7 @@ version <next>:
28 28 
 - transpose_npp filter
29 29 
 - AVS2 video encoder via libxavs2
30 30 
 - amultiply filter
31 
+- Block-Matching 3d (bm3d) denoising filter
31 32
32 33
33 34 
 version 4.0:
doc/filters.texi
History View file @ 544fde1
... ... 
@@ -5729,6 +5729,91 @@ tblend=all_mode=grainextract
5729 5729 
 @end example
5730 5730 
 @end itemize
5731 5731
5732 
+@section bm3d
5733 
+
5734 
+Denoise frames using Block-Matching 3D algorithm.
5735 
+
5736 
+The filter accepts the following options.
5737 
+
5738 
+@table @option
5739 
+@item sigma
5740 
+Set denoising strength. Default value is 1.
5741 
+Allowed range is from 0 to 999.9.
5742 
+The denoising algorith is very sensitive to sigma, so adjust it
5743 
+according to the source.
5744 
+
5745 
+@item block
5746 
+Set local patch size. This sets dimensions in 2D.
5747 
+
5748 
+@item bstep
5749 
+Set sliding step for processing blocks. Default value is 4.
5750 
+Allowed range is from 1 to 64.
5751 
+Smaller values allows processing more reference blocks and is slower.
5752 
+
5753 
+@item group
5754 
+Set maximal number of similar blocks for 3rd dimension. Default value is 1.
5755 
+When set to 1, no block matching is done. Larger values allows more blocks
5756 
+in single group.
5757 
+Allowed range is from 1 to 256.
5758 
+
5759 
+@item range
5760 
+Set radius for search block matching. Default is 9.
5761 
+Allowed range is from 1 to INT32_MAX.
5762 
+
5763 
+@item mstep
5764 
+Set step between two search locations for block matching. Default is 1.
5765 
+Allowed range is from 1 to 64. Smaller is slower.
5766 
+
5767 
+@item thmse
5768 
+Set threshold of mean square error for block matching. Valid range is 0 to
5769 
+INT32_MAX.
5770 
+
5771 
+@item hdthr
5772 
+Set thresholding parameter for hard thresholding in 3D transformed domain.
5773 
+Larger values results in stronger hard-thresholding filtering in frequency
5774 
+domain.
5775 
+
5776 
+@item estim
5777 
+Set filtering estimation mode. Can be @code{basic} or @code{final}.
5778 
+Default is @code{basic}.
5779 
+
5780 
+@item ref
5781 
+If enabled, filter will use 2nd stream for block matching.
5782 
+Default is disabled for @code{basic} value of @var{estim} option,
5783 
+and always enabled if value of @var{estim} is @code{final}.
5784 
+
5785 
+@item planes
5786 
+Set planes to filter. Default is all available except alpha.
5787 
+@end table
5788 
+
5789 
+@subsection Examples
5790 
+
5791 
+@itemize
5792 
+@item
5793 
+Basic filtering with bm3d:
5794 
+@example
5795 
+bm3d=sigma=3:block=4:bstep=2:group=1:estim=basic
5796 
+@end example
5797 
+
5798 
+@item
5799 
+Same as above, but filtering only luma:
5800 
+@example
5801 
+bm3d=sigma=3:block=4:bstep=2:group=1:estim=basic:planes=1
5802 
+@end example
5803 
+
5804 
+@item
5805 
+Same as above, but with both estimation modes:
5806 
+@example
5807 
+split[a][b],[a]bm3d=sigma=3:block=4:bstep=2:group=1:estim=basic[a],[b][a]bm3d=sigma=3:block=4:bstep=2:group=16:estim=final:ref=1
5808 
+@end example
5809 
+
5810 
+@item
5811 
+Same as above, but prefilter with @ref{nlmeans} filter instead:
5812 
+@example
5813 
+split[a][b],[a]nlmeans=s=3:r=7:p=3[a],[b][a]bm3d=sigma=3:block=4:bstep=2:group=16:estim=final:ref=1
5814 
+@end example
5815 
+@end itemize
5816 
+
5732 5817 
 @section boxblur
5733 5818
5734 5819 
 Apply a boxblur algorithm to the input video.
... ... 
@@ -11691,6 +11776,7 @@ It accepts the following option:
11691 11691 
 With value 1, it negates the alpha component, if present. Default value is 0.
11692 11692 
 @end table
11693 11693
11694 
+@anchor{nlmeans}
11694 11695 
 @section nlmeans
11695 11696
11696 11697 
 Denoise frames using Non-Local Means algorithm.
libavfilter/Makefile
History View file @ 544fde1
... ... 
@@ -158,6 +158,7 @@ OBJS-$(CONFIG_BITPLANENOISE_FILTER)          += vf_bitplanenoise.o
158 158 
 OBJS-$(CONFIG_BLACKDETECT_FILTER)            += vf_blackdetect.o
159 159 
 OBJS-$(CONFIG_BLACKFRAME_FILTER)             += vf_blackframe.o
160 160 
 OBJS-$(CONFIG_BLEND_FILTER)                  += vf_blend.o framesync.o
161 
+OBJS-$(CONFIG_BM3D_FILTER)                   += vf_bm3d.o
161 162 
 OBJS-$(CONFIG_BOXBLUR_FILTER)                += vf_boxblur.o boxblur.o
162 163 
 OBJS-$(CONFIG_BOXBLUR_OPENCL_FILTER)         += vf_avgblur_opencl.o opencl.o \
163 164 
                                                 opencl/avgblur.o boxblur.o
libavfilter/allfilters.c
History View file @ 544fde1
... ... 
@@ -149,6 +149,7 @@ extern AVFilter ff_vf_bitplanenoise;
149 149 
 extern AVFilter ff_vf_blackdetect;
150 150 
 extern AVFilter ff_vf_blackframe;
151 151 
 extern AVFilter ff_vf_blend;
152 
+extern AVFilter ff_vf_bm3d;
152 153 
 extern AVFilter ff_vf_boxblur;
153 154 
 extern AVFilter ff_vf_boxblur_opencl;
154 155 
 extern AVFilter ff_vf_bwdif;
libavfilter/version.h
History View file @ 544fde1
... ... 
@@ -30,7 +30,7 @@
30 30 
 #include "libavutil/version.h"
31 31
32 32 
 #define LIBAVFILTER_VERSION_MAJOR   7
33 
-#define LIBAVFILTER_VERSION_MINOR  30
33 
+#define LIBAVFILTER_VERSION_MINOR  31
34 34 
 #define LIBAVFILTER_VERSION_MICRO 100
35 35
36 36 
 #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
libavfilter/vf_bm3d.c
History View file @ 544fde1
37 37 
new file mode 100644
... ... 
@@ -0,0 +1,1077 @@
0 
+/*
1 
+ * Copyright (c) 2015-2016 mawen1250
2 
+ * Copyright (c) 2018 Paul B Mahol
3 
+ *
4 
+ * This file is part of FFmpeg.
5 
+ *
6 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
7 
+ * of this software and associated documentation files (the "Software"), to deal
8 
+ * in the Software without restriction, including without limitation the rights
9 
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 
+ * copies of the Software, and to permit persons to whom the Software is
11 
+ * furnished to do so, subject to the following conditions:
12 
+ *
13 
+ * The above copyright notice and this permission notice shall be included in all
14 
+ * copies or substantial portions of the Software.
15 
+ *
16 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 
+ * SOFTWARE.
23 
+ */
24 
+
25 
+/**
26 
+ * @todo
27 
+ * - non-power of 2 DCT
28 
+ * - opponent color space
29 
+ * - temporal support
30 
+ */
31 
+
32 
+#include <float.h>
33 
+
34 
+#include "libavutil/avassert.h"
35 
+#include "libavutil/imgutils.h"
36 
+#include "libavutil/opt.h"
37 
+#include "libavutil/pixdesc.h"
38 
+#include "libavcodec/avfft.h"
39 
+#include "avfilter.h"
40 
+#include "filters.h"
41 
+#include "formats.h"
42 
+#include "framesync.h"
43 
+#include "internal.h"
44 
+#include "video.h"
45 
+
46 
+#define MAX_NB_THREADS 32
47 
+
48 
+enum FilterModes {
49 
+    BASIC,
50 
+    FINAL,
51 
+    NB_MODES,
52 
+};
53 
+
54 
+typedef struct ThreadData {
55 
+    const uint8_t *src;
56 
+    int src_linesize;
57 
+    const uint8_t *ref;
58 
+    int ref_linesize;
59 
+    int plane;
60 
+} ThreadData;
61 
+
62 
+typedef struct PosCode {
63 
+    int x, y;
64 
+} PosCode;
65 
+
66 
+typedef struct PosPairCode {
67 
+    double score;
68 
+    int x, y;
69 
+} PosPairCode;
70 
+
71 
+typedef struct SliceContext {
72 
+    DCTContext *gdctf, *gdcti;
73 
+    DCTContext *dctf, *dcti;
74 
+    FFTSample *bufferh;
75 
+    FFTSample *bufferv;
76 
+    FFTSample *bufferz;
77 
+    FFTSample *buffer;
78 
+    FFTSample *rbufferh;
79 
+    FFTSample *rbufferv;
80 
+    FFTSample *rbufferz;
81 
+    FFTSample *rbuffer;
82 
+    float *num, *den;
83 
+    PosPairCode match_blocks[256];
84 
+    int nb_match_blocks;
85 
+    PosCode *search_positions;
86 
+} SliceContext;
87 
+
88 
+typedef struct BM3DContext {
89 
+    const AVClass *class;
90 
+
91 
+    float sigma;
92 
+    int block_size;
93 
+    int block_step;
94 
+    int group_size;
95 
+    int bm_range;
96 
+    int bm_step;
97 
+    float th_mse;
98 
+    float hard_threshold;
99 
+    int mode;
100 
+    int ref;
101 
+    int planes;
102 
+
103 
+    int depth;
104 
+    int max;
105 
+    int nb_planes;
106 
+    int planewidth[4];
107 
+    int planeheight[4];
108 
+    int group_bits;
109 
+    int pgroup_size;
110 
+
111 
+    SliceContext slices[MAX_NB_THREADS];
112 
+
113 
+    FFFrameSync fs;
114 
+    int nb_threads;
115 
+
116 
+    void (*get_block_row)(const uint8_t *srcp, int src_linesize,
117 
+                          int y, int x, int block_size, float *dst);
118 
+    double (*do_block_ssd)(struct BM3DContext *s, PosCode *pos,
119 
+                           const uint8_t *src, int src_stride,
120 
+                           int r_y, int r_x);
121 
+    void (*do_output)(struct BM3DContext *s, uint8_t *dst, int dst_linesize,
122 
+                      int plane, int nb_jobs);
123 
+    void (*block_filtering)(struct BM3DContext *s,
124 
+                            const uint8_t *src, int src_linesize,
125 
+                            const uint8_t *ref, int ref_linesize,
126 
+                            int y, int x, int plane, int jobnr);
127 
+} BM3DContext;
128 
+
129 
+#define OFFSET(x) offsetof(BM3DContext, x)
130 
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
131 
+static const AVOption bm3d_options[] = {
132 
+    { "sigma",  "set denoising strength",
133 
+        OFFSET(sigma),          AV_OPT_TYPE_FLOAT, {.dbl=1},     0,      99999.9, FLAGS },
134 
+    { "block",  "set log2(size) of local patch",
135 
+        OFFSET(block_size),     AV_OPT_TYPE_INT,   {.i64=4},     4,            6, FLAGS },
136 
+    { "bstep",  "set sliding step for processing blocks",
137 
+        OFFSET(block_step),     AV_OPT_TYPE_INT,   {.i64=4},     1,           64, FLAGS },
138 
+    { "group",  "set maximal number of similar blocks",
139 
+        OFFSET(group_size),     AV_OPT_TYPE_INT,   {.i64=1},     1,          256, FLAGS },
140 
+    { "range",  "set block matching range",
141 
+        OFFSET(bm_range),       AV_OPT_TYPE_INT,   {.i64=9},     1,    INT32_MAX, FLAGS },
142 
+    { "mstep",  "set step for block matching",
143 
+        OFFSET(bm_step),        AV_OPT_TYPE_INT,   {.i64=1},     1,           64, FLAGS },
144 
+    { "thmse",  "set threshold of mean square error for block matching",
145 
+        OFFSET(th_mse),         AV_OPT_TYPE_FLOAT, {.dbl=0},     0,    INT32_MAX, FLAGS },
146 
+    { "hdthr",  "set hard threshold for 3D transfer domain",
147 
+        OFFSET(hard_threshold), AV_OPT_TYPE_FLOAT, {.dbl=2.7},   0,    INT32_MAX, FLAGS },
148 
+    { "estim",  "set filtering estimation mode",
149 
+        OFFSET(mode),           AV_OPT_TYPE_INT,   {.i64=BASIC}, 0,   NB_MODES-1, FLAGS, "mode" },
150 
+    { "basic",  "basic estimate",
151 
+        0,                      AV_OPT_TYPE_CONST, {.i64=BASIC}, 0,            0, FLAGS, "mode" },
152 
+    { "final",  "final estimate",
153 
+        0,                      AV_OPT_TYPE_CONST, {.i64=FINAL}, 0,            0, FLAGS, "mode" },
154 
+    { "ref",    "have reference stream",
155 
+        OFFSET(ref),            AV_OPT_TYPE_INT,    {.i64=0},    0,            1, FLAGS },
156 
+    { "planes", "set planes to filter",
157 
+        OFFSET(planes),         AV_OPT_TYPE_INT,   {.i64=7},     0,           15, FLAGS },
158 
+    { NULL }
159 
+};
160 
+
161 
+AVFILTER_DEFINE_CLASS(bm3d);
162 
+
163 
+static int query_formats(AVFilterContext *ctx)
164 
+{
165 
+    static const enum AVPixelFormat pix_fmts[] = {
166 
+        AV_PIX_FMT_GRAY8,
167 
+        AV_PIX_FMT_GRAY9,   AV_PIX_FMT_GRAY10,
168 
+        AV_PIX_FMT_GRAY12,  AV_PIX_FMT_GRAY16,
169 
+        AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
170 
+        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
171 
+        AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
172 
+        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
173 
+        AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
174 
+        AV_PIX_FMT_YUVJ411P,
175 
+        AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
176 
+        AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
177 
+        AV_PIX_FMT_YUV440P10,
178 
+        AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV420P12,
179 
+        AV_PIX_FMT_YUV440P12,
180 
+        AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV420P14,
181 
+        AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
182 
+        AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
183 
+        AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
184 
+        AV_PIX_FMT_NONE
185 
+    };
186 
+
187 
+    AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
188 
+    if (!fmts_list)
189 
+        return AVERROR(ENOMEM);
190 
+    return ff_set_common_formats(ctx, fmts_list);
191 
+}
192 
+
193 
+static int do_search_boundary(int pos, int plane_boundary, int search_range, int search_step)
194 
+{
195 
+    int search_boundary;
196 
+
197 
+    search_range = search_range / search_step * search_step;
198 
+
199 
+    if (pos == plane_boundary) {
200 
+        search_boundary = plane_boundary;
201 
+    } else if (pos > plane_boundary) {
202 
+        search_boundary = pos - search_range;
203 
+
204 
+        while (search_boundary < plane_boundary) {
205 
+            search_boundary += search_step;
206 
+        }
207 
+    } else {
208 
+        search_boundary = pos + search_range;
209 
+
210 
+        while (search_boundary > plane_boundary) {
211 
+            search_boundary -= search_step;
212 
+        }
213 
+    }
214 
+
215 
+    return search_boundary;
216 
+}
217 
+
218 
+static int search_boundary(int plane_boundary, int search_range, int search_step, int vertical, int y, int x)
219 
+{
220 
+    return do_search_boundary(vertical ? y : x, plane_boundary, search_range, search_step);
221 
+}
222 
+
223 
+static int cmp_scores(const void *a, const void *b)
224 
+{
225 
+    const struct PosPairCode *pair1 = a;
226 
+    const struct PosPairCode *pair2 = b;
227 
+    return FFDIFFSIGN(pair1->score, pair2->score);
228 
+}
229 
+
230 
+static double do_block_ssd(BM3DContext *s, PosCode *pos, const uint8_t *src, int src_stride, int r_y, int r_x)
231 
+{
232 
+    const uint8_t *srcp = src + pos->y * src_stride + pos->x;
233 
+    const uint8_t *refp = src + r_y * src_stride + r_x;
234 
+    const int block_size = s->block_size;
235 
+    double dist = 0.;
236 
+    int x, y;
237 
+
238 
+    for (y = 0; y < block_size; y++) {
239 
+        for (x = 0; x < block_size; x++) {
240 
+            double temp = refp[x] - srcp[x];
241 
+            dist += temp * temp;
242 
+        }
243 
+
244 
+        srcp += src_stride;
245 
+        refp += src_stride;
246 
+    }
247 
+
248 
+    return dist;
249 
+}
250 
+
251 
+static double do_block_ssd16(BM3DContext *s, PosCode *pos, const uint8_t *src, int src_stride, int r_y, int r_x)
252 
+{
253 
+    const uint16_t *srcp = (uint16_t *)src + pos->y * src_stride / 2 + pos->x;
254 
+    const uint16_t *refp = (uint16_t *)src + r_y * src_stride / 2 + r_x;
255 
+    const int block_size = s->block_size;
256 
+    double dist = 0.;
257 
+    int x, y;
258 
+
259 
+    for (y = 0; y < block_size; y++) {
260 
+        for (x = 0; x < block_size; x++) {
261 
+            double temp = refp[x] - srcp[x];
262 
+            dist += temp * temp;
263 
+        }
264 
+
265 
+        srcp += src_stride / 2;
266 
+        refp += src_stride / 2;
267 
+    }
268 
+
269 
+    return dist;
270 
+}
271 
+
272 
+static void do_block_matching_multi(BM3DContext *s, const uint8_t *src, int src_stride, int src_range,
273 
+                                    const PosCode *search_pos, int search_size, float th_mse,
274 
+                                    int r_y, int r_x, int plane, int jobnr)
275 
+{
276 
+    SliceContext *sc = &s->slices[jobnr];
277 
+    double MSE2SSE = s->group_size * s->block_size * s->block_size * src_range * src_range / (s->max * s->max);
278 
+    double distMul = 1. / MSE2SSE;
279 
+    double th_sse = th_mse * MSE2SSE;
280 
+    int i, index = sc->nb_match_blocks;
281 
+
282 
+    for (i = 0; i < search_size; i++) {
283 
+        PosCode pos = search_pos[i];
284 
+        double dist;
285 
+
286 
+        dist = s->do_block_ssd(s, &pos, src, src_stride, r_y, r_x);
287 
+
288 
+        // Only match similar blocks but not identical blocks
289 
+        if (dist <= th_sse && dist != 0) {
290 
+            const double score = dist * distMul;
291 
+
292 
+            if (index >= s->group_size && score >= sc->match_blocks[index - 1].score) {
293 
+                continue;
294 
+            }
295 
+
296 
+            if (index >= s->group_size)
297 
+                index = s->group_size - 1;
298 
+
299 
+            sc->match_blocks[index].score = score;
300 
+            sc->match_blocks[index].y = pos.y;
301 
+            sc->match_blocks[index].x = pos.x;
302 
+            index++;
303 
+            qsort(sc->match_blocks, index, sizeof(PosPairCode), cmp_scores);
304 
+        }
305 
+    }
306 
+
307 
+    sc->nb_match_blocks = index;
308 
+}
309 
+
310 
+static void block_matching_multi(BM3DContext *s, const uint8_t *ref, int ref_linesize, int y, int x,
311 
+                                 int exclude_cur_pos, int plane, int jobnr)
312 
+{
313 
+    SliceContext *sc = &s->slices[jobnr];
314 
+    const int width = s->planewidth[plane];
315 
+    const int height = s->planeheight[plane];
316 
+    const int block_size = s->block_size;
317 
+    const int step = s->bm_step;
318 
+    const int range = s->bm_range / step * step;
319 
+    int l = search_boundary(0, range, step, 0, y, x);
320 
+    int r = search_boundary(width - block_size, range, step, 0, y, x);
321 
+    int t = search_boundary(0, range, step, 1, y, x);
322 
+    int b = search_boundary(height - block_size, range, step, 1, y, x);
323 
+    int j, i, index = 0;
324 
+
325 
+    for (j = t; j <= b; j += step) {
326 
+        for (i = l; i <= r; i += step) {
327 
+            PosCode pos;
328 
+
329 
+            if (exclude_cur_pos > 0 && j == y && i == x) {
330 
+                continue;
331 
+            }
332 
+
333 
+            pos.y = j;
334 
+            pos.x = i;
335 
+            sc->search_positions[index++] = pos;
336 
+        }
337 
+    }
338 
+
339 
+    if (exclude_cur_pos == 1) {
340 
+        sc->match_blocks[0].score = 0;
341 
+        sc->match_blocks[0].y = y;
342 
+        sc->match_blocks[0].x = x;
343 
+        sc->nb_match_blocks = 1;
344 
+    }
345 
+
346 
+    do_block_matching_multi(s, ref, ref_linesize, s->bm_range,
347 
+                            sc->search_positions, index, s->th_mse, y, x, plane, jobnr);
348 
+}
349 
+
350 
+static void block_matching(BM3DContext *s, const uint8_t *ref, int ref_linesize,
351 
+                           int j, int i, int plane, int jobnr)
352 
+{
353 
+    SliceContext *sc = &s->slices[jobnr];
354 
+
355 
+    if (s->group_size == 1 || s->th_mse <= 0.f) {
356 
+        sc->match_blocks[0].score = 1;
357 
+        sc->match_blocks[0].x = i;
358 
+        sc->match_blocks[0].y = j;
359 
+        sc->nb_match_blocks = 1;
360 
+        return;
361 
+    }
362 
+
363 
+    sc->nb_match_blocks = 0;
364 
+    block_matching_multi(s, ref, ref_linesize, j, i, 1, plane, jobnr);
365 
+}
366 
+
367 
+static void get_block_row(const uint8_t *srcp, int src_linesize,
368 
+                          int y, int x, int block_size, float *dst)
369 
+{
370 
+    const uint8_t *src = srcp + y * src_linesize + x;
371 
+    int j;
372 
+
373 
+    for (j = 0; j < block_size; j++) {
374 
+        dst[j] = src[j];
375 
+    }
376 
+}
377 
+
378 
+static void get_block_row16(const uint8_t *srcp, int src_linesize,
379 
+                            int y, int x, int block_size, float *dst)
380 
+{
381 
+    const uint16_t *src = (uint16_t *)srcp + y * src_linesize / 2 + x;
382 
+    int j;
383 
+
384 
+    for (j = 0; j < block_size; j++) {
385 
+        dst[j] = src[j];
386 
+    }
387 
+}
388 
+
389 
+static void basic_block_filtering(BM3DContext *s, const uint8_t *src, int src_linesize,
390 
+                                  const uint8_t *ref, int ref_linesize,
391 
+                                  int y, int x, int plane, int jobnr)
392 
+{
393 
+    SliceContext *sc = &s->slices[jobnr];
394 
+    const int buffer_linesize = s->block_size * s->block_size;
395 
+    const int nb_match_blocks = sc->nb_match_blocks;
396 
+    const int block_size = s->block_size;
397 
+    const int width = s->planewidth[plane];
398 
+    const int pgroup_size = s->pgroup_size;
399 
+    const int group_size = s->group_size;
400 
+    float *buffer = sc->buffer;
401 
+    float *bufferh = sc->bufferh;
402 
+    float *bufferv = sc->bufferv;
403 
+    float *bufferz = sc->bufferz;
404 
+    float threshold[4];
405 
+    float den_weight, num_weight;
406 
+    int retained = 0;
407 
+    int i, j, k;
408 
+
409 
+    for (k = 0; k < nb_match_blocks; k++) {
410 
+        const int y = sc->match_blocks[k].y;
411 
+        const int x = sc->match_blocks[k].x;
412 
+
413 
+        for (i = 0; i < block_size; i++) {
414 
+            s->get_block_row(src, src_linesize, y + i, x, block_size, bufferh + block_size * i);
415 
+            av_dct_calc(sc->dctf, bufferh + block_size * i);
416 
+        }
417 
+
418 
+        for (i = 0; i < block_size; i++) {
419 
+            for (j = 0; j < block_size; j++) {
420 
+                bufferv[i * block_size + j] = bufferh[j * block_size + i];
421 
+            }
422 
+            av_dct_calc(sc->dctf, bufferv + i * block_size);
423 
+        }
424 
+
425 
+        for (i = 0; i < block_size; i++) {
426 
+            memcpy(buffer + k * buffer_linesize + i * block_size,
427 
+                   bufferv + i * block_size, block_size * 4);
428 
+        }
429 
+    }
430 
+
431 
+    for (i = 0; i < block_size; i++) {
432 
+        for (j = 0; j < block_size; j++) {
433 
+            for (k = 0; k < nb_match_blocks; k++)
434 
+                bufferz[k] = buffer[buffer_linesize * k + i * block_size + j];
435 
+            if (group_size > 1)
436 
+                av_dct_calc(sc->gdctf, bufferz);
437 
+            bufferz += pgroup_size;
438 
+        }
439 
+    }
440 
+
441 
+    threshold[0] = s->hard_threshold * s->sigma;
442 
+    threshold[1] = threshold[0] * sqrtf(2.f);
443 
+    threshold[2] = threshold[0] * 2.f;
444 
+    threshold[3] = threshold[0] * sqrtf(8.f);
445 
+    bufferz = sc->bufferz;
446 
+
447 
+    for (i = 0; i < block_size; i++) {
448 
+        for (j = 0; j < block_size; j++) {
449 
+            for (k = 0; k < nb_match_blocks; k++) {
450 
+                const float thresh = threshold[(j == 0) + (i == 0) + (k == 0)];
451 
+
452 
+                if (bufferz[k] > thresh || bufferz[k] < -thresh) {
453 
+                    retained++;
454 
+                } else {
455 
+                    bufferz[k] = 0;
456 
+                }
457 
+            }
458 
+            bufferz += pgroup_size;
459 
+        }
460 
+    }
461 
+
462 
+    bufferz = sc->bufferz;
463 
+    buffer = sc->buffer;
464 
+    for (i = 0; i < block_size; i++) {
465 
+        for (j = 0; j < block_size; j++) {
466 
+            if (group_size > 1)
467 
+                av_dct_calc(sc->gdcti, bufferz);
468 
+            for (k = 0; k < nb_match_blocks; k++) {
469 
+                buffer[buffer_linesize * k + i * block_size + j] = bufferz[k];
470 
+            }
471 
+            bufferz += pgroup_size;
472 
+        }
473 
+    }
474 
+
475 
+    den_weight = retained < 1 ? 1.f : 1.f / retained;
476 
+    num_weight = den_weight;
477 
+
478 
+    buffer = sc->buffer;
479 
+    for (k = 0; k < nb_match_blocks; k++) {
480 
+        float *num = sc->num + y * width + x;
481 
+        float *den = sc->den + y * width + x;
482 
+
483 
+        for (i = 0; i < block_size; i++) {
484 
+            memcpy(bufferv + i * block_size,
485 
+                   buffer + k * buffer_linesize + i * block_size,
486 
+                   block_size * 4);
487 
+        }
488 
+
489 
+        for (i = 0; i < block_size; i++) {
490 
+            av_dct_calc(sc->dcti, bufferv + block_size * i);
491 
+            for (j = 0; j < block_size; j++) {
492 
+                bufferh[j * block_size + i] = bufferv[i * block_size + j];
493 
+            }
494 
+        }
495 
+
496 
+        for (i = 0; i < block_size; i++) {
497 
+            av_dct_calc(sc->dcti, bufferh + block_size * i);
498 
+            for (j = 0; j < block_size; j++) {
499 
+                num[j] += bufferh[i * block_size + j] * num_weight;
500 
+                den[j] += den_weight;
501 
+            }
502 
+            num += width;
503 
+            den += width;
504 
+        }
505 
+    }
506 
+}
507 
+
508 
+static void final_block_filtering(BM3DContext *s, const uint8_t *src, int src_linesize,
509 
+                                  const uint8_t *ref, int ref_linesize,
510 
+                                  int y, int x, int plane, int jobnr)
511 
+{
512 
+    SliceContext *sc = &s->slices[jobnr];
513 
+    const int buffer_linesize = s->block_size * s->block_size;
514 
+    const int nb_match_blocks = sc->nb_match_blocks;
515 
+    const int block_size = s->block_size;
516 
+    const int width = s->planewidth[plane];
517 
+    const int pgroup_size = s->pgroup_size;
518 
+    const int group_size = s->group_size;
519 
+    const float sigma_sqr = s->sigma * s->sigma;
520 
+    float *buffer = sc->buffer;
521 
+    float *bufferh = sc->bufferh;
522 
+    float *bufferv = sc->bufferv;
523 
+    float *bufferz = sc->bufferz;
524 
+    float *rbuffer = sc->rbuffer;
525 
+    float *rbufferh = sc->rbufferh;
526 
+    float *rbufferv = sc->rbufferv;
527 
+    float *rbufferz = sc->rbufferz;
528 
+    float den_weight, num_weight;
529 
+    float l2_wiener = 0;
530 
+    int i, j, k;
531 
+
532 
+    for (k = 0; k < nb_match_blocks; k++) {
533 
+        const int y = sc->match_blocks[k].y;
534 
+        const int x = sc->match_blocks[k].x;
535 
+
536 
+        for (i = 0; i < block_size; i++) {
537 
+            s->get_block_row(src, src_linesize, y + i, x, block_size, bufferh + block_size * i);
538 
+            s->get_block_row(ref, ref_linesize, y + i, x, block_size, rbufferh + block_size * i);
539 
+            av_dct_calc(sc->dctf, bufferh + block_size * i);
540 
+            av_dct_calc(sc->dctf, rbufferh + block_size * i);
541 
+        }
542 
+
543 
+        for (i = 0; i < block_size; i++) {
544 
+            for (j = 0; j < block_size; j++) {
545 
+                bufferv[i * block_size + j] = bufferh[j * block_size + i];
546 
+                rbufferv[i * block_size + j] = rbufferh[j * block_size + i];
547 
+            }
548 
+            av_dct_calc(sc->dctf, bufferv + i * block_size);
549 
+            av_dct_calc(sc->dctf, rbufferv + i * block_size);
550 
+        }
551 
+
552 
+        for (i = 0; i < block_size; i++) {
553 
+            memcpy(buffer + k * buffer_linesize + i * block_size,
554 
+                   bufferv + i * block_size, block_size * 4);
555 
+            memcpy(rbuffer + k * buffer_linesize + i * block_size,
556 
+                   rbufferv + i * block_size, block_size * 4);
557 
+        }
558 
+    }
559 
+
560 
+    for (i = 0; i < block_size; i++) {
561 
+        for (j = 0; j < block_size; j++) {
562 
+            for (k = 0; k < nb_match_blocks; k++) {
563 
+                bufferz[k] = buffer[buffer_linesize * k + i * block_size + j];
564 
+                rbufferz[k] = rbuffer[buffer_linesize * k + i * block_size + j];
565 
+            }
566 
+            if (group_size > 1) {
567 
+                av_dct_calc(sc->gdctf, bufferz);
568 
+                av_dct_calc(sc->gdctf, rbufferz);
569 
+            }
570 
+            bufferz += pgroup_size;
571 
+            rbufferz += pgroup_size;
572 
+        }
573 
+    }
574 
+
575 
+    bufferz = sc->bufferz;
576 
+    rbufferz = sc->rbufferz;
577 
+
578 
+    for (i = 0; i < block_size; i++) {
579 
+        for (j = 0; j < block_size; j++) {
580 
+            for (k = 0; k < nb_match_blocks; k++) {
581 
+                const float ref_sqr = rbufferz[k] * rbufferz[k];
582 
+                float wiener_coef = ref_sqr / (ref_sqr + sigma_sqr);
583 
+
584 
+                if (isnan(wiener_coef))
585 
+                   wiener_coef = 1;
586 
+                bufferz[k] *= wiener_coef;
587 
+                l2_wiener += wiener_coef * wiener_coef;
588 
+            }
589 
+            bufferz += pgroup_size;
590 
+            rbufferz += pgroup_size;
591 
+        }
592 
+    }
593 
+
594 
+    bufferz = sc->bufferz;
595 
+    buffer = sc->buffer;
596 
+    for (i = 0; i < block_size; i++) {
597 
+        for (j = 0; j < block_size; j++) {
598 
+            if (group_size > 1)
599 
+                av_dct_calc(sc->gdcti, bufferz);
600 
+            for (k = 0; k < nb_match_blocks; k++) {
601 
+                buffer[buffer_linesize * k + i * block_size + j] = bufferz[k];
602 
+            }
603 
+            bufferz += pgroup_size;
604 
+        }
605 
+    }
606 
+
607 
+    l2_wiener = FFMAX(l2_wiener, 1e-15f);
608 
+    den_weight = 1.f / l2_wiener;
609 
+    num_weight = den_weight;
610 
+
611 
+    for (k = 0; k < nb_match_blocks; k++) {
612 
+        float *num = sc->num + y * width + x;
613 
+        float *den = sc->den + y * width + x;
614 
+
615 
+        for (i = 0; i < block_size; i++) {
616 
+            memcpy(bufferv + i * block_size,
617 
+                   buffer + k * buffer_linesize + i * block_size,
618 
+                   block_size * 4);
619 
+        }
620 
+
621 
+        for (i = 0; i < block_size; i++) {
622 
+            av_dct_calc(sc->dcti, bufferv + block_size * i);
623 
+            for (j = 0; j < block_size; j++) {
624 
+                bufferh[j * block_size + i] = bufferv[i * block_size + j];
625 
+            }
626 
+        }
627 
+
628 
+        for (i = 0; i < block_size; i++) {
629 
+            av_dct_calc(sc->dcti, bufferh + block_size * i);
630 
+            for (j = 0; j < block_size; j++) {
631 
+                num[j] += bufferh[i * block_size + j] * num_weight;
632 
+                den[j] += den_weight;
633 
+            }
634 
+            num += width;
635 
+            den += width;
636 
+        }
637 
+    }
638 
+}
639 
+
640 
+static void do_output(BM3DContext *s, uint8_t *dst, int dst_linesize,
641 
+                      int plane, int nb_jobs)
642 
+{
643 
+    const int height = s->planeheight[plane];
644 
+    const int width = s->planewidth[plane];
645 
+    int i, j, k;
646 
+
647 
+    for (i = 0; i < height; i++) {
648 
+        for (j = 0; j < width; j++) {
649 
+            uint8_t *dstp = dst + i * dst_linesize;
650 
+            float sum_den = 0.f;
651 
+            float sum_num = 0.f;
652 
+
653 
+            for (k = 0; k < nb_jobs; k++) {
654 
+                SliceContext *sc = &s->slices[k];
655 
+                float num = sc->num[i * width + j];
656 
+                float den = sc->den[i * width + j];
657 
+
658 
+                sum_num += num;
659 
+                sum_den += den;
660 
+            }
661 
+
662 
+            dstp[j] = av_clip_uint8(sum_num / sum_den);
663 
+        }
664 
+    }
665 
+}
666 
+
667 
+static void do_output16(BM3DContext *s, uint8_t *dst, int dst_linesize,
668 
+                        int plane, int nb_jobs)
669 
+{
670 
+    const int height = s->planeheight[plane];
671 
+    const int width = s->planewidth[plane];
672 
+    const int depth = s->depth;
673 
+    int i, j, k;
674 
+
675 
+    for (i = 0; i < height; i++) {
676 
+        for (j = 0; j < width; j++) {
677 
+            uint16_t *dstp = (uint16_t *)dst + i * dst_linesize / 2;
678 
+            float sum_den = 0.f;
679 
+            float sum_num = 0.f;
680 
+
681 
+            for (k = 0; k < nb_jobs; k++) {
682 
+                SliceContext *sc = &s->slices[k];
683 
+                float num = sc->num[i * width + j];
684 
+                float den = sc->den[i * width + j];
685 
+
686 
+                sum_num += num;
687 
+                sum_den += den;
688 
+            }
689 
+
690 
+            dstp[j] = av_clip_uintp2(sum_num / sum_den, depth);
691 
+        }
692 
+    }
693 
+}
694 
+
695 
+static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
696 
+{
697 
+    BM3DContext *s = ctx->priv;
698 
+    SliceContext *sc = &s->slices[jobnr];
699 
+    const int block_step = s->block_step;
700 
+    ThreadData *td = arg;
701 
+    const uint8_t *src = td->src;
702 
+    const uint8_t *ref = td->ref;
703 
+    const int src_linesize = td->src_linesize;
704 
+    const int ref_linesize = td->ref_linesize;
705 
+    const int plane = td->plane;
706 
+    const int width = s->planewidth[plane];
707 
+    const int height = s->planeheight[plane];
708 
+    const int block_pos_bottom = height - s->block_size;
709 
+    const int block_pos_right  = width - s->block_size;
710 
+    const int slice_start = (((height + block_step - 1) / block_step) * jobnr / nb_jobs) * block_step;
711 
+    const int slice_end = (jobnr == nb_jobs - 1) ? block_pos_bottom + block_step :
712 
+                          (((height + block_step - 1) / block_step) * (jobnr + 1) / nb_jobs) * block_step;
713 
+    int i, j;
714 
+
715 
+    memset(sc->num, 0, width * height * sizeof(FFTSample));
716 
+    memset(sc->den, 0, width * height * sizeof(FFTSample));
717 
+
718 
+    for (j = slice_start; j < slice_end; j += block_step) {
719 
+        if (j > block_pos_bottom) {
720 
+            j = block_pos_bottom;
721 
+        }
722 
+
723 
+        for (i = 0; i < block_pos_right + block_step; i += block_step) {
724 
+            if (i > block_pos_right) {
725 
+                i = block_pos_right;
726 
+            }
727 
+
728 
+            block_matching(s, ref, ref_linesize, j, i, plane, jobnr);
729 
+
730 
+            s->block_filtering(s, src, src_linesize,
731 
+                               ref, ref_linesize, j, i, plane, jobnr);
732 
+        }
733 
+    }
734 
+
735 
+    return 0;
736 
+}
737 
+
738 
+static int filter_frame(AVFilterContext *ctx, AVFrame **out, AVFrame *in, AVFrame *ref)
739 
+{
740 
+    BM3DContext *s = ctx->priv;
741 
+    AVFilterLink *outlink = ctx->outputs[0];
742 
+    int p;
743 
+
744 
+    *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
745 
+    if (!*out)
746 
+        return AVERROR(ENOMEM);
747 
+    av_frame_copy_props(*out, in);
748 
+
749 
+    for (p = 0; p < s->nb_planes; p++) {
750 
+        const int nb_jobs = FFMIN(s->nb_threads, s->planeheight[p] / s->block_step);
751 
+        ThreadData td;
752 
+
753 
+        if (!((1 << p) & s->planes) || ctx->is_disabled) {
754 
+            av_image_copy_plane((*out)->data[p], (*out)->linesize[p],
755 
+                                in->data[p], in->linesize[p],
756 
+                                s->planewidth[p], s->planeheight[p]);
757 
+            continue;
758 
+        }
759 
+
760 
+        td.src = in->data[p];
761 
+        td.src_linesize = in->linesize[p];
762 
+        td.ref = ref->data[p];
763 
+        td.ref_linesize = ref->linesize[p];
764 
+        td.plane = p;
765 
+        ctx->internal->execute(ctx, filter_slice, &td, NULL, nb_jobs);
766 
+
767 
+        s->do_output(s, (*out)->data[p], (*out)->linesize[p], p, nb_jobs);
768 
+    }
769 
+
770 
+    return 0;
771 
+}
772 
+
773 
+#define SQR(x) ((x) * (x))
774 
+
775 
+static int config_input(AVFilterLink *inlink)
776 
+{
777 
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
778 
+    AVFilterContext *ctx = inlink->dst;
779 
+    BM3DContext *s = ctx->priv;
780 
+    int i, group_bits;
781 
+
782 
+    s->nb_threads = FFMIN(ff_filter_get_nb_threads(ctx), MAX_NB_THREADS);
783 
+    s->nb_planes = av_pix_fmt_count_planes(inlink->format);
784 
+    s->depth = desc->comp[0].depth;
785 
+    s->max = (1 << s->depth) - 1;
786 
+    s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
787 
+    s->planeheight[0] = s->planeheight[3] = inlink->h;
788 
+    s->planewidth[1]  = s->planewidth[2]  = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
789 
+    s->planewidth[0]  = s->planewidth[3]  = inlink->w;
790 
+
791 
+    for (group_bits = 4; 1 << group_bits < s->group_size; group_bits++);
792 
+    s->group_bits = group_bits;
793 
+    s->pgroup_size = 1 << group_bits;
794 
+
795 
+    for (i = 0; i < s->nb_threads; i++) {
796 
+        SliceContext *sc = &s->slices[i];
797 
+
798 
+        sc->num = av_calloc(s->planewidth[0] * s->planeheight[0], sizeof(FFTSample));
799 
+        sc->den = av_calloc(s->planewidth[0] * s->planeheight[0], sizeof(FFTSample));
800 
+        if (!sc->num || !sc->den)
801 
+            return AVERROR(ENOMEM);
802 
+
803 
+        sc->dctf = av_dct_init(av_log2(s->block_size), DCT_II);
804 
+        sc->dcti = av_dct_init(av_log2(s->block_size), DCT_III);
805 
+        if (!sc->dctf || !sc->dcti)
806 
+            return AVERROR(ENOMEM);
807 
+
808 
+        if (s->group_bits > 1) {
809 
+            sc->gdctf = av_dct_init(s->group_bits, DCT_II);
810 
+            sc->gdcti = av_dct_init(s->group_bits, DCT_III);
811 
+            if (!sc->gdctf || !sc->gdcti)
812 
+                return AVERROR(ENOMEM);
813 
+        }
814 
+
815 
+        sc->buffer = av_calloc(s->block_size * s->block_size * s->pgroup_size, sizeof(*sc->buffer));
816 
+        sc->bufferz = av_calloc(s->block_size * s->block_size * s->pgroup_size, sizeof(*sc->bufferz));
817 
+        sc->bufferh = av_calloc(s->block_size * s->block_size, sizeof(*sc->bufferh));
818 
+        sc->bufferv = av_calloc(s->block_size * s->block_size, sizeof(*sc->bufferv));
819 
+        if (!sc->bufferh || !sc->bufferv || !sc->buffer || !sc->bufferz)
820 
+            return AVERROR(ENOMEM);
821 
+
822 
+        if (s->mode == FINAL) {
823 
+            sc->rbuffer = av_calloc(s->block_size * s->block_size * s->pgroup_size, sizeof(*sc->rbuffer));
824 
+            sc->rbufferz = av_calloc(s->block_size * s->block_size * s->pgroup_size, sizeof(*sc->rbufferz));
825 
+            sc->rbufferh = av_calloc(s->block_size * s->block_size, sizeof(*sc->rbufferh));
826 
+            sc->rbufferv = av_calloc(s->block_size * s->block_size, sizeof(*sc->rbufferv));
827 
+            if (!sc->rbufferh || !sc->rbufferv || !sc->rbuffer || !sc->rbufferz)
828 
+                return AVERROR(ENOMEM);
829 
+        }
830 
+
831 
+        sc->search_positions = av_calloc(SQR(2 * s->bm_range / s->bm_step + 1), sizeof(*sc->search_positions));
832 
+        if (!sc->search_positions)
833 
+            return AVERROR(ENOMEM);
834 
+    }
835 
+
836 
+    s->do_output = do_output;
837 
+    s->do_block_ssd = do_block_ssd;
838 
+    s->get_block_row = get_block_row;
839 
+
840 
+    if (s->depth > 8) {
841 
+        s->do_output = do_output16;
842 
+        s->do_block_ssd = do_block_ssd16;
843 
+        s->get_block_row = get_block_row16;
844 
+    }
845 
+
846 
+    return 0;
847 
+}
848 
+
849 
+static int activate(AVFilterContext *ctx)
850 
+{
851 
+    BM3DContext *s = ctx->priv;
852 
+
853 
+    if (!s->ref) {
854 
+        AVFrame *frame = NULL;
855 
+        AVFrame *out = NULL;
856 
+        int ret, status;
857 
+        int64_t pts;
858 
+
859 
+        if ((ret = ff_inlink_consume_frame(ctx->inputs[0], &frame)) > 0) {
860 
+            ret = filter_frame(ctx, &out, frame, frame);
861 
+            av_frame_free(&frame);
862 
+            if (ret < 0)
863 
+                return ret;
864 
+            ret = ff_filter_frame(ctx->outputs[0], out);
865 
+        }
866 
+        if (ret < 0) {
867 
+            return ret;
868 
+        } else if (ff_inlink_acknowledge_status(ctx->inputs[0], &status, &pts)) {
869 
+            ff_outlink_set_status(ctx->outputs[0], status, pts);
870 
+            return 0;
871 
+        } else {
872 
+            if (ff_outlink_frame_wanted(ctx->outputs[0]))
873 
+                ff_inlink_request_frame(ctx->inputs[0]);
874 
+            return 0;
875 
+        }
876 
+    } else {
877 
+        return ff_framesync_activate(&s->fs);
878 
+    }
879 
+}
880 
+
881 
+static int process_frame(FFFrameSync *fs)
882 
+{
883 
+    AVFilterContext *ctx = fs->parent;
884 
+    BM3DContext *s = fs->opaque;
885 
+    AVFilterLink *outlink = ctx->outputs[0];
886 
+    AVFrame *out = NULL, *src, *ref;
887 
+    int ret;
888 
+
889 
+    if ((ret = ff_framesync_get_frame(&s->fs, 0, &src, 0)) < 0 ||
890 
+        (ret = ff_framesync_get_frame(&s->fs, 1, &ref, 0)) < 0)
891 
+        return ret;
892 
+
893 
+    if ((ret = filter_frame(ctx, &out, src, ref)) < 0)
894 
+        return ret;
895 
+
896 
+    out->pts = av_rescale_q(src->pts, s->fs.time_base, outlink->time_base);
897 
+
898 
+    return ff_filter_frame(outlink, out);
899 
+}
900 
+
901 
+static av_cold int init(AVFilterContext *ctx)
902 
+{
903 
+    BM3DContext *s = ctx->priv;
904 
+    AVFilterPad pad = { 0 };
905 
+    int ret;
906 
+
907 
+    if (s->mode == BASIC) {
908 
+        if (s->th_mse == 0.f)
909 
+            s->th_mse = 400.f + s->sigma * 80.f;
910 
+        s->block_filtering = basic_block_filtering;
911 
+    } else if (s->mode == FINAL) {
912 
+        if (!s->ref) {
913 
+            av_log(ctx, AV_LOG_WARNING, "Reference stream is mandatory in final estimation mode.\n");
914 
+            s->ref = 1;
915 
+        }
916 
+        if (s->th_mse == 0.f)
917 
+            s->th_mse = 200.f + s->sigma * 10.f;
918 
+
919 
+        s->block_filtering = final_block_filtering;
920 
+    } else {
921 
+        return AVERROR_BUG;
922 
+    }
923 
+
924 
+    s->block_size = 1 << s->block_size;
925 
+
926 
+    if (s->block_step > s->block_size) {
927 
+        av_log(ctx, AV_LOG_WARNING, "bstep: %d can't be bigger than block size. Changing to %d.\n",
928 
+               s->block_step, s->block_size);
929 
+        s->block_step = s->block_size;
930 
+    }
931 
+    if (s->bm_step > s->bm_range) {
932 
+        av_log(ctx, AV_LOG_WARNING, "mstep: %d can't be bigger than block matching range. Changing to %d.\n",
933 
+               s->bm_step, s->bm_range);
934 
+        s->bm_step = s->bm_range;
935 
+    }
936 
+
937 
+    pad.type         = AVMEDIA_TYPE_VIDEO;
938 
+    pad.name         = av_strdup("source");
939 
+    pad.config_props = config_input;
940 
+    if (!pad.name)
941 
+        return AVERROR(ENOMEM);
942 
+
943 
+    if ((ret = ff_insert_inpad(ctx, 0, &pad)) < 0) {
944 
+        av_freep(&pad.name);
945 
+        return ret;
946 
+    }
947 
+
948 
+    if (s->ref) {
949 
+        pad.type         = AVMEDIA_TYPE_VIDEO;
950 
+        pad.name         = av_strdup("reference");
951 
+        pad.config_props = NULL;
952 
+        if (!pad.name)
953 
+            return AVERROR(ENOMEM);
954 
+
955 
+        if ((ret = ff_insert_inpad(ctx, 1, &pad)) < 0) {
956 
+            av_freep(&pad.name);
957 
+            return ret;
958 
+        }
959 
+    }
960 
+
961 
+    return 0;
962 
+}
963 
+
964 
+static int config_output(AVFilterLink *outlink)
965 
+{
966 
+    AVFilterContext *ctx = outlink->src;
967 
+    BM3DContext *s = ctx->priv;
968 
+    AVFilterLink *src = ctx->inputs[0];
969 
+    AVFilterLink *ref;
970 
+    FFFrameSyncIn *in;
971 
+    int ret;
972 
+
973 
+    if (s->ref) {
974 
+        ref = ctx->inputs[1];
975 
+
976 
+        if (src->format != ref->format) {
977 
+            av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n");
978 
+            return AVERROR(EINVAL);
979 
+        }
980 
+        if (src->w                       != ref->w ||
981 
+            src->h                       != ref->h) {
982 
+            av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
983 
+                   "(size %dx%d) do not match the corresponding "
984 
+                   "second input link %s parameters (%dx%d) ",
985 
+                   ctx->input_pads[0].name, src->w, src->h,
986 
+                   ctx->input_pads[1].name, ref->w, ref->h);
987 
+            return AVERROR(EINVAL);
988 
+        }
989 
+    }
990 
+
991 
+    outlink->w = src->w;
992 
+    outlink->h = src->h;
993 
+    outlink->time_base = src->time_base;
994 
+    outlink->sample_aspect_ratio = src->sample_aspect_ratio;
995 
+    outlink->frame_rate = src->frame_rate;
996 
+
997 
+    if (!s->ref)
998 
+        return 0;
999 
+
1000 
+    if ((ret = ff_framesync_init(&s->fs, ctx, 2)) < 0)
1001 
+        return ret;
1002 
+
1003 
+    in = s->fs.in;
1004 
+    in[0].time_base = src->time_base;
1005 
+    in[1].time_base = ref->time_base;
1006 
+    in[0].sync   = 1;
1007 
+    in[0].before = EXT_STOP;
1008 
+    in[0].after  = EXT_STOP;
1009 
+    in[1].sync   = 1;
1010 
+    in[1].before = EXT_STOP;
1011 
+    in[1].after  = EXT_STOP;
1012 
+    s->fs.opaque   = s;
1013 
+    s->fs.on_event = process_frame;
1014 
+
1015 
+    return ff_framesync_configure(&s->fs);
1016 
+}
1017 
+
1018 
+static av_cold void uninit(AVFilterContext *ctx)
1019 
+{
1020 
+    BM3DContext *s = ctx->priv;
1021 
+    int i;
1022 
+
1023 
+    for (i = 0; i < ctx->nb_inputs; i++)
1024 
+        av_freep(&ctx->input_pads[i].name);
1025 
+
1026 
+    if (s->ref)
1027 
+        ff_framesync_uninit(&s->fs);
1028 
+
1029 
+    for (i = 0; i < s->nb_threads; i++) {
1030 
+        SliceContext *sc = &s->slices[i];
1031 
+
1032 
+        av_freep(&sc->num);
1033 
+        av_freep(&sc->den);
1034 
+
1035 
+        av_dct_end(sc->gdctf);
1036 
+        av_dct_end(sc->gdcti);
1037 
+        av_dct_end(sc->dctf);
1038 
+        av_dct_end(sc->dcti);
1039 
+
1040 
+        av_freep(&sc->buffer);
1041 
+        av_freep(&sc->bufferh);
1042 
+        av_freep(&sc->bufferv);
1043 
+        av_freep(&sc->bufferz);
1044 
+        av_freep(&sc->rbuffer);
1045 
+        av_freep(&sc->rbufferh);
1046 
+        av_freep(&sc->rbufferv);
1047 
+        av_freep(&sc->rbufferz);
1048 
+
1049 
+        av_freep(&sc->search_positions);
1050 
+    }
1051 
+}
1052 
+
1053 
+static const AVFilterPad bm3d_outputs[] = {
1054 
+    {
1055 
+        .name         = "default",
1056 
+        .type         = AVMEDIA_TYPE_VIDEO,
1057 
+        .config_props = config_output,
1058 
+    },
1059 
+    { NULL }
1060 
+};
1061 
+
1062 
+AVFilter ff_vf_bm3d = {
1063 
+    .name          = "bm3d",
1064 
+    .description   = NULL_IF_CONFIG_SMALL("Block-Matching 3D denoiser."),
1065 
+    .priv_size     = sizeof(BM3DContext),
1066 
+    .init          = init,
1067 
+    .uninit        = uninit,
1068 
+    .activate      = activate,
1069 
+    .query_formats = query_formats,
1070 
+    .inputs        = NULL,
1071 
+    .outputs       = bm3d_outputs,
1072 
+    .priv_class    = &bm3d_class,
1073 
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
1074 
+                     AVFILTER_FLAG_DYNAMIC_INPUTS |
1075 
+                     AVFILTER_FLAG_SLICE_THREADS,
1076 
+};