summaryrefslogtreecommitdiff
path: root/libavfilter/f_drawgraph.c (plain)
blob: 4c705fe85119614ab4d51500d19066291bfba17b
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
31typedef 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 float *values[4];
48 int values_size[4];
49 int nb_values;
50} DrawGraphContext;
51
52#define OFFSET(x) offsetof(DrawGraphContext, x)
53#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
54
55static const AVOption drawgraph_options[] = {
56 { "m1", "set 1st metadata key", OFFSET(key[0]), AV_OPT_TYPE_STRING, {.str=""}, CHAR_MIN, CHAR_MAX, FLAGS },
57 { "fg1", "set 1st foreground color expression", OFFSET(fg_str[0]), AV_OPT_TYPE_STRING, {.str="0xffff0000"}, CHAR_MIN, CHAR_MAX, FLAGS },
58 { "m2", "set 2nd metadata key", OFFSET(key[1]), AV_OPT_TYPE_STRING, {.str=""}, CHAR_MIN, CHAR_MAX, FLAGS },
59 { "fg2", "set 2nd foreground color expression", OFFSET(fg_str[1]), AV_OPT_TYPE_STRING, {.str="0xff00ff00"}, CHAR_MIN, CHAR_MAX, FLAGS },
60 { "m3", "set 3rd metadata key", OFFSET(key[2]), AV_OPT_TYPE_STRING, {.str=""}, CHAR_MIN, CHAR_MAX, FLAGS },
61 { "fg3", "set 3rd foreground color expression", OFFSET(fg_str[2]), AV_OPT_TYPE_STRING, {.str="0xffff00ff"}, CHAR_MIN, CHAR_MAX, FLAGS },
62 { "m4", "set 4th metadata key", OFFSET(key[3]), AV_OPT_TYPE_STRING, {.str=""}, CHAR_MIN, CHAR_MAX, FLAGS },
63 { "fg4", "set 4th foreground color expression", OFFSET(fg_str[3]), AV_OPT_TYPE_STRING, {.str="0xffffff00"}, CHAR_MIN, CHAR_MAX, FLAGS },
64 { "bg", "set background color", OFFSET(bg), AV_OPT_TYPE_COLOR, {.str="white"}, CHAR_MIN, CHAR_MAX, FLAGS },
65 { "min", "set minimal value", OFFSET(min), AV_OPT_TYPE_FLOAT, {.dbl=-1.}, INT_MIN, INT_MAX, FLAGS },
66 { "max", "set maximal value", OFFSET(max), AV_OPT_TYPE_FLOAT, {.dbl=1.}, INT_MIN, INT_MAX, FLAGS },
67 { "mode", "set graph mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=2}, 0, 2, FLAGS, "mode" },
68 {"bar", "draw bars", OFFSET(mode), AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "mode"},
69 {"dot", "draw dots", OFFSET(mode), AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "mode"},
70 {"line", "draw lines", OFFSET(mode), AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "mode"},
71 { "slide", "set slide mode", OFFSET(slide), AV_OPT_TYPE_INT, {.i64=0}, 0, 4, FLAGS, "slide" },
72 {"frame", "draw new frames", OFFSET(slide), AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "slide"},
73 {"replace", "replace old columns with new", OFFSET(slide), AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "slide"},
74 {"scroll", "scroll from right to left", OFFSET(slide), AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "slide"},
75 {"rscroll", "scroll from left to right", OFFSET(slide), AV_OPT_TYPE_CONST, {.i64=3}, 0, 0, FLAGS, "slide"},
76 {"picture", "display graph in single frame", OFFSET(slide), AV_OPT_TYPE_CONST, {.i64=4}, 0, 0, FLAGS, "slide"},
77 { "size", "set graph size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str="900x256"}, 0, 0, FLAGS },
78 { "s", "set graph size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str="900x256"}, 0, 0, FLAGS },
79 { NULL }
80};
81
82static const char *const var_names[] = { "MAX", "MIN", "VAL", NULL };
83enum { VAR_MAX, VAR_MIN, VAR_VAL, VAR_VARS_NB };
84
85static av_cold int init(AVFilterContext *ctx)
86{
87 DrawGraphContext *s = ctx->priv;
88 int ret, i;
89
90 if (s->max <= s->min) {
91 av_log(ctx, AV_LOG_ERROR, "max is same or lower than min\n");
92 return AVERROR(EINVAL);
93 }
94
95 for (i = 0; i < 4; i++) {
96 if (s->fg_str[i]) {
97 ret = av_expr_parse(&s->fg_expr[i], s->fg_str[i], var_names,
98 NULL, NULL, NULL, NULL, 0, ctx);
99
100 if (ret < 0)
101 return ret;
102 }
103 }
104
105 s->first = 1;
106
107 if (s->slide == 4) {
108 s->values[0] = av_fast_realloc(NULL, &s->values_size[0], 2000);
109 s->values[1] = av_fast_realloc(NULL, &s->values_size[1], 2000);
110 s->values[2] = av_fast_realloc(NULL, &s->values_size[2], 2000);
111 s->values[3] = av_fast_realloc(NULL, &s->values_size[3], 2000);
112
113 if (!s->values[0] || !s->values[1] ||
114 !s->values[2] || !s->values[3]) {
115 return AVERROR(ENOMEM);
116 }
117 }
118
119 return 0;
120}
121
122static int query_formats(AVFilterContext *ctx)
123{
124 AVFilterLink *outlink = ctx->outputs[0];
125 static const enum AVPixelFormat pix_fmts[] = {
126 AV_PIX_FMT_RGBA,
127 AV_PIX_FMT_NONE
128 };
129 int ret;
130
131 AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
132 if ((ret = ff_formats_ref(fmts_list, &outlink->in_formats)) < 0)
133 return ret;
134
135 return 0;
136}
137
138static void clear_image(DrawGraphContext *s, AVFrame *out, AVFilterLink *outlink)
139{
140 int i, j;
141 int bg = AV_RN32(s->bg);
142
143 for (i = 0; i < out->height; i++)
144 for (j = 0; j < out->width; j++)
145 AV_WN32(out->data[0] + i * out->linesize[0] + j * 4, bg);
146}
147
148static inline void draw_dot(int fg, int x, int y, AVFrame *out)
149{
150 AV_WN32(out->data[0] + y * out->linesize[0] + x * 4, fg);
151}
152
153static int filter_frame(AVFilterLink *inlink, AVFrame *in)
154{
155 AVFilterContext *ctx = inlink->dst;
156 DrawGraphContext *s = ctx->priv;
157 AVFilterLink *outlink = ctx->outputs[0];
158 AVDictionary *metadata;
159 AVDictionaryEntry *e;
160 AVFrame *out = s->out;
161 int i;
162
163 if (s->slide == 4 && s->nb_values >= s->values_size[0] / sizeof(float)) {
164 float *ptr;
165
166 ptr = av_fast_realloc(s->values[0], &s->values_size[0], s->values_size[0] * 2);
167 if (!ptr)
168 return AVERROR(ENOMEM);
169 s->values[0] = ptr;
170
171 ptr = av_fast_realloc(s->values[1], &s->values_size[1], s->values_size[1] * 2);
172 if (!ptr)
173 return AVERROR(ENOMEM);
174 s->values[1] = ptr;
175
176 ptr = av_fast_realloc(s->values[2], &s->values_size[2], s->values_size[2] * 2);
177 if (!ptr)
178 return AVERROR(ENOMEM);
179 s->values[2] = ptr;
180
181 ptr = av_fast_realloc(s->values[3], &s->values_size[3], s->values_size[3] * 2);
182 if (!ptr)
183 return AVERROR(ENOMEM);
184 s->values[3] = ptr;
185 }
186
187 if (s->slide != 4 || s->nb_values == 0) {
188 if (!s->out || s->out->width != outlink->w ||
189 s->out->height != outlink->h) {
190 av_frame_free(&s->out);
191 s->out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
192 out = s->out;
193 if (!s->out) {
194 av_frame_free(&in);
195 return AVERROR(ENOMEM);
196 }
197
198 clear_image(s, out, outlink);
199 }
200 av_frame_copy_props(out, in);
201 }
202
203 metadata = av_frame_get_metadata(in);
204
205 for (i = 0; i < 4; i++) {
206 double values[VAR_VARS_NB];
207 int j, y, x, old;
208 uint32_t fg, bg;
209 float vf;
210
211 if (s->slide == 4)
212 s->values[i][s->nb_values] = NAN;
213
214 e = av_dict_get(metadata, s->key[i], NULL, 0);
215 if (!e || !e->value)
216 continue;
217
218 if (sscanf(e->value, "%f", &vf) != 1)
219 continue;
220
221 vf = av_clipf(vf, s->min, s->max);
222
223 if (s->slide == 4) {
224 s->values[i][s->nb_values] = vf;
225 continue;
226 }
227
228 values[VAR_MIN] = s->min;
229 values[VAR_MAX] = s->max;
230 values[VAR_VAL] = vf;
231
232 fg = av_expr_eval(s->fg_expr[i], values, NULL);
233 bg = AV_RN32(s->bg);
234
235 if (i == 0 && (s->x >= outlink->w || s->slide == 3)) {
236 if (s->slide == 0 || s->slide == 1)
237 s->x = 0;
238
239 if (s->slide == 2) {
240 s->x = outlink->w - 1;
241 for (j = 0; j < outlink->h; j++) {
242 memmove(out->data[0] + j * out->linesize[0] ,
243 out->data[0] + j * out->linesize[0] + 4,
244 (outlink->w - 1) * 4);
245 }
246 } else if (s->slide == 3) {
247 s->x = 0;
248 for (j = 0; j < outlink->h; j++) {
249 memmove(out->data[0] + j * out->linesize[0] + 4,
250 out->data[0] + j * out->linesize[0],
251 (outlink->w - 1) * 4);
252 }
253 } else if (s->slide == 0) {
254 clear_image(s, out, outlink);
255 }
256 }
257
258 x = s->x;
259 y = (outlink->h - 1) * (1 - ((vf - s->min) / (s->max - s->min)));
260
261 switch (s->mode) {
262 case 0:
263 if (i == 0 && (s->slide > 0))
264 for (j = 0; j < outlink->h; j++)
265 draw_dot(bg, x, j, out);
266
267 old = AV_RN32(out->data[0] + y * out->linesize[0] + x * 4);
268 for (j = y; j < outlink->h; j++) {
269 if (old != bg &&
270 (AV_RN32(out->data[0] + j * out->linesize[0] + x * 4) != old) ||
271 AV_RN32(out->data[0] + FFMIN(j+1, outlink->h - 1) * out->linesize[0] + x * 4) != old) {
272 draw_dot(fg, x, j, out);
273 break;
274 }
275 draw_dot(fg, x, j, out);
276 }
277 break;
278 case 1:
279 if (i == 0 && (s->slide > 0))
280 for (j = 0; j < outlink->h; j++)
281 draw_dot(bg, x, j, out);
282 draw_dot(fg, x, y, out);
283 break;
284 case 2:
285 if (s->first) {
286 s->first = 0;
287 s->prev_y[i] = y;
288 }
289
290 if (i == 0 && (s->slide > 0)) {
291 for (j = 0; j < y; j++)
292 draw_dot(bg, x, j, out);
293 for (j = outlink->h - 1; j > y; j--)
294 draw_dot(bg, x, j, out);
295 }
296 if (y <= s->prev_y[i]) {
297 for (j = y; j <= s->prev_y[i]; j++)
298 draw_dot(fg, x, j, out);
299 } else {
300 for (j = s->prev_y[i]; j <= y; j++)
301 draw_dot(fg, x, j, out);
302 }
303 s->prev_y[i] = y;
304 break;
305 }
306 }
307
308 s->nb_values++;
309 s->x++;
310
311 av_frame_free(&in);
312
313 if (s->slide == 4)
314 return 0;
315
316 return ff_filter_frame(outlink, av_frame_clone(s->out));
317}
318
319static int request_frame(AVFilterLink *outlink)
320{
321 AVFilterContext *ctx = outlink->src;
322 DrawGraphContext *s = ctx->priv;
323 AVFrame *out = s->out;
324 int ret, i, k, step, l;
325
326 ret = ff_request_frame(ctx->inputs[0]);
327
328 if (s->slide == 4 && ret == AVERROR_EOF && s->nb_values > 0) {
329 s->x = l = 0;
330 step = ceil(s->nb_values / (float)s->w);
331
332 for (k = 0; k < s->nb_values; k++) {
333 for (i = 0; i < 4; i++) {
334 double values[VAR_VARS_NB];
335 int j, y, x, old;
336 uint32_t fg, bg;
337 float vf = s->values[i][k];
338
339 if (isnan(vf))
340 continue;
341
342 values[VAR_MIN] = s->min;
343 values[VAR_MAX] = s->max;
344 values[VAR_VAL] = vf;
345
346 fg = av_expr_eval(s->fg_expr[i], values, NULL);
347 bg = AV_RN32(s->bg);
348
349 x = s->x;
350 y = (outlink->h - 1) * (1 - ((vf - s->min) / (s->max - s->min)));
351
352 switch (s->mode) {
353 case 0:
354 old = AV_RN32(out->data[0] + y * out->linesize[0] + x * 4);
355 for (j = y; j < outlink->h; j++) {
356 if (old != bg &&
357 (AV_RN32(out->data[0] + j * out->linesize[0] + x * 4) != old) ||
358 AV_RN32(out->data[0] + FFMIN(j+1, outlink->h - 1) * out->linesize[0] + x * 4) != old) {
359 draw_dot(fg, x, j, out);
360 break;
361 }
362 draw_dot(fg, x, j, out);
363 }
364 break;
365 case 1:
366 draw_dot(fg, x, y, out);
367 break;
368 case 2:
369 if (s->first) {
370 s->first = 0;
371 s->prev_y[i] = y;
372 }
373
374 if (y <= s->prev_y[i]) {
375 for (j = y; j <= s->prev_y[i]; j++)
376 draw_dot(fg, x, j, out);
377 } else {
378 for (j = s->prev_y[i]; j <= y; j++)
379 draw_dot(fg, x, j, out);
380 }
381 s->prev_y[i] = y;
382 break;
383 }
384 }
385
386 l++;
387 if (l >= step) {
388 l = 0;
389 s->x++;
390 }
391 }
392
393 s->nb_values = 0;
394 out->pts = 0;
395 ret = ff_filter_frame(ctx->outputs[0], s->out);
396 }
397
398 return ret;
399}
400
401static int config_output(AVFilterLink *outlink)
402{
403 DrawGraphContext *s = outlink->src->priv;
404
405 outlink->w = s->w;
406 outlink->h = s->h;
407 outlink->sample_aspect_ratio = (AVRational){1,1};
408
409 return 0;
410}
411
412static av_cold void uninit(AVFilterContext *ctx)
413{
414 DrawGraphContext *s = ctx->priv;
415 int i;
416
417 for (i = 0; i < 4; i++)
418 av_expr_free(s->fg_expr[i]);
419
420 if (s->slide != 4)
421 av_frame_free(&s->out);
422
423 av_freep(&s->values[0]);
424 av_freep(&s->values[1]);
425 av_freep(&s->values[2]);
426 av_freep(&s->values[3]);
427}
428
429#if CONFIG_DRAWGRAPH_FILTER
430
431AVFILTER_DEFINE_CLASS(drawgraph);
432
433static const AVFilterPad drawgraph_inputs[] = {
434 {
435 .name = "default",
436 .type = AVMEDIA_TYPE_VIDEO,
437 .filter_frame = filter_frame,
438 },
439 { NULL }
440};
441
442static const AVFilterPad drawgraph_outputs[] = {
443 {
444 .name = "default",
445 .type = AVMEDIA_TYPE_VIDEO,
446 .config_props = config_output,
447 .request_frame = request_frame,
448 },
449 { NULL }
450};
451
452AVFilter ff_vf_drawgraph = {
453 .name = "drawgraph",
454 .description = NULL_IF_CONFIG_SMALL("Draw a graph using input video metadata."),
455 .priv_size = sizeof(DrawGraphContext),
456 .priv_class = &drawgraph_class,
457 .query_formats = query_formats,
458 .init = init,
459 .uninit = uninit,
460 .inputs = drawgraph_inputs,
461 .outputs = drawgraph_outputs,
462};
463
464#endif // CONFIG_DRAWGRAPH_FILTER
465
466#if CONFIG_ADRAWGRAPH_FILTER
467
468#define adrawgraph_options drawgraph_options
469AVFILTER_DEFINE_CLASS(adrawgraph);
470
471static const AVFilterPad adrawgraph_inputs[] = {
472 {
473 .name = "default",
474 .type = AVMEDIA_TYPE_AUDIO,
475 .filter_frame = filter_frame,
476 },
477 { NULL }
478};
479
480static const AVFilterPad adrawgraph_outputs[] = {
481 {
482 .name = "default",
483 .type = AVMEDIA_TYPE_VIDEO,
484 .config_props = config_output,
485 .request_frame = request_frame,
486 },
487 { NULL }
488};
489
490AVFilter ff_avf_adrawgraph = {
491 .name = "adrawgraph",
492 .description = NULL_IF_CONFIG_SMALL("Draw a graph using input audio metadata."),
493 .priv_size = sizeof(DrawGraphContext),
494 .priv_class = &adrawgraph_class,
495 .query_formats = query_formats,
496 .init = init,
497 .uninit = uninit,
498 .inputs = adrawgraph_inputs,
499 .outputs = adrawgraph_outputs,
500};
501#endif // CONFIG_ADRAWGRAPH_FILTER
502
generated by cgit at 2024-05-17 05:49:46 (GMT)