avfilter/avf_concat: check ff_insert_pad() for failure
[ffmpeg.git] / libavfilter / vf_datascope.c
1 /*
2  * Copyright (c) 2016 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/avassert.h"
22 #include "libavutil/intreadwrite.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/parseutils.h"
25 #include "libavutil/pixdesc.h"
26 #include "libavutil/xga_font_data.h"
27 #include "avfilter.h"
28 #include "drawutils.h"
29 #include "formats.h"
30 #include "internal.h"
31 #include "video.h"
32
33 typedef struct DatascopeContext {
34     const AVClass *class;
35     int ow, oh;
36     int x, y;
37     int mode;
38     int axis;
39     float opacity;
40
41     int nb_planes;
42     int nb_comps;
43     int chars;
44     FFDrawContext draw;
45     FFDrawColor yellow;
46     FFDrawColor white;
47     FFDrawColor black;
48     FFDrawColor gray;
49
50     void (*pick_color)(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value);
51     void (*reverse_color)(FFDrawContext *draw, FFDrawColor *color, FFDrawColor *reverse);
52     int (*filter)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
53 } DatascopeContext;
54
55 #define OFFSET(x) offsetof(DatascopeContext, x)
56 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
57
58 static const AVOption datascope_options[] = {
59     { "size", "set output size", OFFSET(ow),   AV_OPT_TYPE_IMAGE_SIZE, {.str="hd720"}, 0, 0, FLAGS },
60     { "s",    "set output size", OFFSET(ow),   AV_OPT_TYPE_IMAGE_SIZE, {.str="hd720"}, 0, 0, FLAGS },
61     { "x",    "set x offset", OFFSET(x),    AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, FLAGS },
62     { "y",    "set y offset", OFFSET(y),    AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, FLAGS },
63     { "mode", "set scope mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, FLAGS, "mode" },
64     {   "mono",   NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "mode" },
65     {   "color",  NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "mode" },
66     {   "color2", NULL, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, "mode" },
67     { "axis",    "draw column/row numbers", OFFSET(axis), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
68     { "opacity", "set background opacity", OFFSET(opacity), AV_OPT_TYPE_FLOAT, {.dbl=0.75}, 0, 1, FLAGS },
69     { NULL }
70 };
71
72 AVFILTER_DEFINE_CLASS(datascope);
73
74 static int query_formats(AVFilterContext *ctx)
75 {
76     return ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
77 }
78
79 static void draw_text(FFDrawContext *draw, AVFrame *frame, FFDrawColor *color,
80                       int x0, int y0, const uint8_t *text, int vertical)
81 {
82     int x = x0;
83
84     for (; *text; text++) {
85         if (*text == '\n') {
86             x = x0;
87             y0 += 8;
88             continue;
89         }
90         ff_blend_mask(draw, color, frame->data, frame->linesize,
91                       frame->width, frame->height,
92                       avpriv_cga_font + *text * 8, 1, 8, 8, 0, 0, x, y0);
93         if (vertical) {
94             x = x0;
95             y0 += 8;
96         } else {
97             x += 8;
98         }
99     }
100 }
101
102 static void pick_color8(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value)
103 {
104     int p, i;
105
106     color->rgba[3] = 255;
107     for (p = 0; p < draw->nb_planes; p++) {
108         if (draw->nb_planes == 1) {
109             for (i = 0; i < 4; i++) {
110                 value[i] = in->data[0][y * in->linesize[0] + x * draw->pixelstep[0] + i];
111                 color->comp[0].u8[i] = value[i];
112             }
113         } else {
114             value[p] = in->data[p][(y >> draw->vsub[p]) * in->linesize[p] + (x >> draw->hsub[p])];
115             color->comp[p].u8[0] = value[p];
116         }
117     }
118 }
119
120 static void pick_color16(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value)
121 {
122     int p, i;
123
124     color->rgba[3] = 255;
125     for (p = 0; p < draw->nb_planes; p++) {
126         if (draw->nb_planes == 1) {
127             for (i = 0; i < 4; i++) {
128                 value[i] = AV_RL16(in->data[0] + y * in->linesize[0] + x * draw->pixelstep[0] + i * 2);
129                 color->comp[0].u16[i] = value[i];
130             }
131         } else {
132             value[p] = AV_RL16(in->data[p] + (y >> draw->vsub[p]) * in->linesize[p] + (x >> draw->hsub[p]) * 2);
133             color->comp[p].u16[0] = value[p];
134         }
135     }
136 }
137
138 static void reverse_color8(FFDrawContext *draw, FFDrawColor *color, FFDrawColor *reverse)
139 {
140     int p;
141
142     reverse->rgba[3] = 255;
143     for (p = 0; p < draw->nb_planes; p++) {
144         reverse->comp[p].u8[0] = color->comp[p].u8[0] > 127 ? 0 : 255;
145         reverse->comp[p].u8[1] = color->comp[p].u8[1] > 127 ? 0 : 255;
146         reverse->comp[p].u8[2] = color->comp[p].u8[2] > 127 ? 0 : 255;
147     }
148 }
149
150 static void reverse_color16(FFDrawContext *draw, FFDrawColor *color, FFDrawColor *reverse)
151 {
152     int p;
153
154     reverse->rgba[3] = 255;
155     for (p = 0; p < draw->nb_planes; p++) {
156         const unsigned max = (1 << draw->desc->comp[p].depth) - 1;
157         const unsigned mid = (max + 1) / 2;
158
159         reverse->comp[p].u16[0] = color->comp[p].u16[0] > mid ? 0 : max;
160         reverse->comp[p].u16[1] = color->comp[p].u16[1] > mid ? 0 : max;
161         reverse->comp[p].u16[2] = color->comp[p].u16[2] > mid ? 0 : max;
162     }
163 }
164
165 typedef struct ThreadData {
166     AVFrame *in, *out;
167     int xoff, yoff;
168 } ThreadData;
169
170 static int filter_color2(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
171 {
172     DatascopeContext *s = ctx->priv;
173     AVFilterLink *outlink = ctx->outputs[0];
174     AVFilterLink *inlink = ctx->inputs[0];
175     ThreadData *td = arg;
176     AVFrame *in = td->in;
177     AVFrame *out = td->out;
178     const int xoff = td->xoff;
179     const int yoff = td->yoff;
180     const int P = FFMAX(s->nb_planes, s->nb_comps);
181     const int C = s->chars;
182     const int W = (outlink->w - xoff) / (C * 10);
183     const int H = (outlink->h - yoff) / (P * 12);
184     const char *format[2] = {"%02X\n", "%04X\n"};
185     const int slice_start = (W * jobnr) / nb_jobs;
186     const int slice_end = (W * (jobnr+1)) / nb_jobs;
187     int x, y, p;
188
189     for (y = 0; y < H && (y + s->y < inlink->h); y++) {
190         for (x = slice_start; x < slice_end && (x + s->x < inlink->w); x++) {
191             FFDrawColor color = { { 0 } };
192             FFDrawColor reverse = { { 0 } };
193             int value[4] = { 0 };
194
195             s->pick_color(&s->draw, &color, in, x + s->x, y + s->y, value);
196             s->reverse_color(&s->draw, &color, &reverse);
197             ff_fill_rectangle(&s->draw, &color, out->data, out->linesize,
198                               xoff + x * C * 10, yoff + y * P * 12, C * 10, P * 12);
199
200             for (p = 0; p < P; p++) {
201                 char text[256];
202
203                 snprintf(text, sizeof(text), format[C>>2], value[p]);
204                 draw_text(&s->draw, out, &reverse, xoff + x * C * 10 + 2, yoff + y * P * 12 + p * 10 + 2, text, 0);
205             }
206         }
207     }
208
209     return 0;
210 }
211
212 static int filter_color(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
213 {
214     DatascopeContext *s = ctx->priv;
215     AVFilterLink *outlink = ctx->outputs[0];
216     AVFilterLink *inlink = ctx->inputs[0];
217     ThreadData *td = arg;
218     AVFrame *in = td->in;
219     AVFrame *out = td->out;
220     const int xoff = td->xoff;
221     const int yoff = td->yoff;
222     const int P = FFMAX(s->nb_planes, s->nb_comps);
223     const int C = s->chars;
224     const int W = (outlink->w - xoff) / (C * 10);
225     const int H = (outlink->h - yoff) / (P * 12);
226     const char *format[2] = {"%02X\n", "%04X\n"};
227     const int slice_start = (W * jobnr) / nb_jobs;
228     const int slice_end = (W * (jobnr+1)) / nb_jobs;
229     int x, y, p;
230
231     for (y = 0; y < H && (y + s->y < inlink->h); y++) {
232         for (x = slice_start; x < slice_end && (x + s->x < inlink->w); x++) {
233             FFDrawColor color = { { 0 } };
234             int value[4] = { 0 };
235
236             s->pick_color(&s->draw, &color, in, x + s->x, y + s->y, value);
237
238             for (p = 0; p < P; p++) {
239                 char text[256];
240
241                 snprintf(text, sizeof(text), format[C>>2], value[p]);
242                 draw_text(&s->draw, out, &color, xoff + x * C * 10 + 2, yoff + y * P * 12 + p * 10 + 2, text, 0);
243             }
244         }
245     }
246
247     return 0;
248 }
249
250 static int filter_mono(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
251 {
252     DatascopeContext *s = ctx->priv;
253     AVFilterLink *outlink = ctx->outputs[0];
254     AVFilterLink *inlink = ctx->inputs[0];
255     ThreadData *td = arg;
256     AVFrame *in = td->in;
257     AVFrame *out = td->out;
258     const int xoff = td->xoff;
259     const int yoff = td->yoff;
260     const int P = FFMAX(s->nb_planes, s->nb_comps);
261     const int C = s->chars;
262     const int W = (outlink->w - xoff) / (C * 10);
263     const int H = (outlink->h - yoff) / (P * 12);
264     const char *format[2] = {"%02X\n", "%04X\n"};
265     const int slice_start = (W * jobnr) / nb_jobs;
266     const int slice_end = (W * (jobnr+1)) / nb_jobs;
267     int x, y, p;
268
269     for (y = 0; y < H && (y + s->y < inlink->h); y++) {
270         for (x = slice_start; x < slice_end && (x + s->x < inlink->w); x++) {
271             FFDrawColor color = { { 0 } };
272             int value[4] = { 0 };
273
274             s->pick_color(&s->draw, &color, in, x + s->x, y + s->y, value);
275             for (p = 0; p < P; p++) {
276                 char text[256];
277
278                 snprintf(text, sizeof(text), format[C>>2], value[p]);
279                 draw_text(&s->draw, out, &s->white, xoff + x * C * 10 + 2, yoff + y * P * 12 + p * 10 + 2, text, 0);
280             }
281         }
282     }
283
284     return 0;
285 }
286
287 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
288 {
289     AVFilterContext *ctx  = inlink->dst;
290     DatascopeContext *s = ctx->priv;
291     AVFilterLink *outlink = ctx->outputs[0];
292     ThreadData td = { 0 };
293     int ymaxlen = 0;
294     int xmaxlen = 0;
295     AVFrame *out;
296
297     out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
298     if (!out) {
299         av_frame_free(&in);
300         return AVERROR(ENOMEM);
301     }
302     out->pts = in->pts;
303
304     ff_fill_rectangle(&s->draw, &s->black, out->data, out->linesize,
305                       0, 0, outlink->w, outlink->h);
306
307     if (s->axis) {
308         const int P = FFMAX(s->nb_planes, s->nb_comps);
309         const int C = s->chars;
310         int Y = outlink->h / (P * 12);
311         int X = outlink->w / (C * 10);
312         char text[256] = { 0 };
313         int x, y;
314
315         snprintf(text, sizeof(text), "%d", s->y + Y);
316         ymaxlen = strlen(text);
317         ymaxlen *= 10;
318         snprintf(text, sizeof(text), "%d", s->x + X);
319         xmaxlen = strlen(text);
320         xmaxlen *= 10;
321
322         Y = (outlink->h - xmaxlen) / (P * 12);
323         X = (outlink->w - ymaxlen) / (C * 10);
324
325         for (y = 0; y < Y; y++) {
326             snprintf(text, sizeof(text), "%d", s->y + y);
327
328             ff_fill_rectangle(&s->draw, &s->gray, out->data, out->linesize,
329                               0, xmaxlen + y * P * 12 + (P + 1) * P - 2, ymaxlen, 10);
330
331             draw_text(&s->draw, out, &s->yellow, 2, xmaxlen + y * P * 12 + (P + 1) * P, text, 0);
332         }
333
334         for (x = 0; x < X; x++) {
335             snprintf(text, sizeof(text), "%d", s->x + x);
336
337             ff_fill_rectangle(&s->draw, &s->gray, out->data, out->linesize,
338                               ymaxlen + x * C * 10 + 2 * C - 2, 0, 10, xmaxlen);
339
340             draw_text(&s->draw, out, &s->yellow, ymaxlen + x * C * 10 + 2 * C, 2, text, 1);
341         }
342     }
343
344     td.in = in; td.out = out, td.yoff = xmaxlen, td.xoff = ymaxlen;
345     ctx->internal->execute(ctx, s->filter, &td, NULL, FFMIN(ff_filter_get_nb_threads(ctx), FFMAX(outlink->w / 20, 1)));
346
347     av_frame_free(&in);
348     return ff_filter_frame(outlink, out);
349 }
350
351 static int config_input(AVFilterLink *inlink)
352 {
353     DatascopeContext *s = inlink->dst->priv;
354     uint8_t alpha = s->opacity * 255;
355
356     s->nb_planes = av_pix_fmt_count_planes(inlink->format);
357     ff_draw_init(&s->draw, inlink->format, 0);
358     ff_draw_color(&s->draw, &s->white,  (uint8_t[]){ 255, 255, 255, 255} );
359     ff_draw_color(&s->draw, &s->black,  (uint8_t[]){ 0, 0, 0, alpha} );
360     ff_draw_color(&s->draw, &s->yellow, (uint8_t[]){ 255, 255, 0, 255} );
361     ff_draw_color(&s->draw, &s->gray,   (uint8_t[]){ 77, 77, 77, 255} );
362     s->chars = (s->draw.desc->comp[0].depth + 7) / 8 * 2;
363     s->nb_comps = s->draw.desc->nb_components;
364
365     switch (s->mode) {
366     case 0: s->filter = filter_mono;   break;
367     case 1: s->filter = filter_color;  break;
368     case 2: s->filter = filter_color2; break;
369     }
370
371     if (s->draw.desc->comp[0].depth <= 8) {
372         s->pick_color = pick_color8;
373         s->reverse_color = reverse_color8;
374     } else {
375         s->pick_color = pick_color16;
376         s->reverse_color = reverse_color16;
377     }
378
379     return 0;
380 }
381
382 static int config_output(AVFilterLink *outlink)
383 {
384     DatascopeContext *s = outlink->src->priv;
385
386     outlink->h = s->oh;
387     outlink->w = s->ow;
388     outlink->sample_aspect_ratio = (AVRational){1,1};
389
390     return 0;
391 }
392
393 static const AVFilterPad inputs[] = {
394     {
395         .name         = "default",
396         .type         = AVMEDIA_TYPE_VIDEO,
397         .filter_frame = filter_frame,
398         .config_props = config_input,
399     },
400     { NULL }
401 };
402
403 static const AVFilterPad outputs[] = {
404     {
405         .name         = "default",
406         .type         = AVMEDIA_TYPE_VIDEO,
407         .config_props = config_output,
408     },
409     { NULL }
410 };
411
412 AVFilter ff_vf_datascope = {
413     .name          = "datascope",
414     .description   = NULL_IF_CONFIG_SMALL("Video data analysis."),
415     .priv_size     = sizeof(DatascopeContext),
416     .priv_class    = &datascope_class,
417     .query_formats = query_formats,
418     .inputs        = inputs,
419     .outputs       = outputs,
420     .flags         = AVFILTER_FLAG_SLICE_THREADS,
421 };
422
423 typedef struct PixscopeContext {
424     const AVClass *class;
425
426     float xpos, ypos;
427     float wx, wy;
428     int w, h;
429     float o;
430
431     int x, y;
432     int ww, wh;
433
434     int nb_planes;
435     int nb_comps;
436     int is_rgb;
437     uint8_t rgba_map[4];
438     FFDrawContext draw;
439     FFDrawColor   dark;
440     FFDrawColor   black;
441     FFDrawColor   white;
442     FFDrawColor   green;
443     FFDrawColor   blue;
444     FFDrawColor   red;
445     FFDrawColor  *colors[4];
446
447     void (*pick_color)(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value);
448 } PixscopeContext;
449
450 #define POFFSET(x) offsetof(PixscopeContext, x)
451
452 static const AVOption pixscope_options[] = {
453     { "x",  "set scope x offset",  POFFSET(xpos), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0,  1, FLAGS },
454     { "y",  "set scope y offset",  POFFSET(ypos), AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0,  1, FLAGS },
455     { "w",  "set scope width",     POFFSET(w),    AV_OPT_TYPE_INT,   {.i64=7},   1, 80, FLAGS },
456     { "h",  "set scope height",    POFFSET(h),    AV_OPT_TYPE_INT,   {.i64=7},   1, 80, FLAGS },
457     { "o",  "set window opacity",  POFFSET(o),    AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0,  1, FLAGS },
458     { "wx", "set window x offset", POFFSET(wx),   AV_OPT_TYPE_FLOAT, {.dbl=1},   0,  1, FLAGS },
459     { "wy", "set window y offset", POFFSET(wy),   AV_OPT_TYPE_FLOAT, {.dbl=0},   0,  1, FLAGS },
460     { NULL }
461 };
462
463 AVFILTER_DEFINE_CLASS(pixscope);
464
465 static int pixscope_config_input(AVFilterLink *inlink)
466 {
467     PixscopeContext *s = inlink->dst->priv;
468
469     s->nb_planes = av_pix_fmt_count_planes(inlink->format);
470     ff_draw_init(&s->draw, inlink->format, 0);
471     ff_draw_color(&s->draw, &s->dark,  (uint8_t[]){ 0, 0, 0, s->o * 255} );
472     ff_draw_color(&s->draw, &s->black, (uint8_t[]){ 0, 0, 0, 255} );
473     ff_draw_color(&s->draw, &s->white, (uint8_t[]){ 255, 255, 255, 255} );
474     ff_draw_color(&s->draw, &s->green, (uint8_t[]){   0, 255,   0, 255} );
475     ff_draw_color(&s->draw, &s->blue,  (uint8_t[]){   0,   0, 255, 255} );
476     ff_draw_color(&s->draw, &s->red,   (uint8_t[]){ 255,   0,   0, 255} );
477     s->nb_comps = s->draw.desc->nb_components;
478     s->is_rgb   = s->draw.desc->flags & AV_PIX_FMT_FLAG_RGB;
479
480     if (s->is_rgb) {
481         s->colors[0] = &s->red;
482         s->colors[1] = &s->green;
483         s->colors[2] = &s->blue;
484         s->colors[3] = &s->white;
485         ff_fill_rgba_map(s->rgba_map, inlink->format);
486     } else {
487         s->colors[0] = &s->white;
488         s->colors[1] = &s->blue;
489         s->colors[2] = &s->red;
490         s->colors[3] = &s->white;
491         s->rgba_map[0] = 0;
492         s->rgba_map[1] = 1;
493         s->rgba_map[2] = 2;
494         s->rgba_map[3] = 3;
495     }
496
497     if (s->draw.desc->comp[0].depth <= 8) {
498         s->pick_color = pick_color8;
499     } else {
500         s->pick_color = pick_color16;
501     }
502
503     if (inlink->w < 640 || inlink->h < 480) {
504         av_log(inlink->dst, AV_LOG_ERROR, "min supported resolution is 640x480\n");
505         return AVERROR(EINVAL);
506     }
507
508     s->ww = 300;
509     s->wh = 300 * 1.6180;
510     s->x = s->xpos * (inlink->w - 1);
511     s->y = s->ypos * (inlink->h - 1);
512     if (s->x + s->w >= inlink->w || s->y + s->h >= inlink->h) {
513         av_log(inlink->dst, AV_LOG_WARNING, "scope position is out of range, clipping\n");
514         s->x = FFMIN(s->x, inlink->w - s->w);
515         s->y = FFMIN(s->y, inlink->h - s->h);
516     }
517
518     return 0;
519 }
520
521 static int pixscope_filter_frame(AVFilterLink *inlink, AVFrame *in)
522 {
523     AVFilterContext *ctx  = inlink->dst;
524     PixscopeContext *s = ctx->priv;
525     AVFilterLink *outlink = ctx->outputs[0];
526     AVFrame *out = ff_get_video_buffer(outlink, in->width, in->height);
527     int max[4] = { 0 }, min[4] = { INT_MAX, INT_MAX, INT_MAX, INT_MAX };
528     float average[4] = { 0 };
529     double rms[4] = { 0 };
530     const char rgba[4] = { 'R', 'G', 'B', 'A' };
531     const char yuva[4] = { 'Y', 'U', 'V', 'A' };
532     int x, y, X, Y, i, w, h;
533     char text[128];
534
535     if (!out) {
536         av_frame_free(&in);
537         return AVERROR(ENOMEM);
538     }
539     av_frame_copy_props(out, in);
540     av_frame_copy(out, in);
541
542     w = s->ww / s->w;
543     h = s->ww / s->h;
544
545     X = (in->width - s->ww) * s->wx;
546     Y = (in->height - s->wh) * s->wy;
547
548     ff_blend_rectangle(&s->draw, &s->dark, out->data, out->linesize,
549                        out->width, out->height,
550                        X,
551                        Y,
552                        s->ww,
553                        s->wh);
554
555     for (y = 0; y < s->h; y++) {
556         for (x = 0; x < s->w; x++) {
557             FFDrawColor color = { { 0 } };
558             int value[4] = { 0 };
559
560             s->pick_color(&s->draw, &color, in, x + s->x, y + s->y, value);
561             ff_fill_rectangle(&s->draw, &color, out->data, out->linesize,
562                               x * w + (s->ww - 4 - (s->w * w)) / 2 + X, y * h + 2 + Y, w, h);
563             for (i = 0; i < 4; i++) {
564                 rms[i]     += (double)value[i] * (double)value[i];
565                 average[i] += value[i];
566                 min[i]      = FFMIN(min[i], value[i]);
567                 max[i]      = FFMAX(max[i], value[i]);
568             }
569         }
570     }
571
572     ff_blend_rectangle(&s->draw, &s->black, out->data, out->linesize,
573                        out->width, out->height,
574                        s->x - 2, s->y - 2, s->w + 4, 1);
575
576     ff_blend_rectangle(&s->draw, &s->white, out->data, out->linesize,
577                        out->width, out->height,
578                        s->x - 1, s->y - 1, s->w + 2, 1);
579
580     ff_blend_rectangle(&s->draw, &s->white, out->data, out->linesize,
581                        out->width, out->height,
582                        s->x - 1, s->y - 1, 1, s->h + 2);
583
584     ff_blend_rectangle(&s->draw, &s->black, out->data, out->linesize,
585                        out->width, out->height,
586                        s->x - 2, s->y - 2, 1, s->h + 4);
587
588     ff_blend_rectangle(&s->draw, &s->white, out->data, out->linesize,
589                        out->width, out->height,
590                        s->x - 1, s->y + 1 + s->h, s->w + 3, 1);
591
592     ff_blend_rectangle(&s->draw, &s->black, out->data, out->linesize,
593                        out->width, out->height,
594                        s->x - 2, s->y + 2 + s->h, s->w + 4, 1);
595
596     ff_blend_rectangle(&s->draw, &s->white, out->data, out->linesize,
597                        out->width, out->height,
598                        s->x + 1 + s->w, s->y - 1, 1, s->h + 2);
599
600     ff_blend_rectangle(&s->draw, &s->black, out->data, out->linesize,
601                        out->width, out->height,
602                        s->x + 2 + s->w, s->y - 2, 1, s->h + 5);
603
604     for (i = 0; i < 4; i++) {
605         rms[i] /= s->w * s->h;
606         rms[i]  = sqrt(rms[i]);
607         average[i] /= s->w * s->h;
608     }
609
610     snprintf(text, sizeof(text), "CH   AVG    MIN    MAX    RMS\n");
611     draw_text(&s->draw, out, &s->white,        X + 28, Y + s->ww + 20,           text, 0);
612     for (i = 0; i < s->nb_comps; i++) {
613         int c = s->rgba_map[i];
614
615         snprintf(text, sizeof(text), "%c  %07.1f %05d %05d %07.1f\n", s->is_rgb ? rgba[i] : yuva[i], average[c], min[c], max[c], rms[c]);
616         draw_text(&s->draw, out, s->colors[i], X + 28, Y + s->ww + 20 * (i + 2), text, 0);
617     }
618
619     av_frame_free(&in);
620     return ff_filter_frame(outlink, out);
621 }
622
623 static const AVFilterPad pixscope_inputs[] = {
624     {
625         .name           = "default",
626         .type           = AVMEDIA_TYPE_VIDEO,
627         .filter_frame   = pixscope_filter_frame,
628         .config_props   = pixscope_config_input,
629     },
630     { NULL }
631 };
632
633 static const AVFilterPad pixscope_outputs[] = {
634     {
635         .name         = "default",
636         .type         = AVMEDIA_TYPE_VIDEO,
637     },
638     { NULL }
639 };
640
641 AVFilter ff_vf_pixscope = {
642     .name          = "pixscope",
643     .description   = NULL_IF_CONFIG_SMALL("Pixel data analysis."),
644     .priv_size     = sizeof(PixscopeContext),
645     .priv_class    = &pixscope_class,
646     .query_formats = query_formats,
647     .inputs        = pixscope_inputs,
648     .outputs       = pixscope_outputs,
649 };
650
651 typedef struct PixelValues {
652     uint16_t p[4];
653 } PixelValues;
654
655 typedef struct OscilloscopeContext {
656     const AVClass *class;
657
658     float xpos, ypos;
659     float tx, ty;
660     float size;
661     float tilt;
662     float theight, twidth;
663     float o;
664     int components;
665     int grid;
666     int statistics;
667     int scope;
668
669     int x1, y1, x2, y2;
670     int ox, oy;
671     int height, width;
672
673     int max;
674     int nb_planes;
675     int nb_comps;
676     int is_rgb;
677     uint8_t rgba_map[4];
678     FFDrawContext draw;
679     FFDrawColor   dark;
680     FFDrawColor   black;
681     FFDrawColor   white;
682     FFDrawColor   green;
683     FFDrawColor   blue;
684     FFDrawColor   red;
685     FFDrawColor   cyan;
686     FFDrawColor   magenta;
687     FFDrawColor   gray;
688     FFDrawColor  *colors[4];
689
690     int nb_values;
691     PixelValues  *values;
692
693     void (*pick_color)(FFDrawContext *draw, FFDrawColor *color, AVFrame *in, int x, int y, int *value);
694     void (*draw_trace)(struct OscilloscopeContext *s, AVFrame *frame);
695 } OscilloscopeContext;
696
697 #define OOFFSET(x) offsetof(OscilloscopeContext, x)
698
699 static const AVOption oscilloscope_options[] = {
700     { "x",  "set scope x position",    OOFFSET(xpos),       AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1,  FLAGS },
701     { "y",  "set scope y position",    OOFFSET(ypos),       AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1,  FLAGS },
702     { "s",  "set scope size",          OOFFSET(size),       AV_OPT_TYPE_FLOAT, {.dbl=0.8}, 0, 1,  FLAGS },
703     { "t",  "set scope tilt",          OOFFSET(tilt),       AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1,  FLAGS },
704     { "o",  "set trace opacity",       OOFFSET(o),          AV_OPT_TYPE_FLOAT, {.dbl=0.8}, 0, 1,  FLAGS },
705     { "tx", "set trace x position",    OOFFSET(tx),         AV_OPT_TYPE_FLOAT, {.dbl=0.5}, 0, 1,  FLAGS },
706     { "ty", "set trace y position",    OOFFSET(ty),         AV_OPT_TYPE_FLOAT, {.dbl=0.9}, 0, 1,  FLAGS },
707     { "tw", "set trace width",         OOFFSET(twidth),     AV_OPT_TYPE_FLOAT, {.dbl=0.8},.1, 1,  FLAGS },
708     { "th", "set trace height",        OOFFSET(theight),    AV_OPT_TYPE_FLOAT, {.dbl=0.3},.1, 1,  FLAGS },
709     { "c",  "set components to trace", OOFFSET(components), AV_OPT_TYPE_INT,   {.i64=7},   0, 15, FLAGS },
710     { "g",  "draw trace grid",         OOFFSET(grid),       AV_OPT_TYPE_BOOL,  {.i64=1},   0, 1,  FLAGS },
711     { "st", "draw statistics",         OOFFSET(statistics), AV_OPT_TYPE_BOOL,  {.i64=1},   0, 1,  FLAGS },
712     { "sc", "draw scope",              OOFFSET(scope),      AV_OPT_TYPE_BOOL,  {.i64=1},   0, 1,  FLAGS },
713     { NULL }
714 };
715
716 AVFILTER_DEFINE_CLASS(oscilloscope);
717
718 static void oscilloscope_uninit(AVFilterContext *ctx)
719 {
720     OscilloscopeContext *s = ctx->priv;
721
722     av_freep(&s->values);
723 }
724
725 static void draw_line(FFDrawContext *draw, int x0, int y0, int x1, int y1,
726                       AVFrame *out, FFDrawColor *color)
727 {
728     int dx = FFABS(x1 - x0), sx = x0 < x1 ? 1 : -1;
729     int dy = FFABS(y1 - y0), sy = y0 < y1 ? 1 : -1;
730     int err = (dx > dy ? dx : -dy) / 2, e2;
731     int p, i;
732
733     for (;;) {
734         if (x0 >= 0 && y0 >= 0 && x0 < out->width && y0 < out->height) {
735             for (p = 0; p < draw->nb_planes; p++) {
736                 if (draw->desc->comp[p].depth == 8) {
737                     if (draw->nb_planes == 1) {
738                         for (i = 0; i < 4; i++) {
739                             out->data[0][y0 * out->linesize[0] + x0 * draw->pixelstep[0] + i] = color->comp[0].u8[i];
740                         }
741                     } else {
742                         out->data[p][out->linesize[p] * (y0 >> draw->vsub[p]) + (x0 >> draw->hsub[p])] = color->comp[p].u8[0];
743                     }
744                 } else {
745                     if (draw->nb_planes == 1) {
746                         for (i = 0; i < 4; i++) {
747                             AV_WN16(out->data[0] + y0 * out->linesize[0] + 2 * (x0 * draw->pixelstep[0] + i), color->comp[0].u16[i]);
748                         }
749                     } else {
750                         AV_WN16(out->data[p] + out->linesize[p] * (y0 >> draw->vsub[p]) + (x0 >> draw->hsub[p]) * 2, color->comp[p].u16[0]);
751                     }
752                 }
753             }
754         }
755
756         if (x0 == x1 && y0 == y1)
757             break;
758
759         e2 = err;
760
761         if (e2 >-dx) {
762             err -= dy;
763             x0 += sx;
764         }
765
766         if (e2 < dy) {
767             err += dx;
768             y0 += sy;
769         }
770     }
771 }
772
773 static void draw_trace8(OscilloscopeContext *s, AVFrame *frame)
774 {
775     int i, c;
776
777     for (i = 1; i < s->nb_values; i++) {
778         for (c = 0; c < s->nb_comps; c++) {
779             if ((1 << c) & s->components) {
780                 int x = i * s->width / s->nb_values;
781                 int px = (i - 1) * s->width / s->nb_values;
782                 int py = s->height - s->values[i-1].p[c] * s->height / 256;
783                 int y = s->height - s->values[i].p[c] * s->height / 256;
784
785                 draw_line(&s->draw, s->ox + x, s->oy + y, s->ox + px, s->oy + py, frame, s->colors[c]);
786             }
787         }
788     }
789 }
790
791
792 static void draw_trace16(OscilloscopeContext *s, AVFrame *frame)
793 {
794     int i, c;
795
796     for (i = 1; i < s->nb_values; i++) {
797         for (c = 0; c < s->nb_comps; c++) {
798             if ((1 << c) & s->components) {
799                 int x = i * s->width / s->nb_values;
800                 int px = (i - 1) * s->width / s->nb_values;
801                 int py = s->height - s->values[i-1].p[c] * s->height / s->max;
802                 int y = s->height - s->values[i].p[c] * s->height / s->max;
803
804                 draw_line(&s->draw, s->ox + x, s->oy + y, s->ox + px, s->oy + py, frame, s->colors[c]);
805             }
806         }
807     }
808 }
809
810 static int oscilloscope_config_input(AVFilterLink *inlink)
811 {
812     OscilloscopeContext *s = inlink->dst->priv;
813     int cx, cy, size;
814     double tilt;
815
816     s->nb_planes = av_pix_fmt_count_planes(inlink->format);
817     ff_draw_init(&s->draw, inlink->format, 0);
818     ff_draw_color(&s->draw, &s->dark,    (uint8_t[]){   0,   0,   0, s->o * 255} );
819     ff_draw_color(&s->draw, &s->black,   (uint8_t[]){   0,   0,   0, 255} );
820     ff_draw_color(&s->draw, &s->white,   (uint8_t[]){ 255, 255, 255, 255} );
821     ff_draw_color(&s->draw, &s->green,   (uint8_t[]){   0, 255,   0, 255} );
822     ff_draw_color(&s->draw, &s->blue,    (uint8_t[]){   0,   0, 255, 255} );
823     ff_draw_color(&s->draw, &s->red,     (uint8_t[]){ 255,   0,   0, 255} );
824     ff_draw_color(&s->draw, &s->cyan,    (uint8_t[]){   0, 255, 255, 255} );
825     ff_draw_color(&s->draw, &s->magenta, (uint8_t[]){ 255,   0, 255, 255} );
826     ff_draw_color(&s->draw, &s->gray,    (uint8_t[]){ 128, 128, 128, 255} );
827     s->nb_comps = s->draw.desc->nb_components;
828     s->is_rgb   = s->draw.desc->flags & AV_PIX_FMT_FLAG_RGB;
829
830     if (s->is_rgb) {
831         s->colors[0] = &s->red;
832         s->colors[1] = &s->green;
833         s->colors[2] = &s->blue;
834         s->colors[3] = &s->white;
835         ff_fill_rgba_map(s->rgba_map, inlink->format);
836     } else {
837         s->colors[0] = &s->white;
838         s->colors[1] = &s->cyan;
839         s->colors[2] = &s->magenta;
840         s->colors[3] = &s->white;
841         s->rgba_map[0] = 0;
842         s->rgba_map[1] = 1;
843         s->rgba_map[2] = 2;
844         s->rgba_map[3] = 3;
845     }
846
847     if (s->draw.desc->comp[0].depth <= 8) {
848         s->pick_color = pick_color8;
849         s->draw_trace = draw_trace8;
850     } else {
851         s->pick_color = pick_color16;
852         s->draw_trace = draw_trace16;
853     }
854
855     s->max = (1 << s->draw.desc->comp[0].depth);
856     cx = s->xpos * (inlink->w - 1);
857     cy = s->ypos * (inlink->h - 1);
858     s->height = s->theight * inlink->h;
859     s->width = s->twidth * inlink->w;
860     size = hypot(inlink->w, inlink->h);
861
862     s->values = av_calloc(size, sizeof(*s->values));
863     if (!s->values)
864         return AVERROR(ENOMEM);
865
866     size *= s->size;
867     tilt  = (s->tilt - 0.5) * M_PI;
868     s->x1 = cx - size / 2.0 * cos(tilt);
869     s->x2 = cx + size / 2.0 * cos(tilt);
870     s->y1 = cy - size / 2.0 * sin(tilt);
871     s->y2 = cy + size / 2.0 * sin(tilt);
872     s->ox = (inlink->w - s->width) * s->tx;
873     s->oy = (inlink->h - s->height) * s->ty;
874
875     return 0;
876 }
877
878 static void draw_scope(OscilloscopeContext *s, int x0, int y0, int x1, int y1,
879                        AVFrame *out, PixelValues *p, int state)
880 {
881     int dx = FFABS(x1 - x0), sx = x0 < x1 ? 1 : -1;
882     int dy = FFABS(y1 - y0), sy = y0 < y1 ? 1 : -1;
883     int err = (dx > dy ? dx : -dy) / 2, e2;
884
885     for (;;) {
886         if (x0 >= 0 && y0 >= 0 && x0 < out->width && y0 < out->height) {
887             FFDrawColor color = { { 0 } };
888             int value[4] = { 0 };
889
890             s->pick_color(&s->draw, &color, out, x0, y0, value);
891             s->values[s->nb_values].p[0] = value[0];
892             s->values[s->nb_values].p[1] = value[1];
893             s->values[s->nb_values].p[2] = value[2];
894             s->values[s->nb_values].p[3] = value[3];
895             s->nb_values++;
896
897             if (s->scope) {
898                 if (s->draw.desc->comp[0].depth == 8) {
899                     if (s->draw.nb_planes == 1) {
900                         int i;
901
902                         for (i = 0; i < s->draw.pixelstep[0]; i++)
903                             out->data[0][out->linesize[0] * y0 + x0 * s->draw.pixelstep[0] + i] = 255 * ((s->nb_values + state) & 1);
904                     } else {
905                         out->data[0][out->linesize[0] * y0 + x0] = 255 * ((s->nb_values + state) & 1);
906                     }
907                 } else {
908                     if (s->draw.nb_planes == 1) {
909                         int i;
910
911                         for (i = 0; i < s->draw.pixelstep[0]; i++)
912                             AV_WN16(out->data[0] + out->linesize[0] * y0 + 2 * x0 * (s->draw.pixelstep[0] + i), (s->max - 1) * ((s->nb_values + state) & 1));
913                     } else {
914                         AV_WN16(out->data[0] + out->linesize[0] * y0 + 2 * x0, (s->max - 1) * ((s->nb_values + state) & 1));
915                     }
916                 }
917             }
918         }
919
920         if (x0 == x1 && y0 == y1)
921             break;
922
923         e2 = err;
924
925         if (e2 >-dx) {
926             err -= dy;
927             x0 += sx;
928         }
929
930         if (e2 < dy) {
931             err += dx;
932             y0 += sy;
933         }
934     }
935 }
936
937 static int oscilloscope_filter_frame(AVFilterLink *inlink, AVFrame *frame)
938 {
939     AVFilterContext *ctx  = inlink->dst;
940     OscilloscopeContext *s = ctx->priv;
941     AVFilterLink *outlink = ctx->outputs[0];
942     float average[4] = { 0 };
943     int max[4] = { 0 };
944     int min[4] = { INT_MAX, INT_MAX, INT_MAX, INT_MAX };
945     int i, c;
946
947     s->nb_values = 0;
948     draw_scope(s, s->x1, s->y1, s->x2, s->y2, frame, s->values, inlink->frame_count_in & 1);
949     ff_blend_rectangle(&s->draw, &s->dark, frame->data, frame->linesize,
950                        frame->width, frame->height,
951                        s->ox, s->oy, s->width, s->height + 20 * s->statistics);
952
953     if (s->grid) {
954         ff_fill_rectangle(&s->draw, &s->gray, frame->data, frame->linesize,
955                           s->ox, s->oy, s->width - 1, 1);
956
957         for (i = 1; i < 5; i++) {
958             ff_fill_rectangle(&s->draw, &s->gray, frame->data, frame->linesize,
959                               s->ox, s->oy + i * (s->height - 1) / 4, s->width, 1);
960         }
961
962         for (i = 0; i < 10; i++) {
963             ff_fill_rectangle(&s->draw, &s->gray, frame->data, frame->linesize,
964                               s->ox + i * (s->width - 1) / 10, s->oy, 1, s->height);
965         }
966
967         ff_fill_rectangle(&s->draw, &s->gray, frame->data, frame->linesize,
968                           s->ox + s->width - 1, s->oy, 1, s->height);
969     }
970
971     s->draw_trace(s, frame);
972
973     for (i = 0; i < s->nb_values; i++) {
974         for (c = 0; c < s->nb_comps; c++) {
975             if ((1 << c) & s->components) {
976                 max[c] = FFMAX(max[c], s->values[i].p[c]);
977                 min[c] = FFMIN(min[c], s->values[i].p[c]);
978                 average[c] += s->values[i].p[c];
979             }
980         }
981     }
982     for (c = 0; c < s->nb_comps; c++) {
983         average[c] /= s->nb_values;
984     }
985
986     if (s->statistics && s->height > 10 && s->width > 280 * av_popcount(s->components)) {
987         for (c = 0, i = 0; c < s->nb_comps; c++) {
988             if ((1 << c) & s->components) {
989                 const char rgba[4] = { 'R', 'G', 'B', 'A' };
990                 const char yuva[4] = { 'Y', 'U', 'V', 'A' };
991                 char text[128];
992
993                 snprintf(text, sizeof(text), "%c avg:%.1f min:%d max:%d\n", s->is_rgb ? rgba[c] : yuva[c], average[s->rgba_map[c]], min[s->rgba_map[c]], max[s->rgba_map[c]]);
994                 draw_text(&s->draw, frame, &s->white, s->ox +  2 + 280 * i++, s->oy + s->height + 4, text, 0);
995             }
996         }
997     }
998
999     return ff_filter_frame(outlink, frame);
1000 }
1001
1002 static const AVFilterPad oscilloscope_inputs[] = {
1003     {
1004         .name           = "default",
1005         .type           = AVMEDIA_TYPE_VIDEO,
1006         .filter_frame   = oscilloscope_filter_frame,
1007         .config_props   = oscilloscope_config_input,
1008         .needs_writable = 1,
1009     },
1010     { NULL }
1011 };
1012
1013 static const AVFilterPad oscilloscope_outputs[] = {
1014     {
1015         .name         = "default",
1016         .type         = AVMEDIA_TYPE_VIDEO,
1017     },
1018     { NULL }
1019 };
1020
1021 AVFilter ff_vf_oscilloscope = {
1022     .name          = "oscilloscope",
1023     .description   = NULL_IF_CONFIG_SMALL("2D Video Oscilloscope."),
1024     .priv_size     = sizeof(OscilloscopeContext),
1025     .priv_class    = &oscilloscope_class,
1026     .query_formats = query_formats,
1027     .uninit        = oscilloscope_uninit,
1028     .inputs        = oscilloscope_inputs,
1029     .outputs       = oscilloscope_outputs,
1030 };