avfilter/af_ladspa: process all channels for nb_handles > 1
[ffmpeg.git] / libavfilter / f_drawgraph.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 #include "float.h"
22
23 #include "libavutil/eval.h"
24 #include "libavutil/intreadwrite.h"
25 #include "libavutil/opt.h"
26 #include "avfilter.h"
27 #include "formats.h"
28 #include "internal.h"
29 #include "video.h"
30
31 typedef struct DrawGraphContext {
32     const AVClass *class;
33
34     char          *key[4];
35     float         min, max;
36     char          *fg_str[4];
37     AVExpr        *fg_expr[4];
38     uint8_t       bg[4];
39     int           mode;
40     int           slide;
41     int           w, h;
42
43     AVFrame       *out;
44     int           x;
45     int           prev_y[4];
46     int           first;
47 } DrawGraphContext;
48
49 #define OFFSET(x) offsetof(DrawGraphContext, x)
50 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
51
52 static const AVOption drawgraph_options[] = {
53     { "m1", "set 1st metadata key", OFFSET(key[0]), AV_OPT_TYPE_STRING, {.str=""}, CHAR_MIN, CHAR_MAX, FLAGS },
54     { "fg1", "set 1st foreground color expression", OFFSET(fg_str[0]), AV_OPT_TYPE_STRING, {.str="0xffff0000"}, CHAR_MIN, CHAR_MAX, FLAGS },
55     { "m2", "set 2nd metadata key", OFFSET(key[1]), AV_OPT_TYPE_STRING, {.str=""}, CHAR_MIN, CHAR_MAX, FLAGS },
56     { "fg2", "set 2nd foreground color expression", OFFSET(fg_str[1]), AV_OPT_TYPE_STRING, {.str="0xff00ff00"}, CHAR_MIN, CHAR_MAX, FLAGS },
57     { "m3", "set 3rd metadata key", OFFSET(key[2]), AV_OPT_TYPE_STRING, {.str=""}, CHAR_MIN, CHAR_MAX, FLAGS },
58     { "fg3", "set 3rd foreground color expression", OFFSET(fg_str[2]), AV_OPT_TYPE_STRING, {.str="0xffff00ff"}, CHAR_MIN, CHAR_MAX, FLAGS },
59     { "m4", "set 4th metadata key", OFFSET(key[3]), AV_OPT_TYPE_STRING, {.str=""}, CHAR_MIN, CHAR_MAX, FLAGS },
60     { "fg4", "set 4th foreground color expression", OFFSET(fg_str[3]), AV_OPT_TYPE_STRING, {.str="0xffffff00"}, CHAR_MIN, CHAR_MAX, FLAGS },
61     { "bg", "set background color", OFFSET(bg), AV_OPT_TYPE_COLOR, {.str="white"}, CHAR_MIN, CHAR_MAX, FLAGS },
62     { "min", "set minimal value", OFFSET(min), AV_OPT_TYPE_FLOAT, {.dbl=-1.}, INT_MIN, INT_MAX, FLAGS },
63     { "max", "set maximal value", OFFSET(max), AV_OPT_TYPE_FLOAT, {.dbl=1.}, INT_MIN, INT_MAX, FLAGS },
64     { "mode", "set graph mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=2}, 0, 2, FLAGS, "mode" },
65         {"bar", "draw bars", OFFSET(mode), AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "mode"},
66         {"dot", "draw dots", OFFSET(mode), AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "mode"},
67         {"line", "draw lines", OFFSET(mode), AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "mode"},
68     { "slide", "set slide mode", OFFSET(slide), AV_OPT_TYPE_INT, {.i64=0}, 0, 3, FLAGS, "slide" },
69         {"frame", "draw new frames", OFFSET(slide), AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "slide"},
70         {"replace", "replace old columns with new", OFFSET(slide), AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "slide"},
71         {"scroll", "scroll from right to left", OFFSET(slide), AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "slide"},
72         {"rscroll", "scroll from left to right", OFFSET(slide), AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, FLAGS, "slide"},
73     { "size", "set graph size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str="900x256"}, 0, 0, FLAGS },
74     { "s", "set graph size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str="900x256"}, 0, 0, FLAGS },
75     { NULL }
76 };
77
78 static const char *const var_names[] = {   "MAX",   "MIN",   "VAL", NULL };
79 enum                                   { VAR_MAX, VAR_MIN, VAR_VAL, VAR_VARS_NB };
80
81 static av_cold int init(AVFilterContext *ctx)
82 {
83     DrawGraphContext *s = ctx->priv;
84     int ret, i;
85
86     if (s->max <= s->min) {
87         av_log(ctx, AV_LOG_ERROR, "max is same or lower than min\n");
88         return AVERROR(EINVAL);
89     }
90
91     for (i = 0; i < 4; i++) {
92         if (s->fg_str[i]) {
93             ret = av_expr_parse(&s->fg_expr[i], s->fg_str[i], var_names,
94                                 NULL, NULL, NULL, NULL, 0, ctx);
95
96             if (ret < 0)
97                 return ret;
98         }
99     }
100
101     s->first = 1;
102
103     return 0;
104 }
105
106 static int query_formats(AVFilterContext *ctx)
107 {
108     AVFilterLink *outlink = ctx->outputs[0];
109     static const enum AVPixelFormat pix_fmts[] = {
110         AV_PIX_FMT_RGBA,
111         AV_PIX_FMT_NONE
112     };
113
114     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
115     if (!fmts_list)
116         return AVERROR(ENOMEM);
117     ff_formats_ref(fmts_list, &outlink->in_formats);
118
119     return 0;
120 }
121
122 static void clear_image(DrawGraphContext *s, AVFrame *out, AVFilterLink *outlink)
123 {
124     int i, j;
125     int bg = AV_RN32(s->bg);
126
127     for (i = 0; i < out->height; i++)
128         for (j = 0; j < out->width; j++)
129             AV_WN32(out->data[0] + i * out->linesize[0] + j * 4, bg);
130 }
131
132 static inline void draw_dot(int fg, int x, int y, AVFrame *out)
133 {
134     AV_WN32(out->data[0] + y * out->linesize[0] + x * 4, fg);
135 }
136
137 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
138 {
139     AVFilterContext *ctx = inlink->dst;
140     DrawGraphContext *s = ctx->priv;
141     AVFilterLink *outlink = ctx->outputs[0];
142     AVDictionary *metadata;
143     AVDictionaryEntry *e;
144     AVFrame *out = s->out;
145     int i;
146
147     if (!s->out || s->out->width  != outlink->w ||
148                    s->out->height != outlink->h) {
149         av_frame_free(&s->out);
150         s->out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
151         out = s->out;
152         if (!s->out) {
153             av_frame_free(&in);
154             return AVERROR(ENOMEM);
155         }
156
157         clear_image(s, out, outlink);
158     }
159     av_frame_copy_props(out, in);
160
161     metadata = av_frame_get_metadata(in);
162
163     for (i = 0; i < 4; i++) {
164         double values[VAR_VARS_NB];
165         int j, y, x, old;
166         uint32_t fg, bg;
167         float vf;
168
169         e = av_dict_get(metadata, s->key[i], NULL, 0);
170         if (!e || !e->value)
171             continue;
172
173         if (sscanf(e->value, "%f", &vf) != 1)
174             continue;
175
176         vf = av_clipf(vf, s->min, s->max);
177
178         values[VAR_MIN] = s->min;
179         values[VAR_MAX] = s->max;
180         values[VAR_VAL] = vf;
181
182         fg = av_expr_eval(s->fg_expr[i], values, NULL);
183         bg = AV_RN32(s->bg);
184
185         if (i == 0 && (s->x >= outlink->w || s->slide == 3)) {
186             if (s->slide == 0 || s->slide == 1)
187                 s->x = 0;
188
189             if (s->slide == 2) {
190                 s->x = outlink->w - 1;
191                 for (j = 0; j < outlink->h; j++) {
192                     memmove(out->data[0] + j * out->linesize[0] ,
193                             out->data[0] + j * out->linesize[0] + 4,
194                             (outlink->w - 1) * 4);
195                 }
196             } else if (s->slide == 3) {
197                 s->x = 0;
198                 for (j = 0; j < outlink->h; j++) {
199                     memmove(out->data[0] + j * out->linesize[0] + 4,
200                             out->data[0] + j * out->linesize[0],
201                             (outlink->w - 1) * 4);
202                 }
203             } else if (s->slide == 0) {
204                 clear_image(s, out, outlink);
205             }
206         }
207
208         x = s->x;
209         y = (outlink->h - 1) * (1 - ((vf - s->min) / (s->max - s->min)));
210
211         switch (s->mode) {
212         case 0:
213             if (i == 0 && (s->slide > 0))
214                 for (j = 0; j < outlink->h; j++)
215                     draw_dot(bg, x, j, out);
216
217             old = AV_RN32(out->data[0] + y * out->linesize[0] + x * 4);
218             for (j = y; j < outlink->h; j++) {
219                 if (old != bg &&
220                     (AV_RN32(out->data[0] + j * out->linesize[0] + x * 4) != old) ||
221                     AV_RN32(out->data[0] + FFMIN(j+1, outlink->h - 1) * out->linesize[0] + x * 4) != old) {
222                     draw_dot(fg, x, j, out);
223                     break;
224                 }
225                 draw_dot(fg, x, j, out);
226             }
227             break;
228         case 1:
229             if (i == 0 && (s->slide > 0))
230                 for (j = 0; j < outlink->h; j++)
231                     draw_dot(bg, x, j, out);
232             draw_dot(fg, x, y, out);
233             break;
234         case 2:
235             if (s->first) {
236                 s->first = 0;
237                 s->prev_y[i] = y;
238             }
239
240             if (i == 0 && (s->slide > 0)) {
241                 for (j = 0; j < y; j++)
242                     draw_dot(bg, x, j, out);
243                 for (j = outlink->h - 1; j > y; j--)
244                     draw_dot(bg, x, j, out);
245             }
246             if (y <= s->prev_y[i]) {
247                 for (j = y; j <= s->prev_y[i]; j++)
248                     draw_dot(fg, x, j, out);
249             } else {
250                 for (j = s->prev_y[i]; j <= y; j++)
251                     draw_dot(fg, x, j, out);
252             }
253             s->prev_y[i] = y;
254             break;
255         }
256     }
257
258     s->x++;
259
260     av_frame_free(&in);
261     return ff_filter_frame(outlink, av_frame_clone(s->out));
262 }
263
264 static int config_output(AVFilterLink *outlink)
265 {
266     DrawGraphContext *s = outlink->src->priv;
267
268     outlink->w = s->w;
269     outlink->h = s->h;
270     outlink->sample_aspect_ratio = (AVRational){1,1};
271
272     return 0;
273 }
274
275 static av_cold void uninit(AVFilterContext *ctx)
276 {
277     DrawGraphContext *s = ctx->priv;
278     int i;
279
280     for (i = 0; i < 4; i++)
281         av_expr_free(s->fg_expr[i]);
282     av_frame_free(&s->out);
283 }
284
285 #if CONFIG_DRAWGRAPH_FILTER
286
287 AVFILTER_DEFINE_CLASS(drawgraph);
288
289 static const AVFilterPad drawgraph_inputs[] = {
290     {
291         .name         = "default",
292         .type         = AVMEDIA_TYPE_VIDEO,
293         .filter_frame = filter_frame,
294     },
295     { NULL }
296 };
297
298 static const AVFilterPad drawgraph_outputs[] = {
299     {
300         .name         = "default",
301         .type         = AVMEDIA_TYPE_VIDEO,
302         .config_props = config_output,
303     },
304     { NULL }
305 };
306
307 AVFilter ff_vf_drawgraph = {
308     .name          = "drawgraph",
309     .description   = NULL_IF_CONFIG_SMALL("Draw a graph using input video metadata."),
310     .priv_size     = sizeof(DrawGraphContext),
311     .priv_class    = &drawgraph_class,
312     .query_formats = query_formats,
313     .init          = init,
314     .uninit        = uninit,
315     .inputs        = drawgraph_inputs,
316     .outputs       = drawgraph_outputs,
317 };
318
319 #endif // CONFIG_DRAWGRAPH_FILTER
320
321 #if CONFIG_ADRAWGRAPH_FILTER
322
323 #define adrawgraph_options drawgraph_options
324 AVFILTER_DEFINE_CLASS(adrawgraph);
325
326 static const AVFilterPad adrawgraph_inputs[] = {
327     {
328         .name         = "default",
329         .type         = AVMEDIA_TYPE_AUDIO,
330         .filter_frame = filter_frame,
331     },
332     { NULL }
333 };
334
335 static const AVFilterPad adrawgraph_outputs[] = {
336     {
337         .name         = "default",
338         .type         = AVMEDIA_TYPE_VIDEO,
339         .config_props = config_output,
340     },
341     { NULL }
342 };
343
344 AVFilter ff_avf_adrawgraph = {
345     .name          = "adrawgraph",
346     .description   = NULL_IF_CONFIG_SMALL("Draw a graph using input audio metadata."),
347     .priv_size     = sizeof(DrawGraphContext),
348     .priv_class    = &adrawgraph_class,
349     .query_formats = query_formats,
350     .init          = init,
351     .uninit        = uninit,
352     .inputs        = adrawgraph_inputs,
353     .outputs       = adrawgraph_outputs,
354 };
355 #endif // CONFIG_ADRAWGRAPH_FILTER