git.sesse.net Git - ffmpeg/blob - 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 };