git.sesse.net Git - ffmpeg/blob - libavfilter/vsrc_testsrc.c

   1 /*
   2  * Copyright (c) 2007 Nicolas George <nicolas.george@normalesup.org>
   3  * Copyright (c) 2011 Stefano Sabatini
   4  * Copyright (c) 2012 Paul B Mahol
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /**
  24  * @file
  25  * Misc test sources.
  26  *
  27  * testsrc is based on the test pattern generator demuxer by Nicolas George:
  28  * http://lists.ffmpeg.org/pipermail/ffmpeg-devel/2007-October/037845.html
  29  *
  30  * rgbtestsrc is ported from MPlayer libmpcodecs/vf_rgbtest.c by
  31  * Michael Niedermayer.
  32  *
  33  * allyuv, smptebars and smptehdbars are by Paul B Mahol.
  34  */
  35
  36 #include <float.h>
  37
  38 #include "libavutil/avassert.h"
  39 #include "libavutil/common.h"
  40 #include "libavutil/ffmath.h"
  41 #include "libavutil/opt.h"
  42 #include "libavutil/imgutils.h"
  43 #include "libavutil/intreadwrite.h"
  44 #include "libavutil/parseutils.h"
  45 #include "libavutil/xga_font_data.h"
  46 #include "avfilter.h"
  47 #include "drawutils.h"
  48 #include "formats.h"
  49 #include "internal.h"
  50 #include "video.h"
  51
  52 typedef struct TestSourceContext {
  53     const AVClass *class;
  54     int w, h;
  55     unsigned int nb_frame;
  56     AVRational time_base, frame_rate;
  57     int64_t pts;
  58     int64_t duration;           ///< duration expressed in microseconds
  59     AVRational sar;             ///< sample aspect ratio
  60     int draw_once;              ///< draw only the first frame, always put out the same picture
  61     int draw_once_reset;        ///< draw only the first frame or in case of reset
  62     AVFrame *picref;            ///< cached reference containing the painted picture
  63
  64     void (* fill_picture_fn)(AVFilterContext *ctx, AVFrame *frame);
  65
  66     /* only used by testsrc */
  67     int nb_decimals;
  68
  69     /* only used by color */
  70     FFDrawContext draw;
  71     FFDrawColor color;
  72     uint8_t color_rgba[4];
  73
  74     /* only used by rgbtest */
  75     uint8_t rgba_map[4];
  76
  77     /* only used by haldclut */
  78     int level;
  79 } TestSourceContext;
  80
  81 #define OFFSET(x) offsetof(TestSourceContext, x)
  82 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
  83
  84 #define SIZE_OPTIONS \
  85     { "size",     "set video size",     OFFSET(w),        AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },\
  86     { "s",        "set video size",     OFFSET(w),        AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },\
  87
  88 #define COMMON_OPTIONS_NOSIZE \
  89     { "rate",     "set video rate",     OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },\
  90     { "r",        "set video rate",     OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },\
  91     { "duration", "set video duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },\
  92     { "d",        "set video duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },\
  93     { "sar",      "set video sample aspect ratio", OFFSET(sar), AV_OPT_TYPE_RATIONAL, {.dbl= 1},  0, INT_MAX, FLAGS },
  94
  95 #define COMMON_OPTIONS SIZE_OPTIONS COMMON_OPTIONS_NOSIZE
  96
  97 static const AVOption options[] = {
  98     COMMON_OPTIONS
  99     { NULL }
 100 };
 101
 102 static av_cold int init(AVFilterContext *ctx)
 103 {
 104     TestSourceContext *test = ctx->priv;
 105
 106     test->time_base = av_inv_q(test->frame_rate);
 107     test->nb_frame = 0;
 108     test->pts = 0;
 109
 110     av_log(ctx, AV_LOG_VERBOSE, "size:%dx%d rate:%d/%d duration:%f sar:%d/%d\n",
 111            test->w, test->h, test->frame_rate.num, test->frame_rate.den,
 112            test->duration < 0 ? -1 : (double)test->duration/1000000,
 113            test->sar.num, test->sar.den);
 114     return 0;
 115 }
 116
 117 static av_cold void uninit(AVFilterContext *ctx)
 118 {
 119     TestSourceContext *test = ctx->priv;
 120
 121     av_frame_free(&test->picref);
 122 }
 123
 124 static int config_props(AVFilterLink *outlink)
 125 {
 126     TestSourceContext *test = outlink->src->priv;
 127
 128     outlink->w = test->w;
 129     outlink->h = test->h;
 130     outlink->sample_aspect_ratio = test->sar;
 131     outlink->frame_rate = test->frame_rate;
 132     outlink->time_base  = test->time_base;
 133
 134     return 0;
 135 }
 136
 137 static int request_frame(AVFilterLink *outlink)
 138 {
 139     TestSourceContext *test = outlink->src->priv;
 140     AVFrame *frame;
 141
 142     if (test->duration >= 0 &&
 143         av_rescale_q(test->pts, test->time_base, AV_TIME_BASE_Q) >= test->duration)
 144         return AVERROR_EOF;
 145
 146     if (test->draw_once) {
 147         if (test->draw_once_reset) {
 148             av_frame_free(&test->picref);
 149             test->draw_once_reset = 0;
 150         }
 151         if (!test->picref) {
 152             test->picref =
 153                 ff_get_video_buffer(outlink, test->w, test->h);
 154             if (!test->picref)
 155                 return AVERROR(ENOMEM);
 156             test->fill_picture_fn(outlink->src, test->picref);
 157         }
 158         frame = av_frame_clone(test->picref);
 159     } else
 160         frame = ff_get_video_buffer(outlink, test->w, test->h);
 161
 162     if (!frame)
 163         return AVERROR(ENOMEM);
 164     frame->pts                 = test->pts;
 165     frame->key_frame           = 1;
 166     frame->interlaced_frame    = 0;
 167     frame->pict_type           = AV_PICTURE_TYPE_I;
 168     frame->sample_aspect_ratio = test->sar;
 169     if (!test->draw_once)
 170         test->fill_picture_fn(outlink->src, frame);
 171
 172     test->pts++;
 173     test->nb_frame++;
 174
 175     return ff_filter_frame(outlink, frame);
 176 }
 177
 178 #if CONFIG_COLOR_FILTER
 179
 180 static const AVOption color_options[] = {
 181     { "color", "set color", OFFSET(color_rgba), AV_OPT_TYPE_COLOR, {.str = "black"}, CHAR_MIN, CHAR_MAX, FLAGS },
 182     { "c",     "set color", OFFSET(color_rgba), AV_OPT_TYPE_COLOR, {.str = "black"}, CHAR_MIN, CHAR_MAX, FLAGS },
 183     COMMON_OPTIONS
 184     { NULL }
 185 };
 186
 187 AVFILTER_DEFINE_CLASS(color);
 188
 189 static void color_fill_picture(AVFilterContext *ctx, AVFrame *picref)
 190 {
 191     TestSourceContext *test = ctx->priv;
 192     ff_fill_rectangle(&test->draw, &test->color,
 193                       picref->data, picref->linesize,
 194                       0, 0, test->w, test->h);
 195 }
 196
 197 static av_cold int color_init(AVFilterContext *ctx)
 198 {
 199     TestSourceContext *test = ctx->priv;
 200     test->fill_picture_fn = color_fill_picture;
 201     test->draw_once = 1;
 202     return init(ctx);
 203 }
 204
 205 static int color_query_formats(AVFilterContext *ctx)
 206 {
 207     return ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
 208 }
 209
 210 static int color_config_props(AVFilterLink *inlink)
 211 {
 212     AVFilterContext *ctx = inlink->src;
 213     TestSourceContext *test = ctx->priv;
 214     int ret;
 215
 216     ff_draw_init(&test->draw, inlink->format, 0);
 217     ff_draw_color(&test->draw, &test->color, test->color_rgba);
 218
 219     test->w = ff_draw_round_to_sub(&test->draw, 0, -1, test->w);
 220     test->h = ff_draw_round_to_sub(&test->draw, 1, -1, test->h);
 221     if (av_image_check_size(test->w, test->h, 0, ctx) < 0)
 222         return AVERROR(EINVAL);
 223
 224     if ((ret = config_props(inlink)) < 0)
 225         return ret;
 226
 227     return 0;
 228 }
 229
 230 static int color_process_command(AVFilterContext *ctx, const char *cmd, const char *args,
 231                                  char *res, int res_len, int flags)
 232 {
 233     TestSourceContext *test = ctx->priv;
 234     int ret;
 235
 236     if (!strcmp(cmd, "color") || !strcmp(cmd, "c")) {
 237         uint8_t color_rgba[4];
 238
 239         ret = av_parse_color(color_rgba, args, -1, ctx);
 240         if (ret < 0)
 241             return ret;
 242
 243         memcpy(test->color_rgba, color_rgba, sizeof(color_rgba));
 244         ff_draw_color(&test->draw, &test->color, test->color_rgba);
 245         test->draw_once_reset = 1;
 246         return 0;
 247     }
 248
 249     return AVERROR(ENOSYS);
 250 }
 251
 252 static const AVFilterPad color_outputs[] = {
 253     {
 254         .name          = "default",
 255         .type          = AVMEDIA_TYPE_VIDEO,
 256         .request_frame = request_frame,
 257         .config_props  = color_config_props,
 258     },
 259     {  NULL }
 260 };
 261
 262 AVFilter ff_vsrc_color = {
 263     .name            = "color",
 264     .description     = NULL_IF_CONFIG_SMALL("Provide an uniformly colored input."),
 265     .priv_class      = &color_class,
 266     .priv_size       = sizeof(TestSourceContext),
 267     .init            = color_init,
 268     .uninit          = uninit,
 269     .query_formats   = color_query_formats,
 270     .inputs          = NULL,
 271     .outputs         = color_outputs,
 272     .process_command = color_process_command,
 273 };
 274
 275 #endif /* CONFIG_COLOR_FILTER */
 276
 277 #if CONFIG_HALDCLUTSRC_FILTER
 278
 279 static const AVOption haldclutsrc_options[] = {
 280     { "level", "set level", OFFSET(level), AV_OPT_TYPE_INT, {.i64 = 6}, 2, 8, FLAGS },
 281     COMMON_OPTIONS_NOSIZE
 282     { NULL }
 283 };
 284
 285 AVFILTER_DEFINE_CLASS(haldclutsrc);
 286
 287 static void haldclutsrc_fill_picture(AVFilterContext *ctx, AVFrame *frame)
 288 {
 289     int i, j, k, x = 0, y = 0, is16bit = 0, step;
 290     uint32_t alpha = 0;
 291     const TestSourceContext *hc = ctx->priv;
 292     int level = hc->level;
 293     float scale;
 294     const int w = frame->width;
 295     const int h = frame->height;
 296     const uint8_t *data = frame->data[0];
 297     const int linesize  = frame->linesize[0];
 298     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
 299     uint8_t rgba_map[4];
 300
 301     av_assert0(w == h && w == level*level*level);
 302
 303     ff_fill_rgba_map(rgba_map, frame->format);
 304
 305     switch (frame->format) {
 306     case AV_PIX_FMT_RGB48:
 307     case AV_PIX_FMT_BGR48:
 308     case AV_PIX_FMT_RGBA64:
 309     case AV_PIX_FMT_BGRA64:
 310         is16bit = 1;
 311         alpha = 0xffff;
 312         break;
 313     case AV_PIX_FMT_RGBA:
 314     case AV_PIX_FMT_BGRA:
 315     case AV_PIX_FMT_ARGB:
 316     case AV_PIX_FMT_ABGR:
 317         alpha = 0xff;
 318         break;
 319     }
 320
 321     step  = av_get_padded_bits_per_pixel(desc) >> (3 + is16bit);
 322     scale = ((float)(1 << (8*(is16bit+1))) - 1) / (level*level - 1);
 323
 324 #define LOAD_CLUT(nbits) do {                                                   \
 325     uint##nbits##_t *dst = ((uint##nbits##_t *)(data + y*linesize)) + x*step;   \
 326     dst[rgba_map[0]] = av_clip_uint##nbits(i * scale);                          \
 327     dst[rgba_map[1]] = av_clip_uint##nbits(j * scale);                          \
 328     dst[rgba_map[2]] = av_clip_uint##nbits(k * scale);                          \
 329     if (step == 4)                                                              \
 330         dst[rgba_map[3]] = alpha;                                               \
 331 } while (0)
 332
 333     level *= level;
 334     for (k = 0; k < level; k++) {
 335         for (j = 0; j < level; j++) {
 336             for (i = 0; i < level; i++) {
 337                 if (!is16bit)
 338                     LOAD_CLUT(8);
 339                 else
 340                     LOAD_CLUT(16);
 341                 if (++x == w) {
 342                     x = 0;
 343                     y++;
 344                 }
 345             }
 346         }
 347     }
 348 }
 349
 350 static av_cold int haldclutsrc_init(AVFilterContext *ctx)
 351 {
 352     TestSourceContext *hc = ctx->priv;
 353     hc->fill_picture_fn = haldclutsrc_fill_picture;
 354     hc->draw_once = 1;
 355     return init(ctx);
 356 }
 357
 358 static int haldclutsrc_query_formats(AVFilterContext *ctx)
 359 {
 360     static const enum AVPixelFormat pix_fmts[] = {
 361         AV_PIX_FMT_RGB24,  AV_PIX_FMT_BGR24,
 362         AV_PIX_FMT_RGBA,   AV_PIX_FMT_BGRA,
 363         AV_PIX_FMT_ARGB,   AV_PIX_FMT_ABGR,
 364         AV_PIX_FMT_0RGB,   AV_PIX_FMT_0BGR,
 365         AV_PIX_FMT_RGB0,   AV_PIX_FMT_BGR0,
 366         AV_PIX_FMT_RGB48,  AV_PIX_FMT_BGR48,
 367         AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,
 368         AV_PIX_FMT_NONE,
 369     };
 370
 371     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
 372     if (!fmts_list)
 373         return AVERROR(ENOMEM);
 374     return ff_set_common_formats(ctx, fmts_list);
 375 }
 376
 377 static int haldclutsrc_config_props(AVFilterLink *outlink)
 378 {
 379     AVFilterContext *ctx = outlink->src;
 380     TestSourceContext *hc = ctx->priv;
 381
 382     hc->w = hc->h = hc->level * hc->level * hc->level;
 383     return config_props(outlink);
 384 }
 385
 386 static const AVFilterPad haldclutsrc_outputs[] = {
 387     {
 388         .name          = "default",
 389         .type          = AVMEDIA_TYPE_VIDEO,
 390         .request_frame = request_frame,
 391         .config_props  = haldclutsrc_config_props,
 392     },
 393     {  NULL }
 394 };
 395
 396 AVFilter ff_vsrc_haldclutsrc = {
 397     .name          = "haldclutsrc",
 398     .description   = NULL_IF_CONFIG_SMALL("Provide an identity Hald CLUT."),
 399     .priv_class    = &haldclutsrc_class,
 400     .priv_size     = sizeof(TestSourceContext),
 401     .init          = haldclutsrc_init,
 402     .uninit        = uninit,
 403     .query_formats = haldclutsrc_query_formats,
 404     .inputs        = NULL,
 405     .outputs       = haldclutsrc_outputs,
 406 };
 407 #endif /* CONFIG_HALDCLUTSRC_FILTER */
 408
 409 #if CONFIG_NULLSRC_FILTER
 410
 411 #define nullsrc_options options
 412 AVFILTER_DEFINE_CLASS(nullsrc);
 413
 414 static void nullsrc_fill_picture(AVFilterContext *ctx, AVFrame *picref) { }
 415
 416 static av_cold int nullsrc_init(AVFilterContext *ctx)
 417 {
 418     TestSourceContext *test = ctx->priv;
 419
 420     test->fill_picture_fn = nullsrc_fill_picture;
 421     return init(ctx);
 422 }
 423
 424 static const AVFilterPad nullsrc_outputs[] = {
 425     {
 426         .name          = "default",
 427         .type          = AVMEDIA_TYPE_VIDEO,
 428         .request_frame = request_frame,
 429         .config_props  = config_props,
 430     },
 431     { NULL },
 432 };
 433
 434 AVFilter ff_vsrc_nullsrc = {
 435     .name        = "nullsrc",
 436     .description = NULL_IF_CONFIG_SMALL("Null video source, return unprocessed video frames."),
 437     .init        = nullsrc_init,
 438     .uninit      = uninit,
 439     .priv_size   = sizeof(TestSourceContext),
 440     .priv_class  = &nullsrc_class,
 441     .inputs      = NULL,
 442     .outputs     = nullsrc_outputs,
 443 };
 444
 445 #endif /* CONFIG_NULLSRC_FILTER */
 446
 447 #if CONFIG_TESTSRC_FILTER
 448
 449 static const AVOption testsrc_options[] = {
 450     COMMON_OPTIONS
 451     { "decimals", "set number of decimals to show", OFFSET(nb_decimals), AV_OPT_TYPE_INT, {.i64=0},  0, 17, FLAGS },
 452     { "n",        "set number of decimals to show", OFFSET(nb_decimals), AV_OPT_TYPE_INT, {.i64=0},  0, 17, FLAGS },
 453     { NULL }
 454 };
 455
 456 AVFILTER_DEFINE_CLASS(testsrc);
 457
 458 /**
 459  * Fill a rectangle with value val.
 460  *
 461  * @param val the RGB value to set
 462  * @param dst pointer to the destination buffer to fill
 463  * @param dst_linesize linesize of destination
 464  * @param segment_width width of the segment
 465  * @param x horizontal coordinate where to draw the rectangle in the destination buffer
 466  * @param y horizontal coordinate where to draw the rectangle in the destination buffer
 467  * @param w width  of the rectangle to draw, expressed as a number of segment_width units
 468  * @param h height of the rectangle to draw, expressed as a number of segment_width units
 469  */
 470 static void draw_rectangle(unsigned val, uint8_t *dst, int dst_linesize, int segment_width,
 471                            int x, int y, int w, int h)
 472 {
 473     int i;
 474     int step = 3;
 475
 476     dst += segment_width * (step * x + y * dst_linesize);
 477     w *= segment_width * step;
 478     h *= segment_width;
 479     for (i = 0; i < h; i++) {
 480         memset(dst, val, w);
 481         dst += dst_linesize;
 482     }
 483 }
 484
 485 static void draw_digit(int digit, uint8_t *dst, int dst_linesize,
 486                        int segment_width)
 487 {
 488 #define TOP_HBAR        1
 489 #define MID_HBAR        2
 490 #define BOT_HBAR        4
 491 #define LEFT_TOP_VBAR   8
 492 #define LEFT_BOT_VBAR  16
 493 #define RIGHT_TOP_VBAR 32
 494 #define RIGHT_BOT_VBAR 64
 495     struct segments {
 496         int x, y, w, h;
 497     } segments[] = {
 498         { 1,  0, 5, 1 }, /* TOP_HBAR */
 499         { 1,  6, 5, 1 }, /* MID_HBAR */
 500         { 1, 12, 5, 1 }, /* BOT_HBAR */
 501         { 0,  1, 1, 5 }, /* LEFT_TOP_VBAR */
 502         { 0,  7, 1, 5 }, /* LEFT_BOT_VBAR */
 503         { 6,  1, 1, 5 }, /* RIGHT_TOP_VBAR */
 504         { 6,  7, 1, 5 }  /* RIGHT_BOT_VBAR */
 505     };
 506     static const unsigned char masks[10] = {
 507         /* 0 */ TOP_HBAR         |BOT_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
 508         /* 1 */                                                        RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
 509         /* 2 */ TOP_HBAR|MID_HBAR|BOT_HBAR|LEFT_BOT_VBAR                             |RIGHT_TOP_VBAR,
 510         /* 3 */ TOP_HBAR|MID_HBAR|BOT_HBAR                            |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
 511         /* 4 */          MID_HBAR         |LEFT_TOP_VBAR              |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
 512         /* 5 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR                             |RIGHT_BOT_VBAR,
 513         /* 6 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR               |RIGHT_BOT_VBAR,
 514         /* 7 */ TOP_HBAR                                              |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
 515         /* 8 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
 516         /* 9 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR              |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
 517     };
 518     unsigned mask = masks[digit];
 519     int i;
 520
 521     draw_rectangle(0, dst, dst_linesize, segment_width, 0, 0, 8, 13);
 522     for (i = 0; i < FF_ARRAY_ELEMS(segments); i++)
 523         if (mask & (1<<i))
 524             draw_rectangle(255, dst, dst_linesize, segment_width,
 525                            segments[i].x, segments[i].y, segments[i].w, segments[i].h);
 526 }
 527
 528 #define GRADIENT_SIZE (6 * 256)
 529
 530 static void test_fill_picture(AVFilterContext *ctx, AVFrame *frame)
 531 {
 532     TestSourceContext *test = ctx->priv;
 533     uint8_t *p, *p0;
 534     int x, y;
 535     int color, color_rest;
 536     int icolor;
 537     int radius;
 538     int quad0, quad;
 539     int dquad_x, dquad_y;
 540     int grad, dgrad, rgrad, drgrad;
 541     int seg_size;
 542     int second;
 543     int i;
 544     uint8_t *data = frame->data[0];
 545     int width  = frame->width;
 546     int height = frame->height;
 547
 548     /* draw colored bars and circle */
 549     radius = (width + height) / 4;
 550     quad0 = width * width / 4 + height * height / 4 - radius * radius;
 551     dquad_y = 1 - height;
 552     p0 = data;
 553     for (y = 0; y < height; y++) {
 554         p = p0;
 555         color = 0;
 556         color_rest = 0;
 557         quad = quad0;
 558         dquad_x = 1 - width;
 559         for (x = 0; x < width; x++) {
 560             icolor = color;
 561             if (quad < 0)
 562                 icolor ^= 7;
 563             quad += dquad_x;
 564             dquad_x += 2;
 565             *(p++) = icolor & 1 ? 255 : 0;
 566             *(p++) = icolor & 2 ? 255 : 0;
 567             *(p++) = icolor & 4 ? 255 : 0;
 568             color_rest += 8;
 569             if (color_rest >= width) {
 570                 color_rest -= width;
 571                 color++;
 572             }
 573         }
 574         quad0 += dquad_y;
 575         dquad_y += 2;
 576         p0 += frame->linesize[0];
 577     }
 578
 579     /* draw sliding color line */
 580     p0 = p = data + frame->linesize[0] * (height * 3/4);
 581     grad = (256 * test->nb_frame * test->time_base.num / test->time_base.den) %
 582         GRADIENT_SIZE;
 583     rgrad = 0;
 584     dgrad = GRADIENT_SIZE / width;
 585     drgrad = GRADIENT_SIZE % width;
 586     for (x = 0; x < width; x++) {
 587         *(p++) =
 588             grad < 256 || grad >= 5 * 256 ? 255 :
 589             grad >= 2 * 256 && grad < 4 * 256 ? 0 :
 590             grad < 2 * 256 ? 2 * 256 - 1 - grad : grad - 4 * 256;
 591         *(p++) =
 592             grad >= 4 * 256 ? 0 :
 593             grad >= 1 * 256 && grad < 3 * 256 ? 255 :
 594             grad < 1 * 256 ? grad : 4 * 256 - 1 - grad;
 595         *(p++) =
 596             grad < 2 * 256 ? 0 :
 597             grad >= 3 * 256 && grad < 5 * 256 ? 255 :
 598             grad < 3 * 256 ? grad - 2 * 256 : 6 * 256 - 1 - grad;
 599         grad += dgrad;
 600         rgrad += drgrad;
 601         if (rgrad >= GRADIENT_SIZE) {
 602             grad++;
 603             rgrad -= GRADIENT_SIZE;
 604         }
 605         if (grad >= GRADIENT_SIZE)
 606             grad -= GRADIENT_SIZE;
 607     }
 608     p = p0;
 609     for (y = height / 8; y > 0; y--) {
 610         memcpy(p+frame->linesize[0], p, 3 * width);
 611         p += frame->linesize[0];
 612     }
 613
 614     /* draw digits */
 615     seg_size = width / 80;
 616     if (seg_size >= 1 && height >= 13 * seg_size) {
 617         int64_t p10decimals = 1;
 618         double time = av_q2d(test->time_base) * test->nb_frame *
 619                       ff_exp10(test->nb_decimals);
 620         if (time >= INT_MAX)
 621             return;
 622
 623         for (x = 0; x < test->nb_decimals; x++)
 624             p10decimals *= 10;
 625
 626         second = av_rescale_rnd(test->nb_frame * test->time_base.num, p10decimals, test->time_base.den, AV_ROUND_ZERO);
 627         x = width - (width - seg_size * 64) / 2;
 628         y = (height - seg_size * 13) / 2;
 629         p = data + (x*3 + y * frame->linesize[0]);
 630         for (i = 0; i < 8; i++) {
 631             p -= 3 * 8 * seg_size;
 632             draw_digit(second % 10, p, frame->linesize[0], seg_size);
 633             second /= 10;
 634             if (second == 0)
 635                 break;
 636         }
 637     }
 638 }
 639
 640 static av_cold int test_init(AVFilterContext *ctx)
 641 {
 642     TestSourceContext *test = ctx->priv;
 643
 644     test->fill_picture_fn = test_fill_picture;
 645     return init(ctx);
 646 }
 647
 648 static int test_query_formats(AVFilterContext *ctx)
 649 {
 650     static const enum AVPixelFormat pix_fmts[] = {
 651         AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE
 652     };
 653
 654     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
 655     if (!fmts_list)
 656         return AVERROR(ENOMEM);
 657     return ff_set_common_formats(ctx, fmts_list);
 658 }
 659
 660 static const AVFilterPad avfilter_vsrc_testsrc_outputs[] = {
 661     {
 662         .name          = "default",
 663         .type          = AVMEDIA_TYPE_VIDEO,
 664         .request_frame = request_frame,
 665         .config_props  = config_props,
 666     },
 667     { NULL }
 668 };
 669
 670 AVFilter ff_vsrc_testsrc = {
 671     .name          = "testsrc",
 672     .description   = NULL_IF_CONFIG_SMALL("Generate test pattern."),
 673     .priv_size     = sizeof(TestSourceContext),
 674     .priv_class    = &testsrc_class,
 675     .init          = test_init,
 676     .uninit        = uninit,
 677     .query_formats = test_query_formats,
 678     .inputs        = NULL,
 679     .outputs       = avfilter_vsrc_testsrc_outputs,
 680 };
 681
 682 #endif /* CONFIG_TESTSRC_FILTER */
 683
 684 #if CONFIG_TESTSRC2_FILTER
 685
 686 static const AVOption testsrc2_options[] = {
 687     COMMON_OPTIONS
 688     { NULL }
 689 };
 690
 691 AVFILTER_DEFINE_CLASS(testsrc2);
 692
 693 static void set_color(TestSourceContext *s, FFDrawColor *color, uint32_t argb)
 694 {
 695     uint8_t rgba[4] = { (argb >> 16) & 0xFF,
 696                         (argb >>  8) & 0xFF,
 697                         (argb >>  0) & 0xFF,
 698                         (argb >> 24) & 0xFF, };
 699     ff_draw_color(&s->draw, color, rgba);
 700 }
 701
 702 static uint32_t color_gradient(unsigned index)
 703 {
 704     unsigned si = index & 0xFF, sd = 0xFF - si;
 705     switch (index >> 8) {
 706     case 0: return 0xFF0000 + (si <<  8);
 707     case 1: return 0x00FF00 + (sd << 16);
 708     case 2: return 0x00FF00 + (si <<  0);
 709     case 3: return 0x0000FF + (sd <<  8);
 710     case 4: return 0x0000FF + (si << 16);
 711     case 5: return 0xFF0000 + (sd <<  0);
 712     }
 713     av_assert0(0);
 714 }
 715
 716 static void draw_text(TestSourceContext *s, AVFrame *frame, FFDrawColor *color,
 717                       int x0, int y0, const uint8_t *text)
 718 {
 719     int x = x0;
 720
 721     for (; *text; text++) {
 722         if (*text == '\n') {
 723             x = x0;
 724             y0 += 16;
 725             continue;
 726         }
 727         ff_blend_mask(&s->draw, color, frame->data, frame->linesize,
 728                       frame->width, frame->height,
 729                       avpriv_vga16_font + *text * 16, 1, 8, 16, 0, 0, x, y0);
 730         x += 8;
 731     }
 732 }
 733
 734 static void test2_fill_picture(AVFilterContext *ctx, AVFrame *frame)
 735 {
 736     TestSourceContext *s = ctx->priv;
 737     FFDrawColor color;
 738
 739     /* colored background */
 740     {
 741         unsigned i, x = 0, x2;
 742
 743         x = 0;
 744         for (i = 1; i < 7; i++) {
 745             x2 = av_rescale(i, s->w, 6);
 746             x2 = ff_draw_round_to_sub(&s->draw, 0, 0, x2);
 747             set_color(s, &color, ((i & 1) ? 0xFF0000 : 0) |
 748                                  ((i & 2) ? 0x00FF00 : 0) |
 749                                  ((i & 4) ? 0x0000FF : 0));
 750             ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,
 751                               x, 0, x2 - x, frame->height);
 752             x = x2;
 753         }
 754     }
 755
 756     /* oblique gradient */
 757     /* note: too slow if using blending */
 758     if (s->h >= 64) {
 759         unsigned x, dx, y0, y, g0, g;
 760
 761         dx = ff_draw_round_to_sub(&s->draw, 0, +1, 1);
 762         y0 = av_rescale_q(s->pts, s->time_base, av_make_q(2, s->h - 16));
 763         g0 = av_rescale_q(s->pts, s->time_base, av_make_q(1, 128));
 764         for (x = 0; x < s->w; x += dx) {
 765             g = (av_rescale(x, 6 * 256, s->w) + g0) % (6 * 256);
 766             set_color(s, &color, color_gradient(g));
 767             y = y0 + av_rescale(x, s->h / 2, s->w);
 768             y %= 2 * (s->h - 16);
 769             if (y > s->h - 16)
 770                 y = 2 * (s->h - 16) - y;
 771             y = ff_draw_round_to_sub(&s->draw, 1, 0, y);
 772             ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,
 773                               x, y, dx, 16);
 774         }
 775     }
 776
 777     /* top right: draw clock hands */
 778     if (s->w >= 64 && s->h >= 64) {
 779         int l = (FFMIN(s->w, s->h) - 32) >> 1;
 780         int steps = FFMAX(4, l >> 5);
 781         int xc = (s->w >> 2) + (s->w >> 1);
 782         int yc = (s->h >> 2);
 783         int cycle = l << 2;
 784         int pos, xh, yh;
 785         int c, i;
 786
 787         for (c = 0; c < 3; c++) {
 788             set_color(s, &color, 0xBBBBBB ^ (0xFF << (c << 3)));
 789             pos = av_rescale_q(s->pts, s->time_base, av_make_q(64 >> (c << 1), cycle)) % cycle;
 790             xh = pos < 1 * l ? pos :
 791                  pos < 2 * l ? l :
 792                  pos < 3 * l ? 3 * l - pos : 0;
 793             yh = pos < 1 * l ? 0 :
 794                  pos < 2 * l ? pos - l :
 795                  pos < 3 * l ? l :
 796                                cycle - pos;
 797             xh -= l >> 1;
 798             yh -= l >> 1;
 799             for (i = 1; i <= steps; i++) {
 800                 int x = av_rescale(xh, i, steps) + xc;
 801                 int y = av_rescale(yh, i, steps) + yc;
 802                 x = ff_draw_round_to_sub(&s->draw, 0, -1, x);
 803                 y = ff_draw_round_to_sub(&s->draw, 1, -1, y);
 804                 ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,
 805                                   x, y, 8, 8);
 806             }
 807         }
 808     }
 809
 810     /* bottom left: beating rectangles */
 811     if (s->w >= 64 && s->h >= 64) {
 812         int l = (FFMIN(s->w, s->h) - 16) >> 2;
 813         int cycle = l << 3;
 814         int xc = (s->w >> 2);
 815         int yc = (s->h >> 2) + (s->h >> 1);
 816         int xm1 = ff_draw_round_to_sub(&s->draw, 0, -1, xc - 8);
 817         int xm2 = ff_draw_round_to_sub(&s->draw, 0, +1, xc + 8);
 818         int ym1 = ff_draw_round_to_sub(&s->draw, 1, -1, yc - 8);
 819         int ym2 = ff_draw_round_to_sub(&s->draw, 1, +1, yc + 8);
 820         int size, step, x1, x2, y1, y2;
 821
 822         size = av_rescale_q(s->pts, s->time_base, av_make_q(4, cycle));
 823         step = size / l;
 824         size %= l;
 825         if (step & 1)
 826             size = l - size;
 827         step = (step >> 1) & 3;
 828         set_color(s, &color, 0xFF808080);
 829         x1 = ff_draw_round_to_sub(&s->draw, 0, -1, xc - 4 - size);
 830         x2 = ff_draw_round_to_sub(&s->draw, 0, +1, xc + 4 + size);
 831         y1 = ff_draw_round_to_sub(&s->draw, 1, -1, yc - 4 - size);
 832         y2 = ff_draw_round_to_sub(&s->draw, 1, +1, yc + 4 + size);
 833         if (step == 0 || step == 2)
 834             ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,
 835                               x1, ym1, x2 - x1, ym2 - ym1);
 836         if (step == 1 || step == 2)
 837             ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,
 838                               xm1, y1, xm2 - xm1, y2 - y1);
 839         if (step == 3)
 840             ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,
 841                               x1, y1, x2 - x1, y2 - y1);
 842     }
 843
 844     /* bottom right: checker with random noise */
 845     {
 846         unsigned xmin = av_rescale(5, s->w, 8);
 847         unsigned xmax = av_rescale(7, s->w, 8);
 848         unsigned ymin = av_rescale(5, s->h, 8);
 849         unsigned ymax = av_rescale(7, s->h, 8);
 850         unsigned x, y, i, r;
 851         uint8_t alpha[256];
 852
 853         r = s->pts;
 854         for (y = ymin; y < ymax - 15; y += 16) {
 855             for (x = xmin; x < xmax - 15; x += 16) {
 856                 if ((x ^ y) & 16)
 857                     continue;
 858                 for (i = 0; i < 256; i++) {
 859                     r = r * 1664525 + 1013904223;
 860                     alpha[i] = r >> 24;
 861                 }
 862                 set_color(s, &color, 0xFF00FF80);
 863                 ff_blend_mask(&s->draw, &color, frame->data, frame->linesize,
 864                                    frame->width, frame->height,
 865                                    alpha, 16, 16, 16, 3, 0, x, y);
 866             }
 867         }
 868     }
 869
 870     /* bouncing square */
 871     if (s->w >= 16 && s->h >= 16) {
 872         unsigned w = s->w - 8;
 873         unsigned h = s->h - 8;
 874         unsigned x = av_rescale_q(s->pts, s->time_base, av_make_q(233, 55 * w)) % (w << 1);
 875         unsigned y = av_rescale_q(s->pts, s->time_base, av_make_q(233, 89 * h)) % (h << 1);
 876         if (x > w)
 877             x = (w << 1) - x;
 878         if (y > h)
 879             y = (h << 1) - y;
 880         x = ff_draw_round_to_sub(&s->draw, 0, -1, x);
 881         y = ff_draw_round_to_sub(&s->draw, 1, -1, y);
 882         set_color(s, &color, 0xFF8000FF);
 883         ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,
 884                           x, y, 8, 8);
 885     }
 886
 887     /* top right: draw frame time and frame number */
 888     {
 889         char buf[256];
 890         unsigned time;
 891
 892         time = av_rescale_q(s->pts, s->time_base, av_make_q(1, 1000)) % 86400000;
 893         set_color(s, &color, 0xC0000000);
 894         ff_blend_rectangle(&s->draw, &color, frame->data, frame->linesize,
 895                            frame->width, frame->height,
 896                            2, 2, 100, 36);
 897         set_color(s, &color, 0xFFFF8000);
 898         snprintf(buf, sizeof(buf), "%02d:%02d:%02d.%03d\n%12"PRIi64,
 899                  time / 3600000, (time / 60000) % 60, (time / 1000) % 60,
 900                  time % 1000, s->pts);
 901         draw_text(s, frame, &color, 4, 4, buf);
 902     }
 903 }
 904 static av_cold int test2_init(AVFilterContext *ctx)
 905 {
 906     TestSourceContext *s = ctx->priv;
 907
 908     s->fill_picture_fn = test2_fill_picture;
 909     return init(ctx);
 910 }
 911
 912 static int test2_query_formats(AVFilterContext *ctx)
 913 {
 914     return ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
 915 }
 916
 917 static int test2_config_props(AVFilterLink *inlink)
 918 {
 919     AVFilterContext *ctx = inlink->src;
 920     TestSourceContext *s = ctx->priv;
 921
 922     av_assert0(ff_draw_init(&s->draw, inlink->format, 0) >= 0);
 923     s->w = ff_draw_round_to_sub(&s->draw, 0, -1, s->w);
 924     s->h = ff_draw_round_to_sub(&s->draw, 1, -1, s->h);
 925     if (av_image_check_size(s->w, s->h, 0, ctx) < 0)
 926         return AVERROR(EINVAL);
 927     return config_props(inlink);
 928 }
 929
 930 static const AVFilterPad avfilter_vsrc_testsrc2_outputs[] = {
 931     {
 932         .name          = "default",
 933         .type          = AVMEDIA_TYPE_VIDEO,
 934         .request_frame = request_frame,
 935         .config_props  = test2_config_props,
 936     },
 937     { NULL }
 938 };
 939
 940 AVFilter ff_vsrc_testsrc2 = {
 941     .name          = "testsrc2",
 942     .description   = NULL_IF_CONFIG_SMALL("Generate another test pattern."),
 943     .priv_size     = sizeof(TestSourceContext),
 944     .priv_class    = &testsrc2_class,
 945     .init          = test2_init,
 946     .uninit        = uninit,
 947     .query_formats = test2_query_formats,
 948     .inputs        = NULL,
 949     .outputs       = avfilter_vsrc_testsrc2_outputs,
 950 };
 951
 952 #endif /* CONFIG_TESTSRC2_FILTER */
 953
 954 #if CONFIG_RGBTESTSRC_FILTER
 955
 956 #define rgbtestsrc_options options
 957 AVFILTER_DEFINE_CLASS(rgbtestsrc);
 958
 959 #define R 0
 960 #define G 1
 961 #define B 2
 962 #define A 3
 963
 964 static void rgbtest_put_pixel(uint8_t *dst, int dst_linesize,
 965                               int x, int y, int r, int g, int b, enum AVPixelFormat fmt,
 966                               uint8_t rgba_map[4])
 967 {
 968     int32_t v;
 969     uint8_t *p;
 970
 971     switch (fmt) {
 972     case AV_PIX_FMT_BGR444: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r >> 4) << 8) | ((g >> 4) << 4) | (b >> 4); break;
 973     case AV_PIX_FMT_RGB444: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b >> 4) << 8) | ((g >> 4) << 4) | (r >> 4); break;
 974     case AV_PIX_FMT_BGR555: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r>>3)<<10) | ((g>>3)<<5) | (b>>3); break;
 975     case AV_PIX_FMT_RGB555: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b>>3)<<10) | ((g>>3)<<5) | (r>>3); break;
 976     case AV_PIX_FMT_BGR565: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r>>3)<<11) | ((g>>2)<<5) | (b>>3); break;
 977     case AV_PIX_FMT_RGB565: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b>>3)<<11) | ((g>>2)<<5) | (r>>3); break;
 978     case AV_PIX_FMT_RGB24:
 979     case AV_PIX_FMT_BGR24:
 980         v = (r << (rgba_map[R]*8)) + (g << (rgba_map[G]*8)) + (b << (rgba_map[B]*8));
 981         p = dst + 3*x + y*dst_linesize;
 982         AV_WL24(p, v);
 983         break;
 984     case AV_PIX_FMT_RGBA:
 985     case AV_PIX_FMT_BGRA:
 986     case AV_PIX_FMT_ARGB:
 987     case AV_PIX_FMT_ABGR:
 988         v = (r << (rgba_map[R]*8)) + (g << (rgba_map[G]*8)) + (b << (rgba_map[B]*8)) + (255 << (rgba_map[A]*8));
 989         p = dst + 4*x + y*dst_linesize;
 990         AV_WL32(p, v);
 991         break;
 992     }
 993 }
 994
 995 static void rgbtest_fill_picture(AVFilterContext *ctx, AVFrame *frame)
 996 {
 997     TestSourceContext *test = ctx->priv;
 998     int x, y, w = frame->width, h = frame->height;
 999
1000     for (y = 0; y < h; y++) {
1001          for (x = 0; x < w; x++) {
1002              int c = 256*x/w;
1003              int r = 0, g = 0, b = 0;
1004
1005              if      (3*y < h  ) r = c;
1006              else if (3*y < 2*h) g = c;
1007              else                b = c;
1008
1009              rgbtest_put_pixel(frame->data[0], frame->linesize[0], x, y, r, g, b,
1010                                ctx->outputs[0]->format, test->rgba_map);
1011          }
1012      }
1013 }
1014
1015 static av_cold int rgbtest_init(AVFilterContext *ctx)
1016 {
1017     TestSourceContext *test = ctx->priv;
1018
1019     test->draw_once = 1;
1020     test->fill_picture_fn = rgbtest_fill_picture;
1021     return init(ctx);
1022 }
1023
1024 static int rgbtest_query_formats(AVFilterContext *ctx)
1025 {
1026     static const enum AVPixelFormat pix_fmts[] = {
1027         AV_PIX_FMT_RGBA, AV_PIX_FMT_ARGB, AV_PIX_FMT_BGRA, AV_PIX_FMT_ABGR,
1028         AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24,
1029         AV_PIX_FMT_RGB444, AV_PIX_FMT_BGR444,
1030         AV_PIX_FMT_RGB565, AV_PIX_FMT_BGR565,
1031         AV_PIX_FMT_RGB555, AV_PIX_FMT_BGR555,
1032         AV_PIX_FMT_NONE
1033     };
1034
1035     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
1036     if (!fmts_list)
1037         return AVERROR(ENOMEM);
1038     return ff_set_common_formats(ctx, fmts_list);
1039 }
1040
1041 static int rgbtest_config_props(AVFilterLink *outlink)
1042 {
1043     TestSourceContext *test = outlink->src->priv;
1044
1045     ff_fill_rgba_map(test->rgba_map, outlink->format);
1046     return config_props(outlink);
1047 }
1048
1049 static const AVFilterPad avfilter_vsrc_rgbtestsrc_outputs[] = {
1050     {
1051         .name          = "default",
1052         .type          = AVMEDIA_TYPE_VIDEO,
1053         .request_frame = request_frame,
1054         .config_props  = rgbtest_config_props,
1055     },
1056     { NULL }
1057 };
1058
1059 AVFilter ff_vsrc_rgbtestsrc = {
1060     .name          = "rgbtestsrc",
1061     .description   = NULL_IF_CONFIG_SMALL("Generate RGB test pattern."),
1062     .priv_size     = sizeof(TestSourceContext),
1063     .priv_class    = &rgbtestsrc_class,
1064     .init          = rgbtest_init,
1065     .uninit        = uninit,
1066     .query_formats = rgbtest_query_formats,
1067     .inputs        = NULL,
1068     .outputs       = avfilter_vsrc_rgbtestsrc_outputs,
1069 };
1070
1071 #endif /* CONFIG_RGBTESTSRC_FILTER */
1072
1073 #if CONFIG_YUVTESTSRC_FILTER
1074
1075 #define yuvtestsrc_options options
1076 AVFILTER_DEFINE_CLASS(yuvtestsrc);
1077
1078 static void yuvtest_fill_picture8(AVFilterContext *ctx, AVFrame *frame)
1079 {
1080     int x, y, w = frame->width, h = frame->height / 3;
1081     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
1082     const int factor = 1 << desc->comp[0].depth;
1083     const int mid = 1 << (desc->comp[0].depth - 1);
1084     uint8_t *ydst = frame->data[0];
1085     uint8_t *udst = frame->data[1];
1086     uint8_t *vdst = frame->data[2];
1087     int ylinesize = frame->linesize[0];
1088     int ulinesize = frame->linesize[1];
1089     int vlinesize = frame->linesize[2];
1090
1091     for (y = 0; y < h; y++) {
1092         for (x = 0; x < w; x++) {
1093             int c = factor * x / w;
1094
1095             ydst[x] = c;
1096             udst[x] = mid;
1097             vdst[x] = mid;
1098         }
1099
1100         ydst += ylinesize;
1101         udst += ulinesize;
1102         vdst += vlinesize;
1103     }
1104
1105     h += h;
1106     for (; y < h; y++) {
1107         for (x = 0; x < w; x++) {
1108             int c = factor * x / w;
1109
1110             ydst[x] = mid;
1111             udst[x] = c;
1112             vdst[x] = mid;
1113         }
1114
1115         ydst += ylinesize;
1116         udst += ulinesize;
1117         vdst += vlinesize;
1118     }
1119
1120     for (; y < frame->height; y++) {
1121         for (x = 0; x < w; x++) {
1122             int c = factor * x / w;
1123
1124             ydst[x] = mid;
1125             udst[x] = mid;
1126             vdst[x] = c;
1127         }
1128
1129         ydst += ylinesize;
1130         udst += ulinesize;
1131         vdst += vlinesize;
1132     }
1133 }
1134
1135 static void yuvtest_fill_picture16(AVFilterContext *ctx, AVFrame *frame)
1136 {
1137     int x, y, w = frame->width, h = frame->height / 3;
1138     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
1139     const int factor = 1 << desc->comp[0].depth;
1140     const int mid = 1 << (desc->comp[0].depth - 1);
1141     uint16_t *ydst = (uint16_t *)frame->data[0];
1142     uint16_t *udst = (uint16_t *)frame->data[1];
1143     uint16_t *vdst = (uint16_t *)frame->data[2];
1144     int ylinesize = frame->linesize[0] / 2;
1145     int ulinesize = frame->linesize[1] / 2;
1146     int vlinesize = frame->linesize[2] / 2;
1147
1148     for (y = 0; y < h; y++) {
1149         for (x = 0; x < w; x++) {
1150             int c = factor * x / w;
1151
1152             ydst[x] = c;
1153             udst[x] = mid;
1154             vdst[x] = mid;
1155         }
1156
1157         ydst += ylinesize;
1158         udst += ulinesize;
1159         vdst += vlinesize;
1160     }
1161
1162     h += h;
1163     for (; y < h; y++) {
1164         for (x = 0; x < w; x++) {
1165             int c = factor * x / w;
1166
1167             ydst[x] = mid;
1168             udst[x] = c;
1169             vdst[x] = mid;
1170         }
1171
1172         ydst += ylinesize;
1173         udst += ulinesize;
1174         vdst += vlinesize;
1175     }
1176
1177     for (; y < frame->height; y++) {
1178         for (x = 0; x < w; x++) {
1179             int c = factor * x / w;
1180
1181             ydst[x] = mid;
1182             udst[x] = mid;
1183             vdst[x] = c;
1184         }
1185
1186         ydst += ylinesize;
1187         udst += ulinesize;
1188         vdst += vlinesize;
1189     }
1190 }
1191
1192 static av_cold int yuvtest_init(AVFilterContext *ctx)
1193 {
1194     TestSourceContext *test = ctx->priv;
1195
1196     test->draw_once = 1;
1197     return init(ctx);
1198 }
1199
1200 static int yuvtest_query_formats(AVFilterContext *ctx)
1201 {
1202     static const enum AVPixelFormat pix_fmts[] = {
1203         AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
1204         AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10,
1205         AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14,
1206         AV_PIX_FMT_YUV444P16,
1207         AV_PIX_FMT_NONE
1208     };
1209
1210     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
1211     if (!fmts_list)
1212         return AVERROR(ENOMEM);
1213     return ff_set_common_formats(ctx, fmts_list);
1214 }
1215
1216 static int yuvtest_config_props(AVFilterLink *outlink)
1217 {
1218     TestSourceContext *test = outlink->src->priv;
1219     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
1220
1221     test->fill_picture_fn = desc->comp[0].depth > 8 ? yuvtest_fill_picture16 : yuvtest_fill_picture8;
1222     return config_props(outlink);
1223 }
1224
1225 static const AVFilterPad avfilter_vsrc_yuvtestsrc_outputs[] = {
1226     {
1227         .name          = "default",
1228         .type          = AVMEDIA_TYPE_VIDEO,
1229         .request_frame = request_frame,
1230         .config_props  = yuvtest_config_props,
1231     },
1232     { NULL }
1233 };
1234
1235 AVFilter ff_vsrc_yuvtestsrc = {
1236     .name          = "yuvtestsrc",
1237     .description   = NULL_IF_CONFIG_SMALL("Generate YUV test pattern."),
1238     .priv_size     = sizeof(TestSourceContext),
1239     .priv_class    = &yuvtestsrc_class,
1240     .init          = yuvtest_init,
1241     .uninit        = uninit,
1242     .query_formats = yuvtest_query_formats,
1243     .inputs        = NULL,
1244     .outputs       = avfilter_vsrc_yuvtestsrc_outputs,
1245 };
1246
1247 #endif /* CONFIG_YUVTESTSRC_FILTER */
1248
1249 #if CONFIG_SMPTEBARS_FILTER || CONFIG_SMPTEHDBARS_FILTER
1250
1251 static const uint8_t rainbow[7][4] = {
1252     { 180, 128, 128, 255 },     /* 75% white */
1253     { 162,  44, 142, 255 },     /* 75% yellow */
1254     { 131, 156,  44, 255 },     /* 75% cyan */
1255     { 112,  72,  58, 255 },     /* 75% green */
1256     {  84, 184, 198, 255 },     /* 75% magenta */
1257     {  65, 100, 212, 255 },     /* 75% red */
1258     {  35, 212, 114, 255 },     /* 75% blue */
1259 };
1260
1261 static const uint8_t rainbowhd[7][4] = {
1262     { 180, 128, 128, 255 },     /* 75% white */
1263     { 168,  44, 136, 255 },     /* 75% yellow */
1264     { 145, 147,  44, 255 },     /* 75% cyan */
1265     { 133,  63,  52, 255 },     /* 75% green */
1266     {  63, 193, 204, 255 },     /* 75% magenta */
1267     {  51, 109, 212, 255 },     /* 75% red */
1268     {  28, 212, 120, 255 },     /* 75% blue */
1269 };
1270
1271 static const uint8_t wobnair[7][4] = {
1272     {  35, 212, 114, 255 },     /* 75% blue */
1273     {  19, 128, 128, 255 },     /* 7.5% intensity black */
1274     {  84, 184, 198, 255 },     /* 75% magenta */
1275     {  19, 128, 128, 255 },     /* 7.5% intensity black */
1276     { 131, 156,  44, 255 },     /* 75% cyan */
1277     {  19, 128, 128, 255 },     /* 7.5% intensity black */
1278     { 180, 128, 128, 255 },     /* 75% white */
1279 };
1280
1281 static const uint8_t white[4] = { 235, 128, 128, 255 };
1282
1283 /* pluge pulses */
1284 static const uint8_t neg4ire[4] = {  7, 128, 128, 255 };
1285 static const uint8_t pos4ire[4] = { 24, 128, 128, 255 };
1286
1287 /* fudged Q/-I */
1288 static const uint8_t i_pixel[4] = { 57, 156,  97, 255 };
1289 static const uint8_t q_pixel[4] = { 44, 171, 147, 255 };
1290
1291 static const uint8_t gray40[4] = { 104, 128, 128, 255 };
1292 static const uint8_t gray15[4] = {  49, 128, 128, 255 };
1293 static const uint8_t   cyan[4] = { 188, 154,  16, 255 };
1294 static const uint8_t yellow[4] = { 219,  16, 138, 255 };
1295 static const uint8_t   blue[4] = {  32, 240, 118, 255 };
1296 static const uint8_t    red[4] = {  63, 102, 240, 255 };
1297 static const uint8_t black0[4] = {  16, 128, 128, 255 };
1298 static const uint8_t black2[4] = {  20, 128, 128, 255 };
1299 static const uint8_t black4[4] = {  25, 128, 128, 255 };
1300 static const uint8_t   neg2[4] = {  12, 128, 128, 255 };
1301
1302 static void draw_bar(TestSourceContext *test, const uint8_t color[4],
1303                      int x, int y, int w, int h,
1304                      AVFrame *frame)
1305 {
1306     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
1307     uint8_t *p, *p0;
1308     int plane;
1309
1310     x = FFMIN(x, test->w - 1);
1311     y = FFMIN(y, test->h - 1);
1312     w = FFMAX(FFMIN(w, test->w - x), 0);
1313     h = FFMAX(FFMIN(h, test->h - y), 0);
1314
1315     av_assert0(x + w <= test->w);
1316     av_assert0(y + h <= test->h);
1317
1318     for (plane = 0; frame->data[plane]; plane++) {
1319         const int c = color[plane];
1320         const int linesize = frame->linesize[plane];
1321         int i, px, py, pw, ph;
1322
1323         if (plane == 1 || plane == 2) {
1324             px = x >> desc->log2_chroma_w;
1325             pw = AV_CEIL_RSHIFT(w, desc->log2_chroma_w);
1326             py = y >> desc->log2_chroma_h;
1327             ph = AV_CEIL_RSHIFT(h, desc->log2_chroma_h);
1328         } else {
1329             px = x;
1330             pw = w;
1331             py = y;
1332             ph = h;
1333         }
1334
1335         p0 = p = frame->data[plane] + py * linesize + px;
1336         memset(p, c, pw);
1337         p += linesize;
1338         for (i = 1; i < ph; i++, p += linesize)
1339             memcpy(p, p0, pw);
1340     }
1341 }
1342
1343 static int smptebars_query_formats(AVFilterContext *ctx)
1344 {
1345     static const enum AVPixelFormat pix_fmts[] = {
1346         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
1347         AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
1348         AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
1349         AV_PIX_FMT_NONE,
1350     };
1351
1352     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
1353     if (!fmts_list)
1354         return AVERROR(ENOMEM);
1355     return ff_set_common_formats(ctx, fmts_list);
1356 }
1357
1358 static const AVFilterPad smptebars_outputs[] = {
1359     {
1360         .name          = "default",
1361         .type          = AVMEDIA_TYPE_VIDEO,
1362         .request_frame = request_frame,
1363         .config_props  = config_props,
1364     },
1365     { NULL }
1366 };
1367
1368 #if CONFIG_SMPTEBARS_FILTER
1369
1370 #define smptebars_options options
1371 AVFILTER_DEFINE_CLASS(smptebars);
1372
1373 static void smptebars_fill_picture(AVFilterContext *ctx, AVFrame *picref)
1374 {
1375     TestSourceContext *test = ctx->priv;
1376     int r_w, r_h, w_h, p_w, p_h, i, tmp, x = 0;
1377     const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format);
1378
1379     av_frame_set_colorspace(picref, AVCOL_SPC_BT470BG);
1380
1381     r_w = FFALIGN((test->w + 6) / 7, 1 << pixdesc->log2_chroma_w);
1382     r_h = FFALIGN(test->h * 2 / 3, 1 << pixdesc->log2_chroma_h);
1383     w_h = FFALIGN(test->h * 3 / 4 - r_h,  1 << pixdesc->log2_chroma_h);
1384     p_w = FFALIGN(r_w * 5 / 4, 1 << pixdesc->log2_chroma_w);
1385     p_h = test->h - w_h - r_h;
1386
1387     for (i = 0; i < 7; i++) {
1388         draw_bar(test, rainbow[i], x, 0,   r_w, r_h, picref);
1389         draw_bar(test, wobnair[i], x, r_h, r_w, w_h, picref);
1390         x += r_w;
1391     }
1392     x = 0;
1393     draw_bar(test, i_pixel, x, r_h + w_h, p_w, p_h, picref);
1394     x += p_w;
1395     draw_bar(test, white, x, r_h + w_h, p_w, p_h, picref);
1396     x += p_w;
1397     draw_bar(test, q_pixel, x, r_h + w_h, p_w, p_h, picref);
1398     x += p_w;
1399     tmp = FFALIGN(5 * r_w - x,  1 << pixdesc->log2_chroma_w);
1400     draw_bar(test, black0, x, r_h + w_h, tmp, p_h, picref);
1401     x += tmp;
1402     tmp = FFALIGN(r_w / 3,  1 << pixdesc->log2_chroma_w);
1403     draw_bar(test, neg4ire, x, r_h + w_h, tmp, p_h, picref);
1404     x += tmp;
1405     draw_bar(test, black0, x, r_h + w_h, tmp, p_h, picref);
1406     x += tmp;
1407     draw_bar(test, pos4ire, x, r_h + w_h, tmp, p_h, picref);
1408     x += tmp;
1409     draw_bar(test, black0, x, r_h + w_h, test->w - x, p_h, picref);
1410 }
1411
1412 static av_cold int smptebars_init(AVFilterContext *ctx)
1413 {
1414     TestSourceContext *test = ctx->priv;
1415
1416     test->fill_picture_fn = smptebars_fill_picture;
1417     test->draw_once = 1;
1418     return init(ctx);
1419 }
1420
1421 AVFilter ff_vsrc_smptebars = {
1422     .name          = "smptebars",
1423     .description   = NULL_IF_CONFIG_SMALL("Generate SMPTE color bars."),
1424     .priv_size     = sizeof(TestSourceContext),
1425     .priv_class    = &smptebars_class,
1426     .init          = smptebars_init,
1427     .uninit        = uninit,
1428     .query_formats = smptebars_query_formats,
1429     .inputs        = NULL,
1430     .outputs       = smptebars_outputs,
1431 };
1432
1433 #endif  /* CONFIG_SMPTEBARS_FILTER */
1434
1435 #if CONFIG_SMPTEHDBARS_FILTER
1436
1437 #define smptehdbars_options options
1438 AVFILTER_DEFINE_CLASS(smptehdbars);
1439
1440 static void smptehdbars_fill_picture(AVFilterContext *ctx, AVFrame *picref)
1441 {
1442     TestSourceContext *test = ctx->priv;
1443     int d_w, r_w, r_h, l_w, i, tmp, x = 0, y = 0;
1444     const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format);
1445
1446     av_frame_set_colorspace(picref, AVCOL_SPC_BT709);
1447
1448     d_w = FFALIGN(test->w / 8, 1 << pixdesc->log2_chroma_w);
1449     r_h = FFALIGN(test->h * 7 / 12, 1 << pixdesc->log2_chroma_h);
1450     draw_bar(test, gray40, x, 0, d_w, r_h, picref);
1451     x += d_w;
1452
1453     r_w = FFALIGN((((test->w + 3) / 4) * 3) / 7, 1 << pixdesc->log2_chroma_w);
1454     for (i = 0; i < 7; i++) {
1455         draw_bar(test, rainbowhd[i], x, 0, r_w, r_h, picref);
1456         x += r_w;
1457     }
1458     draw_bar(test, gray40, x, 0, test->w - x, r_h, picref);
1459     y = r_h;
1460     r_h = FFALIGN(test->h / 12, 1 << pixdesc->log2_chroma_h);
1461     draw_bar(test, cyan, 0, y, d_w, r_h, picref);
1462     x = d_w;
1463     draw_bar(test, i_pixel, x, y, r_w, r_h, picref);
1464     x += r_w;
1465     tmp = r_w * 6;
1466     draw_bar(test, rainbowhd[0], x, y, tmp, r_h, picref);
1467     x += tmp;
1468     l_w = x;
1469     draw_bar(test, blue, x, y, test->w - x, r_h, picref);
1470     y += r_h;
1471     draw_bar(test, yellow, 0, y, d_w, r_h, picref);
1472     x = d_w;
1473     draw_bar(test, q_pixel, x, y, r_w, r_h, picref);
1474     x += r_w;
1475
1476     for (i = 0; i < tmp; i += 1 << pixdesc->log2_chroma_w) {
1477         uint8_t yramp[4] = {0};
1478
1479         yramp[0] = i * 255 / tmp;
1480         yramp[1] = 128;
1481         yramp[2] = 128;
1482         yramp[3] = 255;
1483
1484         draw_bar(test, yramp, x, y, 1 << pixdesc->log2_chroma_w, r_h, picref);
1485         x += 1 << pixdesc->log2_chroma_w;
1486     }
1487     draw_bar(test, red, x, y, test->w - x, r_h, picref);
1488     y += r_h;
1489     draw_bar(test, gray15, 0, y, d_w, test->h - y, picref);
1490     x = d_w;
1491     tmp = FFALIGN(r_w * 3 / 2, 1 << pixdesc->log2_chroma_w);
1492     draw_bar(test, black0, x, y, tmp, test->h - y, picref);
1493     x += tmp;
1494     tmp = FFALIGN(r_w * 2, 1 << pixdesc->log2_chroma_w);
1495     draw_bar(test, white, x, y, tmp, test->h - y, picref);
1496     x += tmp;
1497     tmp = FFALIGN(r_w * 5 / 6, 1 << pixdesc->log2_chroma_w);
1498     draw_bar(test, black0, x, y, tmp, test->h - y, picref);
1499     x += tmp;
1500     tmp = FFALIGN(r_w / 3, 1 << pixdesc->log2_chroma_w);
1501     draw_bar(test,   neg2, x, y, tmp, test->h - y, picref);
1502     x += tmp;
1503     draw_bar(test, black0, x, y, tmp, test->h - y, picref);
1504     x += tmp;
1505     draw_bar(test, black2, x, y, tmp, test->h - y, picref);
1506     x += tmp;
1507     draw_bar(test, black0, x, y, tmp, test->h - y, picref);
1508     x += tmp;
1509     draw_bar(test, black4, x, y, tmp, test->h - y, picref);
1510     x += tmp;
1511     r_w = l_w - x;
1512     draw_bar(test, black0, x, y, r_w, test->h - y, picref);
1513     x += r_w;
1514     draw_bar(test, gray15, x, y, test->w - x, test->h - y, picref);
1515 }
1516
1517 static av_cold int smptehdbars_init(AVFilterContext *ctx)
1518 {
1519     TestSourceContext *test = ctx->priv;
1520
1521     test->fill_picture_fn = smptehdbars_fill_picture;
1522     test->draw_once = 1;
1523     return init(ctx);
1524 }
1525
1526 AVFilter ff_vsrc_smptehdbars = {
1527     .name          = "smptehdbars",
1528     .description   = NULL_IF_CONFIG_SMALL("Generate SMPTE HD color bars."),
1529     .priv_size     = sizeof(TestSourceContext),
1530     .priv_class    = &smptehdbars_class,
1531     .init          = smptehdbars_init,
1532     .uninit        = uninit,
1533     .query_formats = smptebars_query_formats,
1534     .inputs        = NULL,
1535     .outputs       = smptebars_outputs,
1536 };
1537
1538 #endif  /* CONFIG_SMPTEHDBARS_FILTER */
1539 #endif  /* CONFIG_SMPTEBARS_FILTER || CONFIG_SMPTEHDBARS_FILTER */
1540
1541 #if CONFIG_ALLYUV_FILTER
1542
1543 static const AVOption allyuv_options[] = {
1544     COMMON_OPTIONS_NOSIZE
1545     { NULL }
1546 };
1547
1548 AVFILTER_DEFINE_CLASS(allyuv);
1549
1550 static void allyuv_fill_picture(AVFilterContext *ctx, AVFrame *frame)
1551 {
1552     const int ys = frame->linesize[0];
1553     const int us = frame->linesize[1];
1554     const int vs = frame->linesize[2];
1555     int x, y, j;
1556
1557     for (y = 0; y < 4096; y++) {
1558         for (x = 0; x < 2048; x++) {
1559             frame->data[0][y * ys + x] = ((x / 8) % 256);
1560             frame->data[0][y * ys + 4095 - x] = ((x / 8) % 256);
1561         }
1562
1563         for (x = 0; x < 2048; x+=8) {
1564             for (j = 0; j < 8; j++) {
1565                 frame->data[1][vs * y + x + j]        = (y%16 + (j % 8) * 16);
1566                 frame->data[1][vs * y + 4095 - x - j] = (128 + y%16 + (j % 8) * 16);
1567             }
1568         }
1569
1570         for (x = 0; x < 4096; x++)
1571             frame->data[2][y * us + x] = 256 * y / 4096;
1572     }
1573 }
1574
1575 static av_cold int allyuv_init(AVFilterContext *ctx)
1576 {
1577     TestSourceContext *test = ctx->priv;
1578
1579     test->w = test->h = 4096;
1580     test->draw_once = 1;
1581     test->fill_picture_fn = allyuv_fill_picture;
1582     return init(ctx);
1583 }
1584
1585 static int allyuv_query_formats(AVFilterContext *ctx)
1586 {
1587     static const enum AVPixelFormat pix_fmts[] = {
1588         AV_PIX_FMT_YUV444P, AV_PIX_FMT_GBRP,
1589         AV_PIX_FMT_NONE
1590     };
1591
1592     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
1593     if (!fmts_list)
1594         return AVERROR(ENOMEM);
1595     return ff_set_common_formats(ctx, fmts_list);
1596 }
1597
1598 static const AVFilterPad avfilter_vsrc_allyuv_outputs[] = {
1599     {
1600         .name          = "default",
1601         .type          = AVMEDIA_TYPE_VIDEO,
1602         .request_frame = request_frame,
1603         .config_props  = config_props,
1604     },
1605     { NULL }
1606 };
1607
1608 AVFilter ff_vsrc_allyuv = {
1609     .name          = "allyuv",
1610     .description   = NULL_IF_CONFIG_SMALL("Generate all yuv colors."),
1611     .priv_size     = sizeof(TestSourceContext),
1612     .priv_class    = &allyuv_class,
1613     .init          = allyuv_init,
1614     .uninit        = uninit,
1615     .query_formats = allyuv_query_formats,
1616     .inputs        = NULL,
1617     .outputs       = avfilter_vsrc_allyuv_outputs,
1618 };
1619
1620 #endif /* CONFIG_ALLYUV_FILTER */
1621
1622 #if CONFIG_ALLRGB_FILTER
1623
1624 static const AVOption allrgb_options[] = {
1625     COMMON_OPTIONS_NOSIZE
1626     { NULL }
1627 };
1628
1629 AVFILTER_DEFINE_CLASS(allrgb);
1630
1631 static void allrgb_fill_picture(AVFilterContext *ctx, AVFrame *frame)
1632 {
1633     unsigned x, y;
1634     const int linesize = frame->linesize[0];
1635     uint8_t *line = frame->data[0];
1636
1637     for (y = 0; y < 4096; y++) {
1638         uint8_t *dst = line;
1639
1640         for (x = 0; x < 4096; x++) {
1641             *dst++ = x;
1642             *dst++ = y;
1643             *dst++ = (x >> 8) | ((y >> 8) << 4);
1644         }
1645         line += linesize;
1646     }
1647 }
1648
1649 static av_cold int allrgb_init(AVFilterContext *ctx)
1650 {
1651     TestSourceContext *test = ctx->priv;
1652
1653     test->w = test->h = 4096;
1654     test->draw_once = 1;
1655     test->fill_picture_fn = allrgb_fill_picture;
1656     return init(ctx);
1657 }
1658
1659 static int allrgb_config_props(AVFilterLink *outlink)
1660 {
1661     TestSourceContext *test = outlink->src->priv;
1662
1663     ff_fill_rgba_map(test->rgba_map, outlink->format);
1664     return config_props(outlink);
1665 }
1666
1667 static int allrgb_query_formats(AVFilterContext *ctx)
1668 {
1669     static const enum AVPixelFormat pix_fmts[] = {
1670         AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE
1671     };
1672
1673     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
1674     if (!fmts_list)
1675         return AVERROR(ENOMEM);
1676     return ff_set_common_formats(ctx, fmts_list);
1677 }
1678
1679 static const AVFilterPad avfilter_vsrc_allrgb_outputs[] = {
1680     {
1681         .name          = "default",
1682         .type          = AVMEDIA_TYPE_VIDEO,
1683         .request_frame = request_frame,
1684         .config_props  = allrgb_config_props,
1685     },
1686     { NULL }
1687 };
1688
1689 AVFilter ff_vsrc_allrgb = {
1690     .name          = "allrgb",
1691     .description   = NULL_IF_CONFIG_SMALL("Generate all RGB colors."),
1692     .priv_size     = sizeof(TestSourceContext),
1693     .priv_class    = &allrgb_class,
1694     .init          = allrgb_init,
1695     .uninit        = uninit,
1696     .query_formats = allrgb_query_formats,
1697     .inputs        = NULL,
1698     .outputs       = avfilter_vsrc_allrgb_outputs,
1699 };
1700
1701 #endif /* CONFIG_ALLRGB_FILTER */