avfilter/af_ladspa: use av_sscanf()
[ffmpeg.git] / libavfilter / vf_dedot.c
1 /*
2  * Copyright (c) 2018 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 #include "libavutil/imgutils.h"
22 #include "libavutil/opt.h"
23 #include "libavutil/pixdesc.h"
24
25 #include "avfilter.h"
26 #include "filters.h"
27 #include "formats.h"
28 #include "internal.h"
29 #include "video.h"
30
31 typedef struct DedotContext {
32     const AVClass *class;
33     int m;
34     float lt;
35     float tl;
36     float tc;
37     float ct;
38
39     const AVPixFmtDescriptor *desc;
40     int depth;
41     int max;
42     int luma2d;
43     int lumaT;
44     int chromaT1;
45     int chromaT2;
46
47     int eof;
48     int eof_frames;
49     int nb_planes;
50     int planewidth[4];
51     int planeheight[4];
52
53     AVFrame *frames[5];
54
55     int (*dedotcrawl)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
56     int (*derainbow)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
57 } DedotContext;
58
59 static int query_formats(AVFilterContext *ctx)
60 {
61     static const enum AVPixelFormat pixel_fmts[] = {
62         AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
63         AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
64         AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
65         AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
66         AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
67         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
68         AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
69         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
70         AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
71         AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
72         AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
73         AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
74         AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
75         AV_PIX_FMT_NONE
76     };
77     AVFilterFormats *formats = ff_make_format_list(pixel_fmts);
78     if (!formats)
79         return AVERROR(ENOMEM);
80     return ff_set_common_formats(ctx, formats);
81 }
82
83 #define DEFINE_DEDOTCRAWL(name, type, div)                       \
84 static int dedotcrawl##name(AVFilterContext *ctx, void *arg,     \
85                             int jobnr, int nb_jobs)              \
86 {                                                                \
87     DedotContext *s = ctx->priv;                                 \
88     AVFrame *out = arg;                                          \
89     int src_linesize = s->frames[2]->linesize[0] / div;          \
90     int dst_linesize = out->linesize[0] / div;                   \
91     int p0_linesize = s->frames[0]->linesize[0] / div;           \
92     int p1_linesize = s->frames[1]->linesize[0] / div;           \
93     int p3_linesize = s->frames[3]->linesize[0] / div;           \
94     int p4_linesize = s->frames[4]->linesize[0] / div;           \
95     const int h = s->planeheight[0];                             \
96     int slice_start = (h * jobnr) / nb_jobs;                     \
97     int slice_end = (h * (jobnr+1)) / nb_jobs;                   \
98     type *p0 = (type *)s->frames[0]->data[0];                    \
99     type *p1 = (type *)s->frames[1]->data[0];                    \
100     type *p3 = (type *)s->frames[3]->data[0];                    \
101     type *p4 = (type *)s->frames[4]->data[0];                    \
102     type *src = (type *)s->frames[2]->data[0];                   \
103     type *dst = (type *)out->data[0];                            \
104     const int luma2d = s->luma2d;                                \
105     const int lumaT = s->lumaT;                                  \
106                                                                  \
107     if (!slice_start) {                                          \
108         slice_start++;                                           \
109     }                                                            \
110     p0 += p0_linesize * slice_start;                             \
111     p1 += p1_linesize * slice_start;                             \
112     p3 += p3_linesize * slice_start;                             \
113     p4 += p4_linesize * slice_start;                             \
114     src += src_linesize * slice_start;                           \
115     dst += dst_linesize * slice_start;                           \
116     if (slice_end == h) {                                        \
117         slice_end--;                                             \
118     }                                                            \
119     for (int y = slice_start; y < slice_end; y++) {              \
120         for (int x = 1; x < s->planewidth[0] - 1; x++) {         \
121             int above = src[x - src_linesize];                   \
122             int bellow = src[x + src_linesize];                  \
123             int cur = src[x];                                    \
124             int left = src[x - 1];                               \
125             int right = src[x + 1];                              \
126                                                                  \
127             if (FFABS(above + bellow - 2 * cur) <= luma2d &&     \
128                 FFABS(left + right - 2 * cur) <= luma2d)         \
129                 continue;                                        \
130                                                                  \
131             if (FFABS(cur - p0[x]) <= lumaT &&                   \
132                 FFABS(cur - p4[x]) <= lumaT &&                   \
133                 FFABS(p1[x] - p3[x]) <= lumaT) {                 \
134                 int diff1 = FFABS(cur - p1[x]);                  \
135                 int diff2 = FFABS(cur - p3[x]);                  \
136                                                                  \
137                 if (diff1 < diff2)                               \
138                     dst[x] = (src[x] + p1[x] + 1) >> 1;          \
139                 else                                             \
140                     dst[x] = (src[x] + p3[x] + 1) >> 1;          \
141             }                                                    \
142         }                                                        \
143                                                                  \
144         dst += dst_linesize;                                     \
145         src += src_linesize;                                     \
146         p0 += p0_linesize;                                       \
147         p1 += p1_linesize;                                       \
148         p3 += p3_linesize;                                       \
149         p4 += p4_linesize;                                       \
150     }                                                            \
151     return 0;                                                    \
152 }
153
154 DEFINE_DEDOTCRAWL(8, uint8_t, 1)
155 DEFINE_DEDOTCRAWL(16, uint16_t, 2)
156
157 typedef struct ThreadData {
158     AVFrame *out;
159     int plane;
160 } ThreadData;
161
162 #define DEFINE_DERAINBOW(name, type, div)                    \
163 static int derainbow##name(AVFilterContext *ctx, void *arg,  \
164                            int jobnr, int nb_jobs)           \
165 {                                                            \
166     DedotContext *s = ctx->priv;                             \
167     ThreadData *td = arg;                                    \
168     AVFrame *out = td->out;                                  \
169     const int plane = td->plane;                             \
170     const int h = s->planeheight[plane];                     \
171     int slice_start = (h * jobnr) / nb_jobs;                 \
172     int slice_end = (h * (jobnr+1)) / nb_jobs;               \
173     int src_linesize = s->frames[2]->linesize[plane] / div;  \
174     int dst_linesize = out->linesize[plane] / div;           \
175     int p0_linesize = s->frames[0]->linesize[plane] / div;   \
176     int p1_linesize = s->frames[1]->linesize[plane] / div;   \
177     int p3_linesize = s->frames[3]->linesize[plane] / div;   \
178     int p4_linesize = s->frames[4]->linesize[plane] / div;   \
179     type *p0 = (type *)s->frames[0]->data[plane];            \
180     type *p1 = (type *)s->frames[1]->data[plane];            \
181     type *p3 = (type *)s->frames[3]->data[plane];            \
182     type *p4 = (type *)s->frames[4]->data[plane];            \
183     type *src = (type *)s->frames[2]->data[plane];           \
184     type *dst = (type *)out->data[plane];                    \
185     const int chromaT1 = s->chromaT1;                        \
186     const int chromaT2 = s->chromaT2;                        \
187                                                              \
188     p0 += slice_start * p0_linesize;                         \
189     p1 += slice_start * p1_linesize;                         \
190     p3 += slice_start * p3_linesize;                         \
191     p4 += slice_start * p4_linesize;                         \
192     src += slice_start * src_linesize;                       \
193     dst += slice_start * dst_linesize;                       \
194     for (int y = slice_start; y < slice_end; y++) {          \
195         for (int x = 0; x < s->planewidth[plane]; x++) {     \
196             int cur = src[x];                                \
197                                                              \
198             if (FFABS(cur - p0[x]) <= chromaT1 &&            \
199                 FFABS(cur - p4[x]) <= chromaT1 &&            \
200                 FFABS(p1[x] - p3[x]) <= chromaT1 &&          \
201                 FFABS(cur - p1[x]) > chromaT2 &&             \
202                 FFABS(cur - p3[x]) > chromaT2) {             \
203                 int diff1 = FFABS(cur - p1[x]);              \
204                 int diff2 = FFABS(cur - p3[x]);              \
205                                                              \
206                 if (diff1 < diff2)                           \
207                     dst[x] = (src[x] + p1[x] + 1) >> 1;      \
208                 else                                         \
209                     dst[x] = (src[x] + p3[x] + 1) >> 1;      \
210             }                                                \
211         }                                                    \
212                                                              \
213         dst += dst_linesize;                                 \
214         src += src_linesize;                                 \
215         p0 += p0_linesize;                                   \
216         p1 += p1_linesize;                                   \
217         p3 += p3_linesize;                                   \
218         p4 += p4_linesize;                                   \
219     }                                                        \
220     return 0;                                                \
221 }
222
223 DEFINE_DERAINBOW(8, uint8_t, 1)
224 DEFINE_DERAINBOW(16, uint16_t, 2)
225
226 static int config_output(AVFilterLink *outlink)
227 {
228     AVFilterContext *ctx = outlink->src;
229     DedotContext *s = ctx->priv;
230     AVFilterLink *inlink = ctx->inputs[0];
231
232     s->desc = av_pix_fmt_desc_get(outlink->format);
233     if (!s->desc)
234         return AVERROR_BUG;
235     s->nb_planes = av_pix_fmt_count_planes(outlink->format);
236     s->depth = s->desc->comp[0].depth;
237     s->max = (1 << s->depth) - 1;
238     s->luma2d = s->lt * s->max;
239     s->lumaT = s->tl * s->max;
240     s->chromaT1 = s->tc * s->max;
241     s->chromaT2 = s->ct * s->max;
242
243     s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, s->desc->log2_chroma_w);
244     s->planewidth[0] = s->planewidth[3] = inlink->w;
245
246     s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, s->desc->log2_chroma_h);
247     s->planeheight[0] = s->planeheight[3] = inlink->h;
248
249     if (s->depth <= 8) {
250         s->dedotcrawl = dedotcrawl8;
251         s->derainbow = derainbow8;
252     } else {
253         s->dedotcrawl = dedotcrawl16;
254         s->derainbow = derainbow16;
255     }
256
257     return 0;
258 }
259
260 static int activate(AVFilterContext *ctx)
261 {
262     AVFilterLink *inlink = ctx->inputs[0];
263     AVFilterLink *outlink = ctx->outputs[0];
264     DedotContext *s = ctx->priv;
265     AVFrame *frame = NULL;
266     int64_t pts;
267     int status;
268     int ret = 0;
269
270     FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
271
272     if (s->eof == 0) {
273         ret = ff_inlink_consume_frame(inlink, &frame);
274         if (ret < 0)
275             return ret;
276     }
277     if (frame || s->eof_frames > 0) {
278         AVFrame *out = NULL;
279
280         if (frame) {
281             for (int i = 2; i < 5; i++) {
282                 if (!s->frames[i])
283                     s->frames[i] = av_frame_clone(frame);
284             }
285             av_frame_free(&frame);
286         } else {
287             s->eof_frames--;
288             s->frames[4] = av_frame_clone(s->frames[3]);
289         }
290
291         if (s->frames[0] &&
292             s->frames[1] &&
293             s->frames[2] &&
294             s->frames[3] &&
295             s->frames[4]) {
296             out = av_frame_clone(s->frames[2]);
297             if (out && !ctx->is_disabled) {
298                 ret = av_frame_make_writable(out);
299                 if (ret >= 0) {
300                     if (s->m & 1)
301                         ctx->internal->execute(ctx, s->dedotcrawl, out, NULL,
302                                                FFMIN(s->planeheight[0],
303                                                ff_filter_get_nb_threads(ctx)));
304                     if (s->m & 2) {
305                         ThreadData td;
306                         td.out = out; td.plane = 1;
307                         ctx->internal->execute(ctx, s->derainbow, &td, NULL,
308                                                FFMIN(s->planeheight[1],
309                                                ff_filter_get_nb_threads(ctx)));
310                         td.plane = 2;
311                         ctx->internal->execute(ctx, s->derainbow, &td, NULL,
312                                                FFMIN(s->planeheight[2],
313                                                ff_filter_get_nb_threads(ctx)));
314                     }
315                 }
316             } else if (!out) {
317                 ret = AVERROR(ENOMEM);
318             }
319         }
320
321         av_frame_free(&s->frames[0]);
322         s->frames[0] = s->frames[1];
323         s->frames[1] = s->frames[2];
324         s->frames[2] = s->frames[3];
325         s->frames[3] = s->frames[4];
326         s->frames[4] = NULL;
327
328         if (ret < 0)
329             return ret;
330         if (out)
331             return ff_filter_frame(outlink, out);
332     }
333
334     if (s->eof) {
335         if (s->eof_frames <= 0) {
336             ff_outlink_set_status(outlink, AVERROR_EOF, s->frames[2]->pts);
337         } else {
338             ff_filter_set_ready(ctx, 10);
339         }
340         return 0;
341     }
342
343     if (!s->eof && ff_inlink_acknowledge_status(inlink, &status, &pts)) {
344         if (status == AVERROR_EOF) {
345             s->eof = 1;
346             s->eof_frames = 2;
347             ff_filter_set_ready(ctx, 10);
348             return 0;
349         }
350     }
351
352     FF_FILTER_FORWARD_WANTED(outlink, inlink);
353
354     return FFERROR_NOT_READY;
355 }
356
357 static av_cold void uninit(AVFilterContext *ctx)
358 {
359     DedotContext *s = ctx->priv;
360
361     for (int i = 0; i < 5; i++)
362         av_frame_free(&s->frames[i]);
363 }
364
365 #define OFFSET(x) offsetof(DedotContext, x)
366 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM
367
368 static const AVOption dedot_options[] = {
369     { "m",   "set filtering mode",                          OFFSET( m), AV_OPT_TYPE_FLAGS, {.i64=3},    0, 3, FLAGS, "m" },
370     { "dotcrawl",                                           0,       0, AV_OPT_TYPE_CONST, {.i64=1},    0, 0, FLAGS, "m" },
371     { "rainbows",                                           0,       0, AV_OPT_TYPE_CONST, {.i64=2},    0, 0, FLAGS, "m" },
372     { "lt",  "set spatial luma threshold",                  OFFSET(lt), AV_OPT_TYPE_FLOAT, {.dbl=.079}, 0, 1, FLAGS },
373     { "tl",  "set tolerance for temporal luma",             OFFSET(tl), AV_OPT_TYPE_FLOAT, {.dbl=.079}, 0, 1, FLAGS },
374     { "tc",  "set tolerance for chroma temporal variation", OFFSET(tc), AV_OPT_TYPE_FLOAT, {.dbl=.058}, 0, 1, FLAGS },
375     { "ct",  "set temporal chroma threshold",               OFFSET(ct), AV_OPT_TYPE_FLOAT, {.dbl=.019}, 0, 1, FLAGS },
376     { NULL },
377 };
378
379 static const AVFilterPad inputs[] = {
380     {
381         .name           = "default",
382         .type           = AVMEDIA_TYPE_VIDEO,
383     },
384     { NULL }
385 };
386
387 static const AVFilterPad outputs[] = {
388     {
389         .name          = "default",
390         .type          = AVMEDIA_TYPE_VIDEO,
391         .config_props  = config_output,
392     },
393     { NULL }
394 };
395
396 AVFILTER_DEFINE_CLASS(dedot);
397
398 AVFilter ff_vf_dedot = {
399     .name          = "dedot",
400     .description   = NULL_IF_CONFIG_SMALL("Reduce cross-luminance and cross-color."),
401     .priv_size     = sizeof(DedotContext),
402     .priv_class    = &dedot_class,
403     .query_formats = query_formats,
404     .activate      = activate,
405     .uninit        = uninit,
406     .inputs        = inputs,
407     .outputs       = outputs,
408     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
409 };