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 * 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/opt.h" 41#include "libavutil/imgutils.h" 42#include "libavutil/intreadwrite.h" 43#include "libavutil/parseutils.h" 44#include "avfilter.h" 45#include "drawutils.h" 46#include "formats.h" 47#include "internal.h" 48#include "video.h" 49 50typedef struct TestSourceContext { 51 const AVClass *class; 52 int w, h; 53 unsigned int nb_frame; 54 AVRational time_base, frame_rate; 55 int64_t pts; 56 int64_t duration; ///< duration expressed in microseconds 57 AVRational sar; ///< sample aspect ratio 58 int draw_once; ///< draw only the first frame, always put out the same picture 59 int draw_once_reset; ///< draw only the first frame or in case of reset 60 AVFrame *picref; ///< cached reference containing the painted picture 61 62 void (* fill_picture_fn)(AVFilterContext *ctx, AVFrame *frame); 63 64 /* only used by testsrc */ 65 int nb_decimals; 66 67 /* only used by color */ 68 FFDrawContext draw; 69 FFDrawColor color; 70 uint8_t color_rgba[4]; 71 72 /* only used by rgbtest */ 73 uint8_t rgba_map[4]; 74 75 /* only used by haldclut */ 76 int level; 77} TestSourceContext; 78 79#define OFFSET(x) offsetof(TestSourceContext, x) 80#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM 81 82#define SIZE_OPTIONS \ 83 { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },\ 84 { "s", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },\ 85 86#define COMMON_OPTIONS_NOSIZE \ 87 { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, 0, FLAGS },\ 88 { "r", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, 0, FLAGS },\ 89 { "duration", "set video duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },\ 90 { "d", "set video duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },\ 91 { "sar", "set video sample aspect ratio", OFFSET(sar), AV_OPT_TYPE_RATIONAL, {.dbl= 1}, 0, INT_MAX, FLAGS }, 92 93#define COMMON_OPTIONS SIZE_OPTIONS COMMON_OPTIONS_NOSIZE 94 95static const AVOption options[] = { 96 COMMON_OPTIONS 97 { NULL } 98}; 99 100static av_cold int init(AVFilterContext *ctx) 101{ 102 TestSourceContext *test = ctx->priv; 103 104 test->time_base = av_inv_q(test->frame_rate); 105 test->nb_frame = 0; 106 test->pts = 0; 107 108 av_log(ctx, AV_LOG_VERBOSE, "size:%dx%d rate:%d/%d duration:%f sar:%d/%d\n", 109 test->w, test->h, test->frame_rate.num, test->frame_rate.den, 110 test->duration < 0 ? -1 : (double)test->duration/1000000, 111 test->sar.num, test->sar.den); 112 return 0; 113} 114 115static av_cold void uninit(AVFilterContext *ctx) 116{ 117 TestSourceContext *test = ctx->priv; 118 119 av_frame_free(&test->picref); 120} 121 122static int config_props(AVFilterLink *outlink) 123{ 124 TestSourceContext *test = outlink->src->priv; 125 126 outlink->w = test->w; 127 outlink->h = test->h; 128 outlink->sample_aspect_ratio = test->sar; 129 outlink->frame_rate = test->frame_rate; 130 outlink->time_base = test->time_base; 131 132 return 0; 133} 134 135static int request_frame(AVFilterLink *outlink) 136{ 137 TestSourceContext *test = outlink->src->priv; 138 AVFrame *frame; 139 140 if (test->duration >= 0 && 141 av_rescale_q(test->pts, test->time_base, AV_TIME_BASE_Q) >= test->duration) 142 return AVERROR_EOF; 143 144 if (test->draw_once) { 145 if (test->draw_once_reset) { 146 av_frame_free(&test->picref); 147 test->draw_once_reset = 0; 148 } 149 if (!test->picref) { 150 test->picref = 151 ff_get_video_buffer(outlink, test->w, test->h); 152 if (!test->picref) 153 return AVERROR(ENOMEM); 154 test->fill_picture_fn(outlink->src, test->picref); 155 } 156 frame = av_frame_clone(test->picref); 157 } else 158 frame = ff_get_video_buffer(outlink, test->w, test->h); 159 160 if (!frame) 161 return AVERROR(ENOMEM); 162 frame->pts = test->pts; 163 frame->key_frame = 1; 164 frame->interlaced_frame = 0; 165 frame->pict_type = AV_PICTURE_TYPE_I; 166 frame->sample_aspect_ratio = test->sar; 167 if (!test->draw_once) 168 test->fill_picture_fn(outlink->src, frame); 169 170 test->pts++; 171 test->nb_frame++; 172 173 return ff_filter_frame(outlink, frame); 174} 175 176#if CONFIG_COLOR_FILTER 177 178static const AVOption color_options[] = { 179 { "color", "set color", OFFSET(color_rgba), AV_OPT_TYPE_COLOR, {.str = "black"}, CHAR_MIN, CHAR_MAX, FLAGS }, 180 { "c", "set color", OFFSET(color_rgba), AV_OPT_TYPE_COLOR, {.str = "black"}, CHAR_MIN, CHAR_MAX, FLAGS }, 181 COMMON_OPTIONS 182 { NULL } 183}; 184 185AVFILTER_DEFINE_CLASS(color); 186 187static void color_fill_picture(AVFilterContext *ctx, AVFrame *picref) 188{ 189 TestSourceContext *test = ctx->priv; 190 ff_fill_rectangle(&test->draw, &test->color, 191 picref->data, picref->linesize, 192 0, 0, test->w, test->h); 193} 194 195static av_cold int color_init(AVFilterContext *ctx) 196{ 197 TestSourceContext *test = ctx->priv; 198 test->fill_picture_fn = color_fill_picture; 199 test->draw_once = 1; 200 return init(ctx); 201} 202 203static int color_query_formats(AVFilterContext *ctx) 204{ 205 ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0)); 206 return 0; 207} 208 209static int color_config_props(AVFilterLink *inlink) 210{ 211 AVFilterContext *ctx = inlink->src; 212 TestSourceContext *test = ctx->priv; 213 int ret; 214 215 ff_draw_init(&test->draw, inlink->format, 0); 216 ff_draw_color(&test->draw, &test->color, test->color_rgba); 217 218 test->w = ff_draw_round_to_sub(&test->draw, 0, -1, test->w); 219 test->h = ff_draw_round_to_sub(&test->draw, 1, -1, test->h); 220 if (av_image_check_size(test->w, test->h, 0, ctx) < 0) 221 return AVERROR(EINVAL); 222 223 if ((ret = config_props(inlink)) < 0) 224 return ret; 225 226 return 0; 227} 228 229static int color_process_command(AVFilterContext *ctx, const char *cmd, const char *args, 230 char *res, int res_len, int flags) 231{ 232 TestSourceContext *test = ctx->priv; 233 int ret; 234 235 if (!strcmp(cmd, "color") || !strcmp(cmd, "c")) { 236 uint8_t color_rgba[4]; 237 238 ret = av_parse_color(color_rgba, args, -1, ctx); 239 if (ret < 0) 240 return ret; 241 242 memcpy(test->color_rgba, color_rgba, sizeof(color_rgba)); 243 ff_draw_color(&test->draw, &test->color, test->color_rgba); 244 test->draw_once_reset = 1; 245 return 0; 246 } 247 248 return AVERROR(ENOSYS); 249} 250 251static const AVFilterPad color_outputs[] = { 252 { 253 .name = "default", 254 .type = AVMEDIA_TYPE_VIDEO, 255 .request_frame = request_frame, 256 .config_props = color_config_props, 257 }, 258 { NULL } 259}; 260 261AVFilter ff_vsrc_color = { 262 .name = "color", 263 .description = NULL_IF_CONFIG_SMALL("Provide an uniformly colored input."), 264 .priv_class = &color_class, 265 .priv_size = sizeof(TestSourceContext), 266 .init = color_init, 267 .uninit = uninit, 268 .query_formats = color_query_formats, 269 .inputs = NULL, 270 .outputs = color_outputs, 271 .process_command = color_process_command, 272}; 273 274#endif /* CONFIG_COLOR_FILTER */ 275 276#if CONFIG_HALDCLUTSRC_FILTER 277 278static const AVOption haldclutsrc_options[] = { 279 { "level", "set level", OFFSET(level), AV_OPT_TYPE_INT, {.i64 = 6}, 2, 8, FLAGS }, 280 COMMON_OPTIONS_NOSIZE 281 { NULL } 282}; 283 284AVFILTER_DEFINE_CLASS(haldclutsrc); 285 286static void haldclutsrc_fill_picture(AVFilterContext *ctx, AVFrame *frame) 287{ 288 int i, j, k, x = 0, y = 0, is16bit = 0, step; 289 uint32_t alpha = 0; 290 const TestSourceContext *hc = ctx->priv; 291 int level = hc->level; 292 float scale; 293 const int w = frame->width; 294 const int h = frame->height; 295 const uint8_t *data = frame->data[0]; 296 const int linesize = frame->linesize[0]; 297 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format); 298 uint8_t rgba_map[4]; 299 300 av_assert0(w == h && w == level*level*level); 301 302 ff_fill_rgba_map(rgba_map, frame->format); 303 304 switch (frame->format) { 305 case AV_PIX_FMT_RGB48: 306 case AV_PIX_FMT_BGR48: 307 case AV_PIX_FMT_RGBA64: 308 case AV_PIX_FMT_BGRA64: 309 is16bit = 1; 310 alpha = 0xffff; 311 break; 312 case AV_PIX_FMT_RGBA: 313 case AV_PIX_FMT_BGRA: 314 case AV_PIX_FMT_ARGB: 315 case AV_PIX_FMT_ABGR: 316 alpha = 0xff; 317 break; 318 } 319 320 step = av_get_padded_bits_per_pixel(desc) >> (3 + is16bit); 321 scale = ((float)(1 << (8*(is16bit+1))) - 1) / (level*level - 1); 322 323#define LOAD_CLUT(nbits) do { \ 324 uint##nbits##_t *dst = ((uint##nbits##_t *)(data + y*linesize)) + x*step; \ 325 dst[rgba_map[0]] = av_clip_uint##nbits(i * scale); \ 326 dst[rgba_map[1]] = av_clip_uint##nbits(j * scale); \ 327 dst[rgba_map[2]] = av_clip_uint##nbits(k * scale); \ 328 if (step == 4) \ 329 dst[rgba_map[3]] = alpha; \ 330} while (0) 331 332 level *= level; 333 for (k = 0; k < level; k++) { 334 for (j = 0; j < level; j++) { 335 for (i = 0; i < level; i++) { 336 if (!is16bit) 337 LOAD_CLUT(8); 338 else 339 LOAD_CLUT(16); 340 if (++x == w) { 341 x = 0; 342 y++; 343 } 344 } 345 } 346 } 347} 348 349static av_cold int haldclutsrc_init(AVFilterContext *ctx) 350{ 351 TestSourceContext *hc = ctx->priv; 352 hc->fill_picture_fn = haldclutsrc_fill_picture; 353 hc->draw_once = 1; 354 return init(ctx); 355} 356 357static int haldclutsrc_query_formats(AVFilterContext *ctx) 358{ 359 static const enum AVPixelFormat pix_fmts[] = { 360 AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24, 361 AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA, 362 AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR, 363 AV_PIX_FMT_0RGB, AV_PIX_FMT_0BGR, 364 AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0, 365 AV_PIX_FMT_RGB48, AV_PIX_FMT_BGR48, 366 AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64, 367 AV_PIX_FMT_NONE, 368 }; 369 ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); 370 return 0; 371} 372 373static int haldclutsrc_config_props(AVFilterLink *outlink) 374{ 375 AVFilterContext *ctx = outlink->src; 376 TestSourceContext *hc = ctx->priv; 377 378 hc->w = hc->h = hc->level * hc->level * hc->level; 379 return config_props(outlink); 380} 381 382static const AVFilterPad haldclutsrc_outputs[] = { 383 { 384 .name = "default", 385 .type = AVMEDIA_TYPE_VIDEO, 386 .request_frame = request_frame, 387 .config_props = haldclutsrc_config_props, 388 }, 389 { NULL } 390}; 391 392AVFilter ff_vsrc_haldclutsrc = { 393 .name = "haldclutsrc", 394 .description = NULL_IF_CONFIG_SMALL("Provide an identity Hald CLUT."), 395 .priv_class = &haldclutsrc_class, 396 .priv_size = sizeof(TestSourceContext), 397 .init = haldclutsrc_init, 398 .uninit = uninit, 399 .query_formats = haldclutsrc_query_formats, 400 .inputs = NULL, 401 .outputs = haldclutsrc_outputs, 402}; 403#endif /* CONFIG_HALDCLUTSRC_FILTER */ 404 405#if CONFIG_NULLSRC_FILTER 406 407#define nullsrc_options options 408AVFILTER_DEFINE_CLASS(nullsrc); 409 410static void nullsrc_fill_picture(AVFilterContext *ctx, AVFrame *picref) { } 411 412static av_cold int nullsrc_init(AVFilterContext *ctx) 413{ 414 TestSourceContext *test = ctx->priv; 415 416 test->fill_picture_fn = nullsrc_fill_picture; 417 return init(ctx); 418} 419 420static const AVFilterPad nullsrc_outputs[] = { 421 { 422 .name = "default", 423 .type = AVMEDIA_TYPE_VIDEO, 424 .request_frame = request_frame, 425 .config_props = config_props, 426 }, 427 { NULL }, 428}; 429 430AVFilter ff_vsrc_nullsrc = { 431 .name = "nullsrc", 432 .description = NULL_IF_CONFIG_SMALL("Null video source, return unprocessed video frames."), 433 .init = nullsrc_init, 434 .uninit = uninit, 435 .priv_size = sizeof(TestSourceContext), 436 .priv_class = &nullsrc_class, 437 .inputs = NULL, 438 .outputs = nullsrc_outputs, 439}; 440 441#endif /* CONFIG_NULLSRC_FILTER */ 442 443#if CONFIG_TESTSRC_FILTER 444 445static const AVOption testsrc_options[] = { 446 COMMON_OPTIONS 447 { "decimals", "set number of decimals to show", OFFSET(nb_decimals), AV_OPT_TYPE_INT, {.i64=0}, 0, 17, FLAGS }, 448 { "n", "set number of decimals to show", OFFSET(nb_decimals), AV_OPT_TYPE_INT, {.i64=0}, 0, 17, FLAGS }, 449 { NULL } 450}; 451 452AVFILTER_DEFINE_CLASS(testsrc); 453 454/** 455 * Fill a rectangle with value val. 456 * 457 * @param val the RGB value to set 458 * @param dst pointer to the destination buffer to fill 459 * @param dst_linesize linesize of destination 460 * @param segment_width width of the segment 461 * @param x horizontal coordinate where to draw the rectangle in the destination buffer 462 * @param y horizontal coordinate where to draw the rectangle in the destination buffer 463 * @param w width of the rectangle to draw, expressed as a number of segment_width units 464 * @param h height of the rectangle to draw, expressed as a number of segment_width units 465 */ 466static void draw_rectangle(unsigned val, uint8_t *dst, int dst_linesize, int segment_width, 467 int x, int y, int w, int h) 468{ 469 int i; 470 int step = 3; 471 472 dst += segment_width * (step * x + y * dst_linesize); 473 w *= segment_width * step; 474 h *= segment_width; 475 for (i = 0; i < h; i++) { 476 memset(dst, val, w); 477 dst += dst_linesize; 478 } 479} 480 481static void draw_digit(int digit, uint8_t *dst, int dst_linesize, 482 int segment_width) 483{ 484#define TOP_HBAR 1 485#define MID_HBAR 2 486#define BOT_HBAR 4 487#define LEFT_TOP_VBAR 8 488#define LEFT_BOT_VBAR 16 489#define RIGHT_TOP_VBAR 32 490#define RIGHT_BOT_VBAR 64 491 struct segments { 492 int x, y, w, h; 493 } segments[] = { 494 { 1, 0, 5, 1 }, /* TOP_HBAR */ 495 { 1, 6, 5, 1 }, /* MID_HBAR */ 496 { 1, 12, 5, 1 }, /* BOT_HBAR */ 497 { 0, 1, 1, 5 }, /* LEFT_TOP_VBAR */ 498 { 0, 7, 1, 5 }, /* LEFT_BOT_VBAR */ 499 { 6, 1, 1, 5 }, /* RIGHT_TOP_VBAR */ 500 { 6, 7, 1, 5 } /* RIGHT_BOT_VBAR */ 501 }; 502 static const unsigned char masks[10] = { 503 /* 0 */ TOP_HBAR |BOT_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR, 504 /* 1 */ RIGHT_TOP_VBAR|RIGHT_BOT_VBAR, 505 /* 2 */ TOP_HBAR|MID_HBAR|BOT_HBAR|LEFT_BOT_VBAR |RIGHT_TOP_VBAR, 506 /* 3 */ TOP_HBAR|MID_HBAR|BOT_HBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR, 507 /* 4 */ MID_HBAR |LEFT_TOP_VBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR, 508 /* 5 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR |RIGHT_BOT_VBAR, 509 /* 6 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR |RIGHT_BOT_VBAR, 510 /* 7 */ TOP_HBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR, 511 /* 8 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR, 512 /* 9 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR, 513 }; 514 unsigned mask = masks[digit]; 515 int i; 516 517 draw_rectangle(0, dst, dst_linesize, segment_width, 0, 0, 8, 13); 518 for (i = 0; i < FF_ARRAY_ELEMS(segments); i++) 519 if (mask & (1<<i)) 520 draw_rectangle(255, dst, dst_linesize, segment_width, 521 segments[i].x, segments[i].y, segments[i].w, segments[i].h); 522} 523 524#define GRADIENT_SIZE (6 * 256) 525 526static void test_fill_picture(AVFilterContext *ctx, AVFrame *frame) 527{ 528 TestSourceContext *test = ctx->priv; 529 uint8_t *p, *p0; 530 int x, y; 531 int color, color_rest; 532 int icolor; 533 int radius; 534 int quad0, quad; 535 int dquad_x, dquad_y; 536 int grad, dgrad, rgrad, drgrad; 537 int seg_size; 538 int second; 539 int i; 540 uint8_t *data = frame->data[0]; 541 int width = frame->width; 542 int height = frame->height; 543 544 /* draw colored bars and circle */ 545 radius = (width + height) / 4; 546 quad0 = width * width / 4 + height * height / 4 - radius * radius; 547 dquad_y = 1 - height; 548 p0 = data; 549 for (y = 0; y < height; y++) { 550 p = p0; 551 color = 0; 552 color_rest = 0; 553 quad = quad0; 554 dquad_x = 1 - width; 555 for (x = 0; x < width; x++) { 556 icolor = color; 557 if (quad < 0) 558 icolor ^= 7; 559 quad += dquad_x; 560 dquad_x += 2; 561 *(p++) = icolor & 1 ? 255 : 0; 562 *(p++) = icolor & 2 ? 255 : 0; 563 *(p++) = icolor & 4 ? 255 : 0; 564 color_rest += 8; 565 if (color_rest >= width) { 566 color_rest -= width; 567 color++; 568 } 569 } 570 quad0 += dquad_y; 571 dquad_y += 2; 572 p0 += frame->linesize[0]; 573 } 574 575 /* draw sliding color line */ 576 p0 = p = data + frame->linesize[0] * (height * 3/4); 577 grad = (256 * test->nb_frame * test->time_base.num / test->time_base.den) % 578 GRADIENT_SIZE; 579 rgrad = 0; 580 dgrad = GRADIENT_SIZE / width; 581 drgrad = GRADIENT_SIZE % width; 582 for (x = 0; x < width; x++) { 583 *(p++) = 584 grad < 256 || grad >= 5 * 256 ? 255 : 585 grad >= 2 * 256 && grad < 4 * 256 ? 0 : 586 grad < 2 * 256 ? 2 * 256 - 1 - grad : grad - 4 * 256; 587 *(p++) = 588 grad >= 4 * 256 ? 0 : 589 grad >= 1 * 256 && grad < 3 * 256 ? 255 : 590 grad < 1 * 256 ? grad : 4 * 256 - 1 - grad; 591 *(p++) = 592 grad < 2 * 256 ? 0 : 593 grad >= 3 * 256 && grad < 5 * 256 ? 255 : 594 grad < 3 * 256 ? grad - 2 * 256 : 6 * 256 - 1 - grad; 595 grad += dgrad; 596 rgrad += drgrad; 597 if (rgrad >= GRADIENT_SIZE) { 598 grad++; 599 rgrad -= GRADIENT_SIZE; 600 } 601 if (grad >= GRADIENT_SIZE) 602 grad -= GRADIENT_SIZE; 603 } 604 p = p0; 605 for (y = height / 8; y > 0; y--) { 606 memcpy(p+frame->linesize[0], p, 3 * width); 607 p += frame->linesize[0]; 608 } 609 610 /* draw digits */ 611 seg_size = width / 80; 612 if (seg_size >= 1 && height >= 13 * seg_size) { 613 int64_t p10decimals = 1; 614 double time = av_q2d(test->time_base) * test->nb_frame * 615 pow(10, test->nb_decimals); 616 if (time >= INT_MAX) 617 return; 618 619 for (x = 0; x < test->nb_decimals; x++) 620 p10decimals *= 10; 621 622 second = av_rescale_rnd(test->nb_frame * test->time_base.num, p10decimals, test->time_base.den, AV_ROUND_ZERO); 623 x = width - (width - seg_size * 64) / 2; 624 y = (height - seg_size * 13) / 2; 625 p = data + (x*3 + y * frame->linesize[0]); 626 for (i = 0; i < 8; i++) { 627 p -= 3 * 8 * seg_size; 628 draw_digit(second % 10, p, frame->linesize[0], seg_size); 629 second /= 10; 630 if (second == 0) 631 break; 632 } 633 } 634} 635 636static av_cold int test_init(AVFilterContext *ctx) 637{ 638 TestSourceContext *test = ctx->priv; 639 640 test->fill_picture_fn = test_fill_picture; 641 return init(ctx); 642} 643 644static int test_query_formats(AVFilterContext *ctx) 645{ 646 static const enum AVPixelFormat pix_fmts[] = { 647 AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE 648 }; 649 ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); 650 return 0; 651} 652 653static const AVFilterPad avfilter_vsrc_testsrc_outputs[] = { 654 { 655 .name = "default", 656 .type = AVMEDIA_TYPE_VIDEO, 657 .request_frame = request_frame, 658 .config_props = config_props, 659 }, 660 { NULL } 661}; 662 663AVFilter ff_vsrc_testsrc = { 664 .name = "testsrc", 665 .description = NULL_IF_CONFIG_SMALL("Generate test pattern."), 666 .priv_size = sizeof(TestSourceContext), 667 .priv_class = &testsrc_class, 668 .init = test_init, 669 .uninit = uninit, 670 .query_formats = test_query_formats, 671 .inputs = NULL, 672 .outputs = avfilter_vsrc_testsrc_outputs, 673}; 674 675#endif /* CONFIG_TESTSRC_FILTER */ 676 677#if CONFIG_RGBTESTSRC_FILTER 678 679#define rgbtestsrc_options options 680AVFILTER_DEFINE_CLASS(rgbtestsrc); 681 682#define R 0 683#define G 1 684#define B 2 685#define A 3 686 687static void rgbtest_put_pixel(uint8_t *dst, int dst_linesize, 688 int x, int y, int r, int g, int b, enum AVPixelFormat fmt, 689 uint8_t rgba_map[4]) 690{ 691 int32_t v; 692 uint8_t *p; 693 694 switch (fmt) { 695 case AV_PIX_FMT_BGR444: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r >> 4) << 8) | ((g >> 4) << 4) | (b >> 4); break; 696 case AV_PIX_FMT_RGB444: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b >> 4) << 8) | ((g >> 4) << 4) | (r >> 4); break; 697 case AV_PIX_FMT_BGR555: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r>>3)<<10) | ((g>>3)<<5) | (b>>3); break; 698 case AV_PIX_FMT_RGB555: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b>>3)<<10) | ((g>>3)<<5) | (r>>3); break; 699 case AV_PIX_FMT_BGR565: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r>>3)<<11) | ((g>>2)<<5) | (b>>3); break; 700 case AV_PIX_FMT_RGB565: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b>>3)<<11) | ((g>>2)<<5) | (r>>3); break; 701 case AV_PIX_FMT_RGB24: 702 case AV_PIX_FMT_BGR24: 703 v = (r << (rgba_map[R]*8)) + (g << (rgba_map[G]*8)) + (b << (rgba_map[B]*8)); 704 p = dst + 3*x + y*dst_linesize; 705 AV_WL24(p, v); 706 break; 707 case AV_PIX_FMT_RGBA: 708 case AV_PIX_FMT_BGRA: 709 case AV_PIX_FMT_ARGB: 710 case AV_PIX_FMT_ABGR: 711 v = (r << (rgba_map[R]*8)) + (g << (rgba_map[G]*8)) + (b << (rgba_map[B]*8)) + (255 << (rgba_map[A]*8)); 712 p = dst + 4*x + y*dst_linesize; 713 AV_WL32(p, v); 714 break; 715 } 716} 717 718static void rgbtest_fill_picture(AVFilterContext *ctx, AVFrame *frame) 719{ 720 TestSourceContext *test = ctx->priv; 721 int x, y, w = frame->width, h = frame->height; 722 723 for (y = 0; y < h; y++) { 724 for (x = 0; x < w; x++) { 725 int c = 256*x/w; 726 int r = 0, g = 0, b = 0; 727 728 if (3*y < h ) r = c; 729 else if (3*y < 2*h) g = c; 730 else b = c; 731 732 rgbtest_put_pixel(frame->data[0], frame->linesize[0], x, y, r, g, b, 733 ctx->outputs[0]->format, test->rgba_map); 734 } 735 } 736} 737 738static av_cold int rgbtest_init(AVFilterContext *ctx) 739{ 740 TestSourceContext *test = ctx->priv; 741 742 test->draw_once = 1; 743 test->fill_picture_fn = rgbtest_fill_picture; 744 return init(ctx); 745} 746 747static int rgbtest_query_formats(AVFilterContext *ctx) 748{ 749 static const enum AVPixelFormat pix_fmts[] = { 750 AV_PIX_FMT_RGBA, AV_PIX_FMT_ARGB, AV_PIX_FMT_BGRA, AV_PIX_FMT_ABGR, 751 AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24, 752 AV_PIX_FMT_RGB444, AV_PIX_FMT_BGR444, 753 AV_PIX_FMT_RGB565, AV_PIX_FMT_BGR565, 754 AV_PIX_FMT_RGB555, AV_PIX_FMT_BGR555, 755 AV_PIX_FMT_NONE 756 }; 757 ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); 758 return 0; 759} 760 761static int rgbtest_config_props(AVFilterLink *outlink) 762{ 763 TestSourceContext *test = outlink->src->priv; 764 765 ff_fill_rgba_map(test->rgba_map, outlink->format); 766 return config_props(outlink); 767} 768 769static const AVFilterPad avfilter_vsrc_rgbtestsrc_outputs[] = { 770 { 771 .name = "default", 772 .type = AVMEDIA_TYPE_VIDEO, 773 .request_frame = request_frame, 774 .config_props = rgbtest_config_props, 775 }, 776 { NULL } 777}; 778 779AVFilter ff_vsrc_rgbtestsrc = { 780 .name = "rgbtestsrc", 781 .description = NULL_IF_CONFIG_SMALL("Generate RGB test pattern."), 782 .priv_size = sizeof(TestSourceContext), 783 .priv_class = &rgbtestsrc_class, 784 .init = rgbtest_init, 785 .uninit = uninit, 786 .query_formats = rgbtest_query_formats, 787 .inputs = NULL, 788 .outputs = avfilter_vsrc_rgbtestsrc_outputs, 789}; 790 791#endif /* CONFIG_RGBTESTSRC_FILTER */ 792 793#if CONFIG_SMPTEBARS_FILTER || CONFIG_SMPTEHDBARS_FILTER 794 795static const uint8_t rainbow[7][4] = { 796 { 180, 128, 128, 255 }, /* gray */ 797 { 168, 44, 136, 255 }, /* yellow */ 798 { 145, 147, 44, 255 }, /* cyan */ 799 { 133, 63, 52, 255 }, /* green */ 800 { 63, 193, 204, 255 }, /* magenta */ 801 { 51, 109, 212, 255 }, /* red */ 802 { 28, 212, 120, 255 }, /* blue */ 803}; 804 805static const uint8_t wobnair[7][4] = { 806 { 32, 240, 118, 255 }, /* blue */ 807 { 19, 128, 128, 255 }, /* 7.5% intensity black */ 808 { 54, 184, 198, 255 }, /* magenta */ 809 { 19, 128, 128, 255 }, /* 7.5% intensity black */ 810 { 188, 154, 16, 255 }, /* cyan */ 811 { 19, 128, 128, 255 }, /* 7.5% intensity black */ 812 { 191, 128, 128, 255 }, /* gray */ 813}; 814 815static const uint8_t white[4] = { 235, 128, 128, 255 }; 816static const uint8_t black[4] = { 19, 128, 128, 255 }; /* 7.5% intensity black */ 817 818/* pluge pulses */ 819static const uint8_t neg4ire[4] = { 9, 128, 128, 255 }; /* 3.5% intensity black */ 820static const uint8_t pos4ire[4] = { 29, 128, 128, 255 }; /* 11.5% intensity black */ 821 822/* fudged Q/-I */ 823static const uint8_t i_pixel[4] = { 61, 153, 99, 255 }; 824static const uint8_t q_pixel[4] = { 35, 174, 152, 255 }; 825 826static const uint8_t gray40[4] = { 104, 128, 128, 255 }; 827static const uint8_t gray15[4] = { 49, 128, 128, 255 }; 828static const uint8_t cyan[4] = { 188, 154, 16, 255 }; 829static const uint8_t yellow[4] = { 219, 16, 138, 255 }; 830static const uint8_t blue[4] = { 32, 240, 118, 255 }; 831static const uint8_t red[4] = { 63, 102, 240, 255 }; 832static const uint8_t black0[4] = { 16, 128, 128, 255 }; 833static const uint8_t black2[4] = { 20, 128, 128, 255 }; 834static const uint8_t black4[4] = { 25, 128, 128, 255 }; 835static const uint8_t neg2[4] = { 12, 128, 128, 255 }; 836 837static void draw_bar(TestSourceContext *test, const uint8_t color[4], 838 unsigned x, unsigned y, unsigned w, unsigned h, 839 AVFrame *frame) 840{ 841 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format); 842 uint8_t *p, *p0; 843 int plane; 844 845 x = FFMIN(x, test->w - 1); 846 y = FFMIN(y, test->h - 1); 847 w = FFMIN(w, test->w - x); 848 h = FFMIN(h, test->h - y); 849 850 av_assert0(x + w <= test->w); 851 av_assert0(y + h <= test->h); 852 853 for (plane = 0; frame->data[plane]; plane++) { 854 const int c = color[plane]; 855 const int linesize = frame->linesize[plane]; 856 int i, px, py, pw, ph; 857 858 if (plane == 1 || plane == 2) { 859 px = x >> desc->log2_chroma_w; 860 pw = w >> desc->log2_chroma_w; 861 py = y >> desc->log2_chroma_h; 862 ph = h >> desc->log2_chroma_h; 863 } else { 864 px = x; 865 pw = w; 866 py = y; 867 ph = h; 868 } 869 870 p0 = p = frame->data[plane] + py * linesize + px; 871 memset(p, c, pw); 872 p += linesize; 873 for (i = 1; i < ph; i++, p += linesize) 874 memcpy(p, p0, pw); 875 } 876} 877 878static int smptebars_query_formats(AVFilterContext *ctx) 879{ 880 static const enum AVPixelFormat pix_fmts[] = { 881 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, 882 AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P, 883 AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, 884 AV_PIX_FMT_NONE, 885 }; 886 ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); 887 return 0; 888} 889 890static const AVFilterPad smptebars_outputs[] = { 891 { 892 .name = "default", 893 .type = AVMEDIA_TYPE_VIDEO, 894 .request_frame = request_frame, 895 .config_props = config_props, 896 }, 897 { NULL } 898}; 899 900#if CONFIG_SMPTEBARS_FILTER 901 902#define smptebars_options options 903AVFILTER_DEFINE_CLASS(smptebars); 904 905static void smptebars_fill_picture(AVFilterContext *ctx, AVFrame *picref) 906{ 907 TestSourceContext *test = ctx->priv; 908 int r_w, r_h, w_h, p_w, p_h, i, tmp, x = 0; 909 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format); 910 911 av_frame_set_colorspace(picref, AVCOL_SPC_BT470BG); 912 913 r_w = FFALIGN((test->w + 6) / 7, 1 << pixdesc->log2_chroma_w); 914 r_h = FFALIGN(test->h * 2 / 3, 1 << pixdesc->log2_chroma_h); 915 w_h = FFALIGN(test->h * 3 / 4 - r_h, 1 << pixdesc->log2_chroma_h); 916 p_w = FFALIGN(r_w * 5 / 4, 1 << pixdesc->log2_chroma_w); 917 p_h = test->h - w_h - r_h; 918 919 for (i = 0; i < 7; i++) { 920 draw_bar(test, rainbow[i], x, 0, r_w, r_h, picref); 921 draw_bar(test, wobnair[i], x, r_h, r_w, w_h, picref); 922 x += r_w; 923 } 924 x = 0; 925 draw_bar(test, i_pixel, x, r_h + w_h, p_w, p_h, picref); 926 x += p_w; 927 draw_bar(test, white, x, r_h + w_h, p_w, p_h, picref); 928 x += p_w; 929 draw_bar(test, q_pixel, x, r_h + w_h, p_w, p_h, picref); 930 x += p_w; 931 tmp = FFALIGN(5 * r_w - x, 1 << pixdesc->log2_chroma_w); 932 draw_bar(test, black, x, r_h + w_h, tmp, p_h, picref); 933 x += tmp; 934 tmp = FFALIGN(r_w / 3, 1 << pixdesc->log2_chroma_w); 935 draw_bar(test, neg4ire, x, r_h + w_h, tmp, p_h, picref); 936 x += tmp; 937 draw_bar(test, black, x, r_h + w_h, tmp, p_h, picref); 938 x += tmp; 939 draw_bar(test, pos4ire, x, r_h + w_h, tmp, p_h, picref); 940 x += tmp; 941 draw_bar(test, black, x, r_h + w_h, test->w - x, p_h, picref); 942} 943 944static av_cold int smptebars_init(AVFilterContext *ctx) 945{ 946 TestSourceContext *test = ctx->priv; 947 948 test->fill_picture_fn = smptebars_fill_picture; 949 test->draw_once = 1; 950 return init(ctx); 951} 952 953AVFilter ff_vsrc_smptebars = { 954 .name = "smptebars", 955 .description = NULL_IF_CONFIG_SMALL("Generate SMPTE color bars."), 956 .priv_size = sizeof(TestSourceContext), 957 .priv_class = &smptebars_class, 958 .init = smptebars_init, 959 .uninit = uninit, 960 .query_formats = smptebars_query_formats, 961 .inputs = NULL, 962 .outputs = smptebars_outputs, 963}; 964 965#endif /* CONFIG_SMPTEBARS_FILTER */ 966 967#if CONFIG_SMPTEHDBARS_FILTER 968 969#define smptehdbars_options options 970AVFILTER_DEFINE_CLASS(smptehdbars); 971 972static void smptehdbars_fill_picture(AVFilterContext *ctx, AVFrame *picref) 973{ 974 TestSourceContext *test = ctx->priv; 975 int d_w, r_w, r_h, l_w, i, tmp, x = 0, y = 0; 976 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format); 977 978 av_frame_set_colorspace(picref, AVCOL_SPC_BT709); 979 980 d_w = FFALIGN(test->w / 8, 1 << pixdesc->log2_chroma_w); 981 r_h = FFALIGN(test->h * 7 / 12, 1 << pixdesc->log2_chroma_h); 982 draw_bar(test, gray40, x, 0, d_w, r_h, picref); 983 x += d_w; 984 985 r_w = FFALIGN((((test->w + 3) / 4) * 3) / 7, 1 << pixdesc->log2_chroma_w); 986 for (i = 0; i < 7; i++) { 987 draw_bar(test, rainbow[i], x, 0, r_w, r_h, picref); 988 x += r_w; 989 } 990 draw_bar(test, gray40, x, 0, test->w - x, r_h, picref); 991 y = r_h; 992 r_h = FFALIGN(test->h / 12, 1 << pixdesc->log2_chroma_h); 993 draw_bar(test, cyan, 0, y, d_w, r_h, picref); 994 x = d_w; 995 draw_bar(test, i_pixel, x, y, r_w, r_h, picref); 996 x += r_w; 997 tmp = r_w * 6; 998 draw_bar(test, rainbow[0], x, y, tmp, r_h, picref); 999 x += tmp; 1000 l_w = x; 1001 draw_bar(test, blue, x, y, test->w - x, r_h, picref); 1002 y += r_h; 1003 draw_bar(test, yellow, 0, y, d_w, r_h, picref); 1004 x = d_w; 1005 draw_bar(test, q_pixel, x, y, r_w, r_h, picref); 1006 x += r_w; 1007 1008 for (i = 0; i < tmp; i += 1 << pixdesc->log2_chroma_w) { 1009 uint8_t yramp[4] = {0}; 1010 1011 yramp[0] = i * 255 / tmp; 1012 yramp[1] = 128; 1013 yramp[2] = 128; 1014 yramp[3] = 255; 1015 1016 draw_bar(test, yramp, x, y, 1 << pixdesc->log2_chroma_w, r_h, picref); 1017 x += 1 << pixdesc->log2_chroma_w; 1018 } 1019 draw_bar(test, red, x, y, test->w - x, r_h, picref); 1020 y += r_h; 1021 draw_bar(test, gray15, 0, y, d_w, test->h - y, picref); 1022 x = d_w; 1023 tmp = FFALIGN(r_w * 3 / 2, 1 << pixdesc->log2_chroma_w); 1024 draw_bar(test, black0, x, y, tmp, test->h - y, picref); 1025 x += tmp; 1026 tmp = FFALIGN(r_w * 2, 1 << pixdesc->log2_chroma_w); 1027 draw_bar(test, white, x, y, tmp, test->h - y, picref); 1028 x += tmp; 1029 tmp = FFALIGN(r_w * 5 / 6, 1 << pixdesc->log2_chroma_w); 1030 draw_bar(test, black0, x, y, tmp, test->h - y, picref); 1031 x += tmp; 1032 tmp = FFALIGN(r_w / 3, 1 << pixdesc->log2_chroma_w); 1033 draw_bar(test, neg2, x, y, tmp, test->h - y, picref); 1034 x += tmp; 1035 draw_bar(test, black0, x, y, tmp, test->h - y, picref); 1036 x += tmp; 1037 draw_bar(test, black2, x, y, tmp, test->h - y, picref); 1038 x += tmp; 1039 draw_bar(test, black0, x, y, tmp, test->h - y, picref); 1040 x += tmp; 1041 draw_bar(test, black4, x, y, tmp, test->h - y, picref); 1042 x += tmp; 1043 r_w = l_w - x; 1044 draw_bar(test, black0, x, y, r_w, test->h - y, picref); 1045 x += r_w; 1046 draw_bar(test, gray15, x, y, test->w - x, test->h - y, picref); 1047} 1048 1049static av_cold int smptehdbars_init(AVFilterContext *ctx) 1050{ 1051 TestSourceContext *test = ctx->priv; 1052 1053 test->fill_picture_fn = smptehdbars_fill_picture; 1054 test->draw_once = 1; 1055 return init(ctx); 1056} 1057 1058AVFilter ff_vsrc_smptehdbars = { 1059 .name = "smptehdbars", 1060 .description = NULL_IF_CONFIG_SMALL("Generate SMPTE HD color bars."), 1061 .priv_size = sizeof(TestSourceContext), 1062 .priv_class = &smptehdbars_class, 1063 .init = smptehdbars_init, 1064 .uninit = uninit, 1065 .query_formats = smptebars_query_formats, 1066 .inputs = NULL, 1067 .outputs = smptebars_outputs, 1068}; 1069 1070#endif /* CONFIG_SMPTEHDBARS_FILTER */ 1071#endif /* CONFIG_SMPTEBARS_FILTER || CONFIG_SMPTEHDBARS_FILTER */ 1072