lavfi/dynaudnorm: rename pow2 to pow_2
[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(DatascopeContext *s, 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(&s->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, 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, 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, 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, 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, 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 };