avfilter/vf_atadenoise: fix file permissions
[ffmpeg.git] / libavfilter / vf_atadenoise.c
1 /*
2  * Copyright (c) 2015 Paul B Mahol
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 /**
22  * @file
23  * Adaptive Temporal Averaging Denoiser,
24  * based on paper "Video Denoising Based on Adaptive Temporal Averaging" by
25  * David Bartovčak and Miroslav Vrankić
26  */
27
28 #include "libavutil/opt.h"
29 #include "libavutil/pixdesc.h"
30 #include "avfilter.h"
31
32 #define FF_BUFQUEUE_SIZE 129
33 #include "bufferqueue.h"
34
35 #include "formats.h"
36 #include "internal.h"
37 #include "video.h"
38
39 #define SIZE FF_BUFQUEUE_SIZE
40
41 typedef struct ATADenoiseContext {
42     const AVClass *class;
43
44     float fthra[4], fthrb[4];
45     int thra[4], thrb[4];
46
47     int nb_planes;
48     int planewidth[4];
49     int planeheight[4];
50
51     struct FFBufQueue q;
52     void *data[4][SIZE];
53     int linesize[4][SIZE];
54     int size, mid;
55     int available;
56
57     int (*filter_slice)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
58 } ATADenoiseContext;
59
60 #define OFFSET(x) offsetof(ATADenoiseContext, x)
61 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
62
63 static const AVOption atadenoise_options[] = {
64     { "0a", "set threshold A for 1st plane", OFFSET(fthra[0]), AV_OPT_TYPE_FLOAT, {.dbl=0.02}, 0, 0.3, FLAGS },
65     { "0b", "set threshold B for 1st plane", OFFSET(fthrb[0]), AV_OPT_TYPE_FLOAT, {.dbl=0.04}, 0, 5.0, FLAGS },
66     { "1a", "set threshold A for 2nd plane", OFFSET(fthra[1]), AV_OPT_TYPE_FLOAT, {.dbl=0.02}, 0, 0.3, FLAGS },
67     { "1b", "set threshold B for 2nd plane", OFFSET(fthrb[1]), AV_OPT_TYPE_FLOAT, {.dbl=0.04}, 0, 5.0, FLAGS },
68     { "2a", "set threshold A for 3rd plane", OFFSET(fthra[2]), AV_OPT_TYPE_FLOAT, {.dbl=0.02}, 0, 0.3, FLAGS },
69     { "2b", "set threshold B for 3rd plane", OFFSET(fthrb[2]), AV_OPT_TYPE_FLOAT, {.dbl=0.04}, 0, 5.0, FLAGS },
70     { "s",  "set how many frames to use",    OFFSET(size),     AV_OPT_TYPE_INT,   {.i64=33},   5, SIZE, FLAGS },
71     { NULL }
72 };
73
74 AVFILTER_DEFINE_CLASS(atadenoise);
75
76 static int query_formats(AVFilterContext *ctx)
77 {
78     static const enum AVPixelFormat pixel_fmts[] = {
79         AV_PIX_FMT_GRAY8,
80         AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
81         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
82         AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
83         AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
84         AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
85         AV_PIX_FMT_YUVJ411P,
86         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
87         AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
88         AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
89         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
90         AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
91         AV_PIX_FMT_NONE
92     };
93     AVFilterFormats *formats = ff_make_format_list(pixel_fmts);
94     if (!formats)
95         return AVERROR(ENOMEM);
96     return ff_set_common_formats(ctx, formats);
97 }
98
99 static av_cold int init(AVFilterContext *ctx)
100 {
101     ATADenoiseContext *s = ctx->priv;
102
103     if (!(s->size & 1)) {
104         av_log(ctx, AV_LOG_ERROR, "size %d is invalid. Must be an odd value.\n", s->size);
105         return AVERROR(EINVAL);
106     }
107     s->mid = s->size / 2 + 1;
108
109     return 0;
110 }
111
112 typedef struct ThreadData {
113     AVFrame *in, *out;
114 } ThreadData;
115
116 static int filter_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
117 {
118     ATADenoiseContext *s = ctx->priv;
119     ThreadData *td = arg;
120     AVFrame *in = td->in;
121     AVFrame *out = td->out;
122     const int size = s->size;
123     const int mid = s->mid;
124     int p, x, y, i, j;
125
126     for (p = 0; p < s->nb_planes; p++) {
127         const int h = s->planeheight[p];
128         const int w = s->planewidth[p];
129         const int slice_start = (h * jobnr) / nb_jobs;
130         const int slice_end = (h * (jobnr+1)) / nb_jobs;
131         const uint8_t *src = in->data[p] + slice_start * in->linesize[p];
132         uint8_t *dst = out->data[p] + slice_start * out->linesize[p];
133         const int thra = s->thra[p];
134         const int thrb = s->thrb[p];
135         const uint8_t **data = (const uint8_t **)s->data[p];
136         const int *linesize = (const int *)s->linesize[p];
137         const uint8_t *srcf[SIZE];
138
139         for (i = 0; i < size; i++)
140             srcf[i] = data[i] + slice_start * linesize[i];
141
142         for (y = slice_start; y < slice_end; y++) {
143             for (x = 0; x < w; x++) {
144                 const int srcx = src[x];
145                 unsigned lsumdiff = 0, rsumdiff = 0;
146                 unsigned ldiff, rdiff;
147                 unsigned sum = srcx;
148                 int l = 0, r = 0;
149                 int srcjx, srcix;
150
151                 for (j = mid - 1, i = mid + 1; j >= 0 && i < size; j--, i++) {
152                     srcjx = srcf[j][x];
153
154                     ldiff = FFABS(srcx - srcjx);
155                     lsumdiff += ldiff;
156                     if (ldiff > thra ||
157                         lsumdiff > thrb)
158                         break;
159                     l++;
160                     sum += srcjx;
161
162                     srcix = srcf[i][x];
163
164                     rdiff = FFABS(srcx - srcix);
165                     rsumdiff += rdiff;
166                     if (rdiff > thra ||
167                         rsumdiff > thrb)
168                         break;
169                     r++;
170                     sum += srcix;
171                 }
172
173                 dst[x] = sum / (r + l + 1);
174             }
175
176             dst += out->linesize[p];
177             src += in->linesize[p];
178
179             for (i = 0; i < size; i++)
180                 srcf[i] += linesize[i];
181         }
182     }
183
184     return 0;
185 }
186
187 static int filter_slice16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
188 {
189     ATADenoiseContext *s = ctx->priv;
190     ThreadData *td = arg;
191     AVFrame *in = td->in;
192     AVFrame *out = td->out;
193     const int size = s->size;
194     const int mid = s->mid;
195     int p, x, y, i, j;
196
197     for (p = 0; p < s->nb_planes; p++) {
198         const int h = s->planeheight[p];
199         const int w = s->planewidth[p];
200         const int slice_start = (h * jobnr) / nb_jobs;
201         const int slice_end = (h * (jobnr+1)) / nb_jobs;
202         const uint16_t *src = (uint16_t *)(in->data[p] + slice_start * in->linesize[p]);
203         uint16_t *dst = (uint16_t *)(out->data[p] + slice_start * out->linesize[p]);
204         const int thra = s->thra[p];
205         const int thrb = s->thrb[p];
206         const uint8_t **data = (const uint8_t **)s->data[p];
207         const int *linesize = (const int *)s->linesize[p];
208         const uint16_t *srcf[SIZE];
209
210         for (i = 0; i < s->size; i++)
211             srcf[i] = (const uint16_t *)(data[i] + slice_start * linesize[i]);
212
213         for (y = slice_start; y < slice_end; y++) {
214             for (x = 0; x < w; x++) {
215                 const int srcx = src[x];
216                 unsigned lsumdiff = 0, rsumdiff = 0;
217                 unsigned ldiff, rdiff;
218                 unsigned sum = srcx;
219                 int l = 0, r = 0;
220                 int srcjx, srcix;
221
222                 for (j = mid - 1, i = mid + 1; j >= 0 && i < size; j--, i++) {
223                     srcjx = srcf[j][x];
224
225                     ldiff = FFABS(srcx - srcjx);
226                     lsumdiff += ldiff;
227                     if (ldiff > thra ||
228                         lsumdiff > thrb)
229                         break;
230                     l++;
231                     sum += srcjx;
232
233                     srcix = srcf[i][x];
234
235                     rdiff = FFABS(srcx - srcix);
236                     rsumdiff += rdiff;
237                     if (rdiff > thra ||
238                         rsumdiff > thrb)
239                         break;
240                     r++;
241                     sum += srcix;
242                 }
243
244                 dst[x] = sum / (r + l + 1);
245             }
246
247             dst += out->linesize[p] / 2;
248             src += in->linesize[p] / 2;
249
250             for (i = 0; i < size; i++)
251                 srcf[i] += linesize[i] / 2;
252         }
253     }
254
255     return 0;
256 }
257
258 static int config_input(AVFilterLink *inlink)
259 {
260     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
261     AVFilterContext *ctx = inlink->dst;
262     ATADenoiseContext *s = ctx->priv;
263     int depth;
264
265     s->nb_planes = desc->nb_components;
266
267     s->planeheight[1] = s->planeheight[2] = FF_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
268     s->planeheight[0] = s->planeheight[3] = inlink->h;
269     s->planewidth[1]  = s->planewidth[2]  = FF_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
270     s->planewidth[0]  = s->planewidth[3]  = inlink->w;
271
272     depth = desc->comp[0].depth;
273     if (depth == 8)
274         s->filter_slice = filter_slice8;
275     else
276         s->filter_slice = filter_slice16;
277
278     s->thra[0] = s->fthra[0] * (1 << depth) - 1;
279     s->thra[1] = s->fthra[1] * (1 << depth) - 1;
280     s->thra[2] = s->fthra[2] * (1 << depth) - 1;
281     s->thrb[0] = s->fthrb[0] * (1 << depth) - 1;
282     s->thrb[1] = s->fthrb[1] * (1 << depth) - 1;
283     s->thrb[2] = s->fthrb[2] * (1 << depth) - 1;
284
285     return 0;
286 }
287
288 static int config_output(AVFilterLink *outlink)
289 {
290     outlink->flags |= FF_LINK_FLAG_REQUEST_LOOP;
291     return 0;
292 }
293
294 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
295 {
296     AVFilterContext *ctx = inlink->dst;
297     AVFilterLink *outlink = ctx->outputs[0];
298     ATADenoiseContext *s = ctx->priv;
299     AVFrame *out, *in;
300     int i;
301
302     if (s->q.available != s->size) {
303         if (s->q.available < s->mid) {
304             out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
305             if (!out)
306                 return AVERROR(ENOMEM);
307
308             for (i = 0; i < s->mid; i++)
309                 ff_bufqueue_add(ctx, &s->q, av_frame_clone(out));
310             av_frame_free(&out);
311         }
312         if (s->q.available < s->size) {
313             ff_bufqueue_add(ctx, &s->q, buf);
314             s->available++;
315         }
316         return 0;
317     }
318
319     in = ff_bufqueue_peek(&s->q, s->mid);
320
321     if (!ctx->is_disabled) {
322         ThreadData td;
323
324         out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
325         if (!out) {
326             av_frame_free(&buf);
327             return AVERROR(ENOMEM);
328         }
329
330         for (i = 0; i < s->size; i++) {
331             AVFrame *frame = ff_bufqueue_peek(&s->q, i);
332
333             s->data[0][i] = frame->data[0];
334             s->data[1][i] = frame->data[1];
335             s->data[2][i] = frame->data[2];
336             s->linesize[0][i] = frame->linesize[0];
337             s->linesize[1][i] = frame->linesize[1];
338             s->linesize[2][i] = frame->linesize[2];
339         }
340
341         td.in = in; td.out = out;
342         ctx->internal->execute(ctx, s->filter_slice, &td, NULL,
343                                FFMIN3(s->planeheight[1],
344                                       s->planeheight[2],
345                                       ctx->graph->nb_threads));
346         av_frame_copy_props(out, in);
347     } else {
348         out = av_frame_clone(in);
349         if (!out) {
350             av_frame_free(&buf);
351             return AVERROR(ENOMEM);
352         }
353     }
354
355     in = ff_bufqueue_get(&s->q);
356     av_frame_free(&in);
357     ff_bufqueue_add(ctx, &s->q, buf);
358
359     return ff_filter_frame(outlink, out);
360 }
361
362 static int request_frame(AVFilterLink *outlink)
363 {
364     AVFilterContext *ctx = outlink->src;
365     ATADenoiseContext *s = ctx->priv;
366     int ret = 0;
367
368     ret = ff_request_frame(ctx->inputs[0]);
369
370     if (ret == AVERROR_EOF && !ctx->is_disabled && s->available) {
371         AVFrame *buf = ff_get_video_buffer(outlink, outlink->w, outlink->h);
372         if (!buf)
373             return AVERROR(ENOMEM);
374
375         ret = filter_frame(ctx->inputs[0], buf);
376         s->available--;
377     }
378
379     return ret;
380 }
381
382 static av_cold void uninit(AVFilterContext *ctx)
383 {
384     ATADenoiseContext *s = ctx->priv;
385
386     ff_bufqueue_discard_all(&s->q);
387 }
388
389 static const AVFilterPad inputs[] = {
390     {
391         .name         = "default",
392         .type         = AVMEDIA_TYPE_VIDEO,
393         .filter_frame = filter_frame,
394         .config_props = config_input,
395     },
396     { NULL }
397 };
398
399 static const AVFilterPad outputs[] = {
400     {
401         .name          = "default",
402         .type          = AVMEDIA_TYPE_VIDEO,
403         .request_frame = request_frame,
404         .config_props  = config_output,
405     },
406     { NULL }
407 };
408
409 AVFilter ff_vf_atadenoise = {
410     .name          = "atadenoise",
411     .description   = NULL_IF_CONFIG_SMALL("Apply an Adaptive Temporal Averaging Denoiser."),
412     .priv_size     = sizeof(ATADenoiseContext),
413     .priv_class    = &atadenoise_class,
414     .init          = init,
415     .uninit        = uninit,
416     .query_formats = query_formats,
417     .inputs        = inputs,
418     .outputs       = outputs,
419     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
420 };