falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
99787 Commits
32 Branches
850MB
Tree: 5d1238f77f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5d1238f77f'
${ noResults }
FFmpeg/libavfilter/vsrc_testsrc.c

1815 lines
56KB
Raw Blame History 

  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 "filters.h"

  49. #include "formats.h"

  50. #include "internal.h"

  51. #include "video.h"

  52. 

  53. typedef struct TestSourceContext {

  54.     const AVClass *class;

  55.     int w, h;

  56.     unsigned int nb_frame;

  57.     AVRational time_base, frame_rate;

  58.     int64_t pts;

  59.     int64_t duration;           ///< duration expressed in microseconds

  60.     AVRational sar;             ///< sample aspect ratio

  61.     int draw_once;              ///< draw only the first frame, always put out the same picture

  62.     int draw_once_reset;        ///< draw only the first frame or in case of reset

  63.     AVFrame *picref;            ///< cached reference containing the painted picture

  64. 

  65.     void (* fill_picture_fn)(AVFilterContext *ctx, AVFrame *frame);

  66. 

  67.     /* only used by testsrc */

  68.     int nb_decimals;

  69. 

  70.     /* only used by testsrc2 */

  71.     int alpha;

  72. 

  73.     /* only used by color */

  74.     FFDrawContext draw;

  75.     FFDrawColor color;

  76.     uint8_t color_rgba[4];

  77. 

  78.     /* only used by rgbtest */

  79.     uint8_t rgba_map[4];

  80. 

  81.     /* only used by haldclut */

  82.     int level;

  83. } TestSourceContext;

  84. 

  85. #define OFFSET(x) offsetof(TestSourceContext, x)

  86. #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

  87. #define FLAGSR AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM

  88. 

  89. #define SIZE_OPTIONS \

  90.     { "size",     "set video size",     OFFSET(w),        AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },\

  91.     { "s",        "set video size",     OFFSET(w),        AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },\

  92. 

  93. #define COMMON_OPTIONS_NOSIZE \

  94.     { "rate",     "set video rate",     OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },\

  95.     { "r",        "set video rate",     OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },\

  96.     { "duration", "set video duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },\

  97.     { "d",        "set video duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },\

  98.     { "sar",      "set video sample aspect ratio", OFFSET(sar), AV_OPT_TYPE_RATIONAL, {.dbl= 1},  0, INT_MAX, FLAGS },

  99. 

  100. #define COMMON_OPTIONS SIZE_OPTIONS COMMON_OPTIONS_NOSIZE

  101. 

  102. static const AVOption options[] = {

  103.     COMMON_OPTIONS

  104.     { NULL }

  105. };

  106. 

  107. static av_cold int init(AVFilterContext *ctx)

  108. {

  109.     TestSourceContext *test = ctx->priv;

  110. 

  111.     test->time_base = av_inv_q(test->frame_rate);

  112.     test->nb_frame = 0;

  113.     test->pts = 0;

  114. 

  115.     av_log(ctx, AV_LOG_VERBOSE, "size:%dx%d rate:%d/%d duration:%f sar:%d/%d\n",

  116.            test->w, test->h, test->frame_rate.num, test->frame_rate.den,

  117.            test->duration < 0 ? -1 : (double)test->duration/1000000,

  118.            test->sar.num, test->sar.den);

  119.     return 0;

  120. }

  121. 

  122. static av_cold void uninit(AVFilterContext *ctx)

  123. {

  124.     TestSourceContext *test = ctx->priv;

  125. 

  126.     av_frame_free(&test->picref);

  127. }

  128. 

  129. static int config_props(AVFilterLink *outlink)

  130. {

  131.     TestSourceContext *test = outlink->src->priv;

  132. 

  133.     outlink->w = test->w;

  134.     outlink->h = test->h;

  135.     outlink->sample_aspect_ratio = test->sar;

  136.     outlink->frame_rate = test->frame_rate;

  137.     outlink->time_base  = test->time_base;

  138. 

  139.     return 0;

  140. }

  141. 

  142. static int activate(AVFilterContext *ctx)

  143. {

  144.     AVFilterLink *outlink = ctx->outputs[0];

  145.     TestSourceContext *test = ctx->priv;

  146.     AVFrame *frame;

  147. 

  148.     if (!ff_outlink_frame_wanted(outlink))

  149.         return FFERROR_NOT_READY;

  150.     if (test->duration >= 0 &&

  151.         av_rescale_q(test->pts, test->time_base, AV_TIME_BASE_Q) >= test->duration) {

  152.         ff_outlink_set_status(outlink, AVERROR_EOF, test->pts);

  153.         return 0;

  154.     }

  155. 

  156.     if (test->draw_once) {

  157.         if (test->draw_once_reset) {

  158.             av_frame_free(&test->picref);

  159.             test->draw_once_reset = 0;

  160.         }

  161.         if (!test->picref) {

  162.             test->picref =

  163.                 ff_get_video_buffer(outlink, test->w, test->h);

  164.             if (!test->picref)

  165.                 return AVERROR(ENOMEM);

  166.             test->fill_picture_fn(outlink->src, test->picref);

  167.         }

  168.         frame = av_frame_clone(test->picref);

  169.     } else

  170.         frame = ff_get_video_buffer(outlink, test->w, test->h);

  171. 

  172.     if (!frame)

  173.         return AVERROR(ENOMEM);

  174.     frame->pts                 = test->pts;

  175.     frame->key_frame           = 1;

  176.     frame->interlaced_frame    = 0;

  177.     frame->pict_type           = AV_PICTURE_TYPE_I;

  178.     frame->sample_aspect_ratio = test->sar;

  179.     if (!test->draw_once)

  180.         test->fill_picture_fn(outlink->src, frame);

  181. 

  182.     test->pts++;

  183.     test->nb_frame++;

  184. 

  185.     return ff_filter_frame(outlink, frame);

  186. }

  187. 

  188. #if CONFIG_COLOR_FILTER

  189. 

  190. static const AVOption color_options[] = {

  191.     { "color", "set color", OFFSET(color_rgba), AV_OPT_TYPE_COLOR, {.str = "black"}, 0, 0, FLAGSR },

  192.     { "c",     "set color", OFFSET(color_rgba), AV_OPT_TYPE_COLOR, {.str = "black"}, 0, 0, FLAGSR },

  193.     COMMON_OPTIONS

  194.     { NULL }

  195. };

  196. 

  197. AVFILTER_DEFINE_CLASS(color);

  198. 

  199. static void color_fill_picture(AVFilterContext *ctx, AVFrame *picref)

  200. {

  201.     TestSourceContext *test = ctx->priv;

  202.     ff_fill_rectangle(&test->draw, &test->color,

  203.                       picref->data, picref->linesize,

  204.                       0, 0, test->w, test->h);

  205. }

  206. 

  207. static av_cold int color_init(AVFilterContext *ctx)

  208. {

  209.     TestSourceContext *test = ctx->priv;

  210.     test->fill_picture_fn = color_fill_picture;

  211.     test->draw_once = 1;

  212.     return init(ctx);

  213. }

  214. 

  215. static int color_query_formats(AVFilterContext *ctx)

  216. {

  217.     return ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));

  218. }

  219. 

  220. static int color_config_props(AVFilterLink *inlink)

  221. {

  222.     AVFilterContext *ctx = inlink->src;

  223.     TestSourceContext *test = ctx->priv;

  224.     int ret;

  225. 

  226.     ff_draw_init(&test->draw, inlink->format, 0);

  227.     ff_draw_color(&test->draw, &test->color, test->color_rgba);

  228. 

  229.     test->w = ff_draw_round_to_sub(&test->draw, 0, -1, test->w);

  230.     test->h = ff_draw_round_to_sub(&test->draw, 1, -1, test->h);

  231.     if (av_image_check_size(test->w, test->h, 0, ctx) < 0)

  232.         return AVERROR(EINVAL);

  233. 

  234.     if ((ret = config_props(inlink)) < 0)

  235.         return ret;

  236. 

  237.     return 0;

  238. }

  239. 

  240. static int color_process_command(AVFilterContext *ctx, const char *cmd, const char *args,

  241.                                  char *res, int res_len, int flags)

  242. {

  243.     TestSourceContext *test = ctx->priv;

  244.     int ret;

  245. 

  246.     ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);

  247.     if (ret < 0)

  248.         return ret;

  249. 

  250.     ff_draw_color(&test->draw, &test->color, test->color_rgba);

  251.     test->draw_once_reset = 1;

  252.     return 0;

  253. }

  254. 

  255. static const AVFilterPad color_outputs[] = {

  256.     {

  257.         .name          = "default",

  258.         .type          = AVMEDIA_TYPE_VIDEO,

  259.         .config_props  = color_config_props,

  260.     },

  261.     {  NULL }

  262. };

  263. 

  264. AVFilter ff_vsrc_color = {

  265.     .name            = "color",

  266.     .description     = NULL_IF_CONFIG_SMALL("Provide an uniformly colored input."),

  267.     .priv_class      = &color_class,

  268.     .priv_size       = sizeof(TestSourceContext),

  269.     .init            = color_init,

  270.     .uninit          = uninit,

  271.     .activate        = activate,

  272.     .query_formats   = color_query_formats,

  273.     .inputs          = NULL,

  274.     .outputs         = color_outputs,

  275.     .process_command = color_process_command,

  276. };

  277. 

  278. #endif /* CONFIG_COLOR_FILTER */

  279. 

  280. #if CONFIG_HALDCLUTSRC_FILTER

  281. 

  282. static const AVOption haldclutsrc_options[] = {

  283.     { "level", "set level", OFFSET(level), AV_OPT_TYPE_INT, {.i64 = 6}, 2, 16, FLAGS },

  284.     COMMON_OPTIONS_NOSIZE

  285.     { NULL }

  286. };

  287. 

  288. AVFILTER_DEFINE_CLASS(haldclutsrc);

  289. 

  290. static void haldclutsrc_fill_picture(AVFilterContext *ctx, AVFrame *frame)

  291. {

  292.     int i, j, k, x = 0, y = 0, is16bit = 0, step;

  293.     uint32_t alpha = 0;

  294.     const TestSourceContext *hc = ctx->priv;

  295.     int level = hc->level;

  296.     float scale;

  297.     const int w = frame->width;

  298.     const int h = frame->height;

  299.     const uint8_t *data = frame->data[0];

  300.     const int linesize  = frame->linesize[0];

  301.     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);

  302.     uint8_t rgba_map[4];

  303. 

  304.     av_assert0(w == h && w == level*level*level);

  305. 

  306.     ff_fill_rgba_map(rgba_map, frame->format);

  307. 

  308.     switch (frame->format) {

  309.     case AV_PIX_FMT_RGB48:

  310.     case AV_PIX_FMT_BGR48:

  311.     case AV_PIX_FMT_RGBA64:

  312.     case AV_PIX_FMT_BGRA64:

  313.         is16bit = 1;

  314.         alpha = 0xffff;

  315.         break;

  316.     case AV_PIX_FMT_RGBA:

  317.     case AV_PIX_FMT_BGRA:

  318.     case AV_PIX_FMT_ARGB:

  319.     case AV_PIX_FMT_ABGR:

  320.         alpha = 0xff;

  321.         break;

  322.     }

  323. 

  324.     step  = av_get_padded_bits_per_pixel(desc) >> (3 + is16bit);

  325.     scale = ((float)(1 << (8*(is16bit+1))) - 1) / (level*level - 1);

  326. 

  327. #define LOAD_CLUT(nbits) do {                                                   \

  328.     uint##nbits##_t *dst = ((uint##nbits##_t *)(data + y*linesize)) + x*step;   \

  329.     dst[rgba_map[0]] = av_clip_uint##nbits(i * scale);                          \

  330.     dst[rgba_map[1]] = av_clip_uint##nbits(j * scale);                          \

  331.     dst[rgba_map[2]] = av_clip_uint##nbits(k * scale);                          \

  332.     if (step == 4)                                                              \

  333.         dst[rgba_map[3]] = alpha;                                               \

  334. } while (0)

  335. 

  336.     level *= level;

  337.     for (k = 0; k < level; k++) {

  338.         for (j = 0; j < level; j++) {

  339.             for (i = 0; i < level; i++) {

  340.                 if (!is16bit)

  341.                     LOAD_CLUT(8);

  342.                 else

  343.                     LOAD_CLUT(16);

  344.                 if (++x == w) {

  345.                     x = 0;

  346.                     y++;

  347.                 }

  348.             }

  349.         }

  350.     }

  351. }

  352. 

  353. static av_cold int haldclutsrc_init(AVFilterContext *ctx)

  354. {

  355.     TestSourceContext *hc = ctx->priv;

  356.     hc->fill_picture_fn = haldclutsrc_fill_picture;

  357.     hc->draw_once = 1;

  358.     return init(ctx);

  359. }

  360. 

  361. static int haldclutsrc_query_formats(AVFilterContext *ctx)

  362. {

  363.     static const enum AVPixelFormat pix_fmts[] = {

  364.         AV_PIX_FMT_RGB24,  AV_PIX_FMT_BGR24,

  365.         AV_PIX_FMT_RGBA,   AV_PIX_FMT_BGRA,

  366.         AV_PIX_FMT_ARGB,   AV_PIX_FMT_ABGR,

  367.         AV_PIX_FMT_0RGB,   AV_PIX_FMT_0BGR,

  368.         AV_PIX_FMT_RGB0,   AV_PIX_FMT_BGR0,

  369.         AV_PIX_FMT_RGB48,  AV_PIX_FMT_BGR48,

  370.         AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,

  371.         AV_PIX_FMT_NONE,

  372.     };

  373. 

  374.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  375.     if (!fmts_list)

  376.         return AVERROR(ENOMEM);

  377.     return ff_set_common_formats(ctx, fmts_list);

  378. }

  379. 

  380. static int haldclutsrc_config_props(AVFilterLink *outlink)

  381. {

  382.     AVFilterContext *ctx = outlink->src;

  383.     TestSourceContext *hc = ctx->priv;

  384. 

  385.     hc->w = hc->h = hc->level * hc->level * hc->level;

  386.     return config_props(outlink);

  387. }

  388. 

  389. static const AVFilterPad haldclutsrc_outputs[] = {

  390.     {

  391.         .name          = "default",

  392.         .type          = AVMEDIA_TYPE_VIDEO,

  393.         .config_props  = haldclutsrc_config_props,

  394.     },

  395.     {  NULL }

  396. };

  397. 

  398. AVFilter ff_vsrc_haldclutsrc = {

  399.     .name          = "haldclutsrc",

  400.     .description   = NULL_IF_CONFIG_SMALL("Provide an identity Hald CLUT."),

  401.     .priv_class    = &haldclutsrc_class,

  402.     .priv_size     = sizeof(TestSourceContext),

  403.     .init          = haldclutsrc_init,

  404.     .uninit        = uninit,

  405.     .query_formats = haldclutsrc_query_formats,

  406.     .activate      = activate,

  407.     .inputs        = NULL,

  408.     .outputs       = haldclutsrc_outputs,

  409. };

  410. #endif /* CONFIG_HALDCLUTSRC_FILTER */

  411. 

  412. #if CONFIG_NULLSRC_FILTER

  413. 

  414. #define nullsrc_options options

  415. AVFILTER_DEFINE_CLASS(nullsrc);

  416. 

  417. static void nullsrc_fill_picture(AVFilterContext *ctx, AVFrame *picref) { }

  418. 

  419. static av_cold int nullsrc_init(AVFilterContext *ctx)

  420. {

  421.     TestSourceContext *test = ctx->priv;

  422. 

  423.     test->fill_picture_fn = nullsrc_fill_picture;

  424.     return init(ctx);

  425. }

  426. 

  427. static const AVFilterPad nullsrc_outputs[] = {

  428.     {

  429.         .name          = "default",

  430.         .type          = AVMEDIA_TYPE_VIDEO,

  431.         .config_props  = config_props,

  432.     },

  433.     { NULL },

  434. };

  435. 

  436. AVFilter ff_vsrc_nullsrc = {

  437.     .name        = "nullsrc",

  438.     .description = NULL_IF_CONFIG_SMALL("Null video source, return unprocessed video frames."),

  439.     .init        = nullsrc_init,

  440.     .uninit      = uninit,

  441.     .activate    = activate,

  442.     .priv_size   = sizeof(TestSourceContext),

  443.     .priv_class  = &nullsrc_class,

  444.     .inputs      = NULL,

  445.     .outputs     = nullsrc_outputs,

  446. };

  447. 

  448. #endif /* CONFIG_NULLSRC_FILTER */

  449. 

  450. #if CONFIG_TESTSRC_FILTER

  451. 

  452. static const AVOption testsrc_options[] = {

  453.     COMMON_OPTIONS

  454.     { "decimals", "set number of decimals to show", OFFSET(nb_decimals), AV_OPT_TYPE_INT, {.i64=0},  0, 17, FLAGS },

  455.     { "n",        "set number of decimals to show", OFFSET(nb_decimals), AV_OPT_TYPE_INT, {.i64=0},  0, 17, FLAGS },

  456.     { NULL }

  457. };

  458. 

  459. AVFILTER_DEFINE_CLASS(testsrc);

  460. 

  461. /**

  462.  * Fill a rectangle with value val.

  463.  *

  464.  * @param val the RGB value to set

  465.  * @param dst pointer to the destination buffer to fill

  466.  * @param dst_linesize linesize of destination

  467.  * @param segment_width width of the segment

  468.  * @param x horizontal coordinate where to draw the rectangle in the destination buffer

  469.  * @param y horizontal coordinate where to draw the rectangle in the destination buffer

  470.  * @param w width  of the rectangle to draw, expressed as a number of segment_width units

  471.  * @param h height of the rectangle to draw, expressed as a number of segment_width units

  472.  */

  473. static void draw_rectangle(unsigned val, uint8_t *dst, int dst_linesize, int segment_width,

  474.                            int x, int y, int w, int h)

  475. {

  476.     int i;

  477.     int step = 3;

  478. 

  479.     dst += segment_width * (step * x + y * dst_linesize);

  480.     w *= segment_width * step;

  481.     h *= segment_width;

  482.     for (i = 0; i < h; i++) {

  483.         memset(dst, val, w);

  484.         dst += dst_linesize;

  485.     }

  486. }

  487. 

  488. static void draw_digit(int digit, uint8_t *dst, int dst_linesize,

  489.                        int segment_width)

  490. {

  491. #define TOP_HBAR        1

  492. #define MID_HBAR        2

  493. #define BOT_HBAR        4

  494. #define LEFT_TOP_VBAR   8

  495. #define LEFT_BOT_VBAR  16

  496. #define RIGHT_TOP_VBAR 32

  497. #define RIGHT_BOT_VBAR 64

  498.     struct segments {

  499.         int x, y, w, h;

  500.     } segments[] = {

  501.         { 1,  0, 5, 1 }, /* TOP_HBAR */

  502.         { 1,  6, 5, 1 }, /* MID_HBAR */

  503.         { 1, 12, 5, 1 }, /* BOT_HBAR */

  504.         { 0,  1, 1, 5 }, /* LEFT_TOP_VBAR */

  505.         { 0,  7, 1, 5 }, /* LEFT_BOT_VBAR */

  506.         { 6,  1, 1, 5 }, /* RIGHT_TOP_VBAR */

  507.         { 6,  7, 1, 5 }  /* RIGHT_BOT_VBAR */

  508.     };

  509.     static const unsigned char masks[10] = {

  510.         /* 0 */ TOP_HBAR         |BOT_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,

  511.         /* 1 */                                                        RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,

  512.         /* 2 */ TOP_HBAR|MID_HBAR|BOT_HBAR|LEFT_BOT_VBAR                             |RIGHT_TOP_VBAR,

  513.         /* 3 */ TOP_HBAR|MID_HBAR|BOT_HBAR                            |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,

  514.         /* 4 */          MID_HBAR         |LEFT_TOP_VBAR              |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,

  515.         /* 5 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR                             |RIGHT_BOT_VBAR,

  516.         /* 6 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR               |RIGHT_BOT_VBAR,

  517.         /* 7 */ TOP_HBAR                                              |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,

  518.         /* 8 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,

  519.         /* 9 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR              |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,

  520.     };

  521.     unsigned mask = masks[digit];

  522.     int i;

  523. 

  524.     draw_rectangle(0, dst, dst_linesize, segment_width, 0, 0, 8, 13);

  525.     for (i = 0; i < FF_ARRAY_ELEMS(segments); i++)

  526.         if (mask & (1<<i))

  527.             draw_rectangle(255, dst, dst_linesize, segment_width,

  528.                            segments[i].x, segments[i].y, segments[i].w, segments[i].h);

  529. }

  530. 

  531. #define GRADIENT_SIZE (6 * 256)

  532. 

  533. static void test_fill_picture(AVFilterContext *ctx, AVFrame *frame)

  534. {

  535.     TestSourceContext *test = ctx->priv;

  536.     uint8_t *p, *p0;

  537.     int x, y;

  538.     int color, color_rest;

  539.     int icolor;

  540.     int radius;

  541.     int quad0, quad;

  542.     int dquad_x, dquad_y;

  543.     int grad, dgrad, rgrad, drgrad;

  544.     int seg_size;

  545.     int second;

  546.     int i;

  547.     uint8_t *data = frame->data[0];

  548.     int width  = frame->width;

  549.     int height = frame->height;

  550. 

  551.     /* draw colored bars and circle */

  552.     radius = (width + height) / 4;

  553.     quad0 = width * width / 4 + height * height / 4 - radius * radius;

  554.     dquad_y = 1 - height;

  555.     p0 = data;

  556.     for (y = 0; y < height; y++) {

  557.         p = p0;

  558.         color = 0;

  559.         color_rest = 0;

  560.         quad = quad0;

  561.         dquad_x = 1 - width;

  562.         for (x = 0; x < width; x++) {

  563.             icolor = color;

  564.             if (quad < 0)

  565.                 icolor ^= 7;

  566.             quad += dquad_x;

  567.             dquad_x += 2;

  568.             *(p++) = icolor & 1 ? 255 : 0;

  569.             *(p++) = icolor & 2 ? 255 : 0;

  570.             *(p++) = icolor & 4 ? 255 : 0;

  571.             color_rest += 8;

  572.             if (color_rest >= width) {

  573.                 color_rest -= width;

  574.                 color++;

  575.             }

  576.         }

  577.         quad0 += dquad_y;

  578.         dquad_y += 2;

  579.         p0 += frame->linesize[0];

  580.     }

  581. 

  582.     /* draw sliding color line */

  583.     p0 = p = data + frame->linesize[0] * (height * 3/4);

  584.     grad = (256 * test->nb_frame * test->time_base.num / test->time_base.den) %

  585.         GRADIENT_SIZE;

  586.     rgrad = 0;

  587.     dgrad = GRADIENT_SIZE / width;

  588.     drgrad = GRADIENT_SIZE % width;

  589.     for (x = 0; x < width; x++) {

  590.         *(p++) =

  591.             grad < 256 || grad >= 5 * 256 ? 255 :

  592.             grad >= 2 * 256 && grad < 4 * 256 ? 0 :

  593.             grad < 2 * 256 ? 2 * 256 - 1 - grad : grad - 4 * 256;

  594.         *(p++) =

  595.             grad >= 4 * 256 ? 0 :

  596.             grad >= 1 * 256 && grad < 3 * 256 ? 255 :

  597.             grad < 1 * 256 ? grad : 4 * 256 - 1 - grad;

  598.         *(p++) =

  599.             grad < 2 * 256 ? 0 :

  600.             grad >= 3 * 256 && grad < 5 * 256 ? 255 :

  601.             grad < 3 * 256 ? grad - 2 * 256 : 6 * 256 - 1 - grad;

  602.         grad += dgrad;

  603.         rgrad += drgrad;

  604.         if (rgrad >= GRADIENT_SIZE) {

  605.             grad++;

  606.             rgrad -= GRADIENT_SIZE;

  607.         }

  608.         if (grad >= GRADIENT_SIZE)

  609.             grad -= GRADIENT_SIZE;

  610.     }

  611.     p = p0;

  612.     for (y = height / 8; y > 0; y--) {

  613.         memcpy(p+frame->linesize[0], p, 3 * width);

  614.         p += frame->linesize[0];

  615.     }

  616. 

  617.     /* draw digits */

  618.     seg_size = width / 80;

  619.     if (seg_size >= 1 && height >= 13 * seg_size) {

  620.         int64_t p10decimals = 1;

  621.         double time = av_q2d(test->time_base) * test->nb_frame *

  622.                       ff_exp10(test->nb_decimals);

  623.         if (time >= INT_MAX)

  624.             return;

  625. 

  626.         for (x = 0; x < test->nb_decimals; x++)

  627.             p10decimals *= 10;

  628. 

  629.         second = av_rescale_rnd(test->nb_frame * test->time_base.num, p10decimals, test->time_base.den, AV_ROUND_ZERO);

  630.         x = width - (width - seg_size * 64) / 2;

  631.         y = (height - seg_size * 13) / 2;

  632.         p = data + (x*3 + y * frame->linesize[0]);

  633.         for (i = 0; i < 8; i++) {

  634.             p -= 3 * 8 * seg_size;

  635.             draw_digit(second % 10, p, frame->linesize[0], seg_size);

  636.             second /= 10;

  637.             if (second == 0)

  638.                 break;

  639.         }

  640.     }

  641. }

  642. 

  643. static av_cold int test_init(AVFilterContext *ctx)

  644. {

  645.     TestSourceContext *test = ctx->priv;

  646. 

  647.     test->fill_picture_fn = test_fill_picture;

  648.     return init(ctx);

  649. }

  650. 

  651. static int test_query_formats(AVFilterContext *ctx)

  652. {

  653.     static const enum AVPixelFormat pix_fmts[] = {

  654.         AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE

  655.     };

  656. 

  657.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  658.     if (!fmts_list)

  659.         return AVERROR(ENOMEM);

  660.     return ff_set_common_formats(ctx, fmts_list);

  661. }

  662. 

  663. static const AVFilterPad avfilter_vsrc_testsrc_outputs[] = {

  664.     {

  665.         .name          = "default",

  666.         .type          = AVMEDIA_TYPE_VIDEO,

  667.         .config_props  = config_props,

  668.     },

  669.     { NULL }

  670. };

  671. 

  672. AVFilter ff_vsrc_testsrc = {

  673.     .name          = "testsrc",

  674.     .description   = NULL_IF_CONFIG_SMALL("Generate test pattern."),

  675.     .priv_size     = sizeof(TestSourceContext),

  676.     .priv_class    = &testsrc_class,

  677.     .init          = test_init,

  678.     .uninit        = uninit,

  679.     .query_formats = test_query_formats,

  680.     .activate      = activate,

  681.     .inputs        = NULL,

  682.     .outputs       = avfilter_vsrc_testsrc_outputs,

  683. };

  684. 

  685. #endif /* CONFIG_TESTSRC_FILTER */

  686. 

  687. #if CONFIG_TESTSRC2_FILTER

  688. 

  689. static const AVOption testsrc2_options[] = {

  690.     COMMON_OPTIONS

  691.     { "alpha", "set global alpha (opacity)", OFFSET(alpha), AV_OPT_TYPE_INT, {.i64 = 255}, 0, 255, FLAGS },

  692.     { NULL }

  693. };

  694. 

  695. AVFILTER_DEFINE_CLASS(testsrc2);

  696. 

  697. static void set_color(TestSourceContext *s, FFDrawColor *color, uint32_t argb)

  698. {

  699.     uint8_t rgba[4] = { (argb >> 16) & 0xFF,

  700.                         (argb >>  8) & 0xFF,

  701.                         (argb >>  0) & 0xFF,

  702.                         (argb >> 24) & 0xFF, };

  703.     ff_draw_color(&s->draw, color, rgba);

  704. }

  705. 

  706. static uint32_t color_gradient(unsigned index)

  707. {

  708.     unsigned si = index & 0xFF, sd = 0xFF - si;

  709.     switch (index >> 8) {

  710.     case 0: return 0xFF0000 + (si <<  8);

  711.     case 1: return 0x00FF00 + (sd << 16);

  712.     case 2: return 0x00FF00 + (si <<  0);

  713.     case 3: return 0x0000FF + (sd <<  8);

  714.     case 4: return 0x0000FF + (si << 16);

  715.     case 5: return 0xFF0000 + (sd <<  0);

  716.     }

  717.     av_assert0(0);

  718. }

  719. 

  720. static void draw_text(TestSourceContext *s, AVFrame *frame, FFDrawColor *color,

  721.                       int x0, int y0, const uint8_t *text)

  722. {

  723.     int x = x0;

  724. 

  725.     for (; *text; text++) {

  726.         if (*text == '\n') {

  727.             x = x0;

  728.             y0 += 16;

  729.             continue;

  730.         }

  731.         ff_blend_mask(&s->draw, color, frame->data, frame->linesize,

  732.                       frame->width, frame->height,

  733.                       avpriv_vga16_font + *text * 16, 1, 8, 16, 0, 0, x, y0);

  734.         x += 8;

  735.     }

  736. }

  737. 

  738. static void test2_fill_picture(AVFilterContext *ctx, AVFrame *frame)

  739. {

  740.     TestSourceContext *s = ctx->priv;

  741.     FFDrawColor color;

  742.     unsigned alpha = (uint32_t)s->alpha << 24;

  743. 

  744.     /* colored background */

  745.     {

  746.         unsigned i, x = 0, x2;

  747. 

  748.         x = 0;

  749.         for (i = 1; i < 7; i++) {

  750.             x2 = av_rescale(i, s->w, 6);

  751.             x2 = ff_draw_round_to_sub(&s->draw, 0, 0, x2);

  752.             set_color(s, &color, ((i & 1) ? 0xFF0000 : 0) |

  753.                                  ((i & 2) ? 0x00FF00 : 0) |

  754.                                  ((i & 4) ? 0x0000FF : 0) |

  755.                                  alpha);

  756.             ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,

  757.                               x, 0, x2 - x, frame->height);

  758.             x = x2;

  759.         }

  760.     }

  761. 

  762.     /* oblique gradient */

  763.     /* note: too slow if using blending */

  764.     if (s->h >= 64) {

  765.         unsigned x, dx, y0, y, g0, g;

  766. 

  767.         dx = ff_draw_round_to_sub(&s->draw, 0, +1, 1);

  768.         y0 = av_rescale_q(s->pts, s->time_base, av_make_q(2, s->h - 16));

  769.         g0 = av_rescale_q(s->pts, s->time_base, av_make_q(1, 128));

  770.         for (x = 0; x < s->w; x += dx) {

  771.             g = (av_rescale(x, 6 * 256, s->w) + g0) % (6 * 256);

  772.             set_color(s, &color, color_gradient(g) | alpha);

  773.             y = y0 + av_rescale(x, s->h / 2, s->w);

  774.             y %= 2 * (s->h - 16);

  775.             if (y > s->h - 16)

  776.                 y = 2 * (s->h - 16) - y;

  777.             y = ff_draw_round_to_sub(&s->draw, 1, 0, y);

  778.             ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,

  779.                               x, y, dx, 16);

  780.         }

  781.     }

  782. 

  783.     /* top right: draw clock hands */

  784.     if (s->w >= 64 && s->h >= 64) {

  785.         int l = (FFMIN(s->w, s->h) - 32) >> 1;

  786.         int steps = FFMAX(4, l >> 5);

  787.         int xc = (s->w >> 2) + (s->w >> 1);

  788.         int yc = (s->h >> 2);

  789.         int cycle = l << 2;

  790.         int pos, xh, yh;

  791.         int c, i;

  792. 

  793.         for (c = 0; c < 3; c++) {

  794.             set_color(s, &color, (0xBBBBBB ^ (0xFF << (c << 3))) | alpha);

  795.             pos = av_rescale_q(s->pts, s->time_base, av_make_q(64 >> (c << 1), cycle)) % cycle;

  796.             xh = pos < 1 * l ? pos :

  797.                  pos < 2 * l ? l :

  798.                  pos < 3 * l ? 3 * l - pos : 0;

  799.             yh = pos < 1 * l ? 0 :

  800.                  pos < 2 * l ? pos - l :

  801.                  pos < 3 * l ? l :

  802.                                cycle - pos;

  803.             xh -= l >> 1;

  804.             yh -= l >> 1;

  805.             for (i = 1; i <= steps; i++) {

  806.                 int x = av_rescale(xh, i, steps) + xc;

  807.                 int y = av_rescale(yh, i, steps) + yc;

  808.                 x = ff_draw_round_to_sub(&s->draw, 0, -1, x);

  809.                 y = ff_draw_round_to_sub(&s->draw, 1, -1, y);

  810.                 ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,

  811.                                   x, y, 8, 8);

  812.             }

  813.         }

  814.     }

  815. 

  816.     /* bottom left: beating rectangles */

  817.     if (s->w >= 64 && s->h >= 64) {

  818.         int l = (FFMIN(s->w, s->h) - 16) >> 2;

  819.         int cycle = l << 3;

  820.         int xc = (s->w >> 2);

  821.         int yc = (s->h >> 2) + (s->h >> 1);

  822.         int xm1 = ff_draw_round_to_sub(&s->draw, 0, -1, xc - 8);

  823.         int xm2 = ff_draw_round_to_sub(&s->draw, 0, +1, xc + 8);

  824.         int ym1 = ff_draw_round_to_sub(&s->draw, 1, -1, yc - 8);

  825.         int ym2 = ff_draw_round_to_sub(&s->draw, 1, +1, yc + 8);

  826.         int size, step, x1, x2, y1, y2;

  827. 

  828.         size = av_rescale_q(s->pts, s->time_base, av_make_q(4, cycle));

  829.         step = size / l;

  830.         size %= l;

  831.         if (step & 1)

  832.             size = l - size;

  833.         step = (step >> 1) & 3;

  834.         set_color(s, &color, 0xFF808080);

  835.         x1 = ff_draw_round_to_sub(&s->draw, 0, -1, xc - 4 - size);

  836.         x2 = ff_draw_round_to_sub(&s->draw, 0, +1, xc + 4 + size);

  837.         y1 = ff_draw_round_to_sub(&s->draw, 1, -1, yc - 4 - size);

  838.         y2 = ff_draw_round_to_sub(&s->draw, 1, +1, yc + 4 + size);

  839.         if (step == 0 || step == 2)

  840.             ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,

  841.                               x1, ym1, x2 - x1, ym2 - ym1);

  842.         if (step == 1 || step == 2)

  843.             ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,

  844.                               xm1, y1, xm2 - xm1, y2 - y1);

  845.         if (step == 3)

  846.             ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,

  847.                               x1, y1, x2 - x1, y2 - y1);

  848.     }

  849. 

  850.     /* bottom right: checker with random noise */

  851.     {

  852.         unsigned xmin = av_rescale(5, s->w, 8);

  853.         unsigned xmax = av_rescale(7, s->w, 8);

  854.         unsigned ymin = av_rescale(5, s->h, 8);

  855.         unsigned ymax = av_rescale(7, s->h, 8);

  856.         unsigned x, y, i, r;

  857.         uint8_t alpha[256];

  858. 

  859.         r = s->pts;

  860.         for (y = ymin; y + 15 < ymax; y += 16) {

  861.             for (x = xmin; x + 15 < xmax; x += 16) {

  862.                 if ((x ^ y) & 16)

  863.                     continue;

  864.                 for (i = 0; i < 256; i++) {

  865.                     r = r * 1664525 + 1013904223;

  866.                     alpha[i] = r >> 24;

  867.                 }

  868.                 set_color(s, &color, 0xFF00FF80);

  869.                 ff_blend_mask(&s->draw, &color, frame->data, frame->linesize,

  870.                                    frame->width, frame->height,

  871.                                    alpha, 16, 16, 16, 3, 0, x, y);

  872.             }

  873.         }

  874.     }

  875. 

  876.     /* bouncing square */

  877.     if (s->w >= 16 && s->h >= 16) {

  878.         unsigned w = s->w - 8;

  879.         unsigned h = s->h - 8;

  880.         unsigned x = av_rescale_q(s->pts, s->time_base, av_make_q(233, 55 * w)) % (w << 1);

  881.         unsigned y = av_rescale_q(s->pts, s->time_base, av_make_q(233, 89 * h)) % (h << 1);

  882.         if (x > w)

  883.             x = (w << 1) - x;

  884.         if (y > h)

  885.             y = (h << 1) - y;

  886.         x = ff_draw_round_to_sub(&s->draw, 0, -1, x);

  887.         y = ff_draw_round_to_sub(&s->draw, 1, -1, y);

  888.         set_color(s, &color, 0xFF8000FF);

  889.         ff_fill_rectangle(&s->draw, &color, frame->data, frame->linesize,

  890.                           x, y, 8, 8);

  891.     }

  892. 

  893.     /* top right: draw frame time and frame number */

  894.     {

  895.         char buf[256];

  896.         unsigned time;

  897. 

  898.         time = av_rescale_q(s->pts, s->time_base, av_make_q(1, 1000)) % 86400000;

  899.         set_color(s, &color, 0xC0000000);

  900.         ff_blend_rectangle(&s->draw, &color, frame->data, frame->linesize,

  901.                            frame->width, frame->height,

  902.                            2, 2, 100, 36);

  903.         set_color(s, &color, 0xFFFF8000);

  904.         snprintf(buf, sizeof(buf), "%02d:%02d:%02d.%03d\n%12"PRIi64,

  905.                  time / 3600000, (time / 60000) % 60, (time / 1000) % 60,

  906.                  time % 1000, s->pts);

  907.         draw_text(s, frame, &color, 4, 4, buf);

  908.     }

  909. }

  910. static av_cold int test2_init(AVFilterContext *ctx)

  911. {

  912.     TestSourceContext *s = ctx->priv;

  913. 

  914.     s->fill_picture_fn = test2_fill_picture;

  915.     return init(ctx);

  916. }

  917. 

  918. static int test2_query_formats(AVFilterContext *ctx)

  919. {

  920.     return ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));

  921. }

  922. 

  923. static int test2_config_props(AVFilterLink *inlink)

  924. {

  925.     AVFilterContext *ctx = inlink->src;

  926.     TestSourceContext *s = ctx->priv;

  927. 

  928.     av_assert0(ff_draw_init(&s->draw, inlink->format, 0) >= 0);

  929.     s->w = ff_draw_round_to_sub(&s->draw, 0, -1, s->w);

  930.     s->h = ff_draw_round_to_sub(&s->draw, 1, -1, s->h);

  931.     if (av_image_check_size(s->w, s->h, 0, ctx) < 0)

  932.         return AVERROR(EINVAL);

  933.     return config_props(inlink);

  934. }

  935. 

  936. static const AVFilterPad avfilter_vsrc_testsrc2_outputs[] = {

  937.     {

  938.         .name          = "default",

  939.         .type          = AVMEDIA_TYPE_VIDEO,

  940.         .config_props  = test2_config_props,

  941.     },

  942.     { NULL }

  943. };

  944. 

  945. AVFilter ff_vsrc_testsrc2 = {

  946.     .name          = "testsrc2",

  947.     .description   = NULL_IF_CONFIG_SMALL("Generate another test pattern."),

  948.     .priv_size     = sizeof(TestSourceContext),

  949.     .priv_class    = &testsrc2_class,

  950.     .init          = test2_init,

  951.     .uninit        = uninit,

  952.     .query_formats = test2_query_formats,

  953.     .activate      = activate,

  954.     .inputs        = NULL,

  955.     .outputs       = avfilter_vsrc_testsrc2_outputs,

  956. };

  957. 

  958. #endif /* CONFIG_TESTSRC2_FILTER */

  959. 

  960. #if CONFIG_RGBTESTSRC_FILTER

  961. 

  962. #define rgbtestsrc_options options

  963. AVFILTER_DEFINE_CLASS(rgbtestsrc);

  964. 

  965. #define R 0

  966. #define G 1

  967. #define B 2

  968. #define A 3

  969. 

  970. static void rgbtest_put_pixel(uint8_t *dst, int dst_linesize,

  971.                               int x, int y, unsigned r, unsigned g, unsigned b, enum AVPixelFormat fmt,

  972.                               uint8_t rgba_map[4])

  973. {

  974.     uint32_t v;

  975.     uint8_t *p;

  976. 

  977.     switch (fmt) {

  978.     case AV_PIX_FMT_BGR444: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r >> 4) << 8) | ((g >> 4) << 4) | (b >> 4); break;

  979.     case AV_PIX_FMT_RGB444: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b >> 4) << 8) | ((g >> 4) << 4) | (r >> 4); break;

  980.     case AV_PIX_FMT_BGR555: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r>>3)<<10) | ((g>>3)<<5) | (b>>3); break;

  981.     case AV_PIX_FMT_RGB555: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b>>3)<<10) | ((g>>3)<<5) | (r>>3); break;

  982.     case AV_PIX_FMT_BGR565: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r>>3)<<11) | ((g>>2)<<5) | (b>>3); break;

  983.     case AV_PIX_FMT_RGB565: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b>>3)<<11) | ((g>>2)<<5) | (r>>3); break;

  984.     case AV_PIX_FMT_RGB24:

  985.     case AV_PIX_FMT_BGR24:

  986.         v = (r << (rgba_map[R]*8)) + (g << (rgba_map[G]*8)) + (b << (rgba_map[B]*8));

  987.         p = dst + 3*x + y*dst_linesize;

  988.         AV_WL24(p, v);

  989.         break;

  990.     case AV_PIX_FMT_RGBA:

  991.     case AV_PIX_FMT_BGRA:

  992.     case AV_PIX_FMT_ARGB:

  993.     case AV_PIX_FMT_ABGR:

  994.         v = (r << (rgba_map[R]*8)) + (g << (rgba_map[G]*8)) + (b << (rgba_map[B]*8)) + (255U << (rgba_map[A]*8));

  995.         p = dst + 4*x + y*dst_linesize;

  996.         AV_WL32(p, v);

  997.         break;

  998.     }

  999. }

  1000. 

  1001. static void rgbtest_fill_picture(AVFilterContext *ctx, AVFrame *frame)

  1002. {

  1003.     TestSourceContext *test = ctx->priv;

  1004.     int x, y, w = frame->width, h = frame->height;

  1005. 

  1006.     for (y = 0; y < h; y++) {

  1007.          for (x = 0; x < w; x++) {

  1008.              int c = 256*x/w;

  1009.              int r = 0, g = 0, b = 0;

  1010. 

  1011.              if      (3*y < h  ) r = c;

  1012.              else if (3*y < 2*h) g = c;

  1013.              else                b = c;

  1014. 

  1015.              rgbtest_put_pixel(frame->data[0], frame->linesize[0], x, y, r, g, b,

  1016.                                ctx->outputs[0]->format, test->rgba_map);

  1017.          }

  1018.      }

  1019. }

  1020. 

  1021. static av_cold int rgbtest_init(AVFilterContext *ctx)

  1022. {

  1023.     TestSourceContext *test = ctx->priv;

  1024. 

  1025.     test->draw_once = 1;

  1026.     test->fill_picture_fn = rgbtest_fill_picture;

  1027.     return init(ctx);

  1028. }

  1029. 

  1030. static int rgbtest_query_formats(AVFilterContext *ctx)

  1031. {

  1032.     static const enum AVPixelFormat pix_fmts[] = {

  1033.         AV_PIX_FMT_RGBA, AV_PIX_FMT_ARGB, AV_PIX_FMT_BGRA, AV_PIX_FMT_ABGR,

  1034.         AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24,

  1035.         AV_PIX_FMT_RGB444, AV_PIX_FMT_BGR444,

  1036.         AV_PIX_FMT_RGB565, AV_PIX_FMT_BGR565,

  1037.         AV_PIX_FMT_RGB555, AV_PIX_FMT_BGR555,

  1038.         AV_PIX_FMT_NONE

  1039.     };

  1040. 

  1041.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  1042.     if (!fmts_list)

  1043.         return AVERROR(ENOMEM);

  1044.     return ff_set_common_formats(ctx, fmts_list);

  1045. }

  1046. 

  1047. static int rgbtest_config_props(AVFilterLink *outlink)

  1048. {

  1049.     TestSourceContext *test = outlink->src->priv;

  1050. 

  1051.     ff_fill_rgba_map(test->rgba_map, outlink->format);

  1052.     return config_props(outlink);

  1053. }

  1054. 

  1055. static const AVFilterPad avfilter_vsrc_rgbtestsrc_outputs[] = {

  1056.     {

  1057.         .name          = "default",

  1058.         .type          = AVMEDIA_TYPE_VIDEO,

  1059.         .config_props  = rgbtest_config_props,

  1060.     },

  1061.     { NULL }

  1062. };

  1063. 

  1064. AVFilter ff_vsrc_rgbtestsrc = {

  1065.     .name          = "rgbtestsrc",

  1066.     .description   = NULL_IF_CONFIG_SMALL("Generate RGB test pattern."),

  1067.     .priv_size     = sizeof(TestSourceContext),

  1068.     .priv_class    = &rgbtestsrc_class,

  1069.     .init          = rgbtest_init,

  1070.     .uninit        = uninit,

  1071.     .query_formats = rgbtest_query_formats,

  1072.     .activate      = activate,

  1073.     .inputs        = NULL,

  1074.     .outputs       = avfilter_vsrc_rgbtestsrc_outputs,

  1075. };

  1076. 

  1077. #endif /* CONFIG_RGBTESTSRC_FILTER */

  1078. 

  1079. #if CONFIG_YUVTESTSRC_FILTER

  1080. 

  1081. #define yuvtestsrc_options options

  1082. AVFILTER_DEFINE_CLASS(yuvtestsrc);

  1083. 

  1084. static void yuvtest_fill_picture8(AVFilterContext *ctx, AVFrame *frame)

  1085. {

  1086.     int x, y, w = frame->width, h = frame->height / 3;

  1087.     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);

  1088.     const int factor = 1 << desc->comp[0].depth;

  1089.     const int mid = 1 << (desc->comp[0].depth - 1);

  1090.     uint8_t *ydst = frame->data[0];

  1091.     uint8_t *udst = frame->data[1];

  1092.     uint8_t *vdst = frame->data[2];

  1093.     int ylinesize = frame->linesize[0];

  1094.     int ulinesize = frame->linesize[1];

  1095.     int vlinesize = frame->linesize[2];

  1096. 

  1097.     for (y = 0; y < h; y++) {

  1098.         for (x = 0; x < w; x++) {

  1099.             int c = factor * x / w;

  1100. 

  1101.             ydst[x] = c;

  1102.             udst[x] = mid;

  1103.             vdst[x] = mid;

  1104.         }

  1105. 

  1106.         ydst += ylinesize;

  1107.         udst += ulinesize;

  1108.         vdst += vlinesize;

  1109.     }

  1110. 

  1111.     h += h;

  1112.     for (; y < h; y++) {

  1113.         for (x = 0; x < w; x++) {

  1114.             int c = factor * x / w;

  1115. 

  1116.             ydst[x] = mid;

  1117.             udst[x] = c;

  1118.             vdst[x] = mid;

  1119.         }

  1120. 

  1121.         ydst += ylinesize;

  1122.         udst += ulinesize;

  1123.         vdst += vlinesize;

  1124.     }

  1125. 

  1126.     for (; y < frame->height; y++) {

  1127.         for (x = 0; x < w; x++) {

  1128.             int c = factor * x / w;

  1129. 

  1130.             ydst[x] = mid;

  1131.             udst[x] = mid;

  1132.             vdst[x] = c;

  1133.         }

  1134. 

  1135.         ydst += ylinesize;

  1136.         udst += ulinesize;

  1137.         vdst += vlinesize;

  1138.     }

  1139. }

  1140. 

  1141. static void yuvtest_fill_picture16(AVFilterContext *ctx, AVFrame *frame)

  1142. {

  1143.     int x, y, w = frame->width, h = frame->height / 3;

  1144.     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);

  1145.     const int factor = 1 << desc->comp[0].depth;

  1146.     const int mid = 1 << (desc->comp[0].depth - 1);

  1147.     uint16_t *ydst = (uint16_t *)frame->data[0];

  1148.     uint16_t *udst = (uint16_t *)frame->data[1];

  1149.     uint16_t *vdst = (uint16_t *)frame->data[2];

  1150.     int ylinesize = frame->linesize[0] / 2;

  1151.     int ulinesize = frame->linesize[1] / 2;

  1152.     int vlinesize = frame->linesize[2] / 2;

  1153. 

  1154.     for (y = 0; y < h; y++) {

  1155.         for (x = 0; x < w; x++) {

  1156.             int c = factor * x / w;

  1157. 

  1158.             ydst[x] = c;

  1159.             udst[x] = mid;

  1160.             vdst[x] = mid;

  1161.         }

  1162. 

  1163.         ydst += ylinesize;

  1164.         udst += ulinesize;

  1165.         vdst += vlinesize;

  1166.     }

  1167. 

  1168.     h += h;

  1169.     for (; y < h; y++) {

  1170.         for (x = 0; x < w; x++) {

  1171.             int c = factor * x / w;

  1172. 

  1173.             ydst[x] = mid;

  1174.             udst[x] = c;

  1175.             vdst[x] = mid;

  1176.         }

  1177. 

  1178.         ydst += ylinesize;

  1179.         udst += ulinesize;

  1180.         vdst += vlinesize;

  1181.     }

  1182. 

  1183.     for (; y < frame->height; y++) {

  1184.         for (x = 0; x < w; x++) {

  1185.             int c = factor * x / w;

  1186. 

  1187.             ydst[x] = mid;

  1188.             udst[x] = mid;

  1189.             vdst[x] = c;

  1190.         }

  1191. 

  1192.         ydst += ylinesize;

  1193.         udst += ulinesize;

  1194.         vdst += vlinesize;

  1195.     }

  1196. }

  1197. 

  1198. static av_cold int yuvtest_init(AVFilterContext *ctx)

  1199. {

  1200.     TestSourceContext *test = ctx->priv;

  1201. 

  1202.     test->draw_once = 1;

  1203.     return init(ctx);

  1204. }

  1205. 

  1206. static int yuvtest_query_formats(AVFilterContext *ctx)

  1207. {

  1208.     static const enum AVPixelFormat pix_fmts[] = {

  1209.         AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,

  1210.         AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10,

  1211.         AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14,

  1212.         AV_PIX_FMT_YUV444P16,

  1213.         AV_PIX_FMT_NONE

  1214.     };

  1215. 

  1216.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  1217.     if (!fmts_list)

  1218.         return AVERROR(ENOMEM);

  1219.     return ff_set_common_formats(ctx, fmts_list);

  1220. }

  1221. 

  1222. static int yuvtest_config_props(AVFilterLink *outlink)

  1223. {

  1224.     TestSourceContext *test = outlink->src->priv;

  1225.     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);

  1226. 

  1227.     test->fill_picture_fn = desc->comp[0].depth > 8 ? yuvtest_fill_picture16 : yuvtest_fill_picture8;

  1228.     return config_props(outlink);

  1229. }

  1230. 

  1231. static const AVFilterPad avfilter_vsrc_yuvtestsrc_outputs[] = {

  1232.     {

  1233.         .name          = "default",

  1234.         .type          = AVMEDIA_TYPE_VIDEO,

  1235.         .config_props  = yuvtest_config_props,

  1236.     },

  1237.     { NULL }

  1238. };

  1239. 

  1240. AVFilter ff_vsrc_yuvtestsrc = {

  1241.     .name          = "yuvtestsrc",

  1242.     .description   = NULL_IF_CONFIG_SMALL("Generate YUV test pattern."),

  1243.     .priv_size     = sizeof(TestSourceContext),

  1244.     .priv_class    = &yuvtestsrc_class,

  1245.     .init          = yuvtest_init,

  1246.     .uninit        = uninit,

  1247.     .query_formats = yuvtest_query_formats,

  1248.     .activate      = activate,

  1249.     .inputs        = NULL,

  1250.     .outputs       = avfilter_vsrc_yuvtestsrc_outputs,

  1251. };

  1252. 

  1253. #endif /* CONFIG_YUVTESTSRC_FILTER */

  1254. 

  1255. #if CONFIG_PAL75BARS_FILTER || CONFIG_PAL100BARS_FILTER || CONFIG_SMPTEBARS_FILTER || CONFIG_SMPTEHDBARS_FILTER

  1256. 

  1257. static const uint8_t rainbow[7][4] = {

  1258.     { 180, 128, 128, 255 },     /* 75% white */

  1259.     { 162,  44, 142, 255 },     /* 75% yellow */

  1260.     { 131, 156,  44, 255 },     /* 75% cyan */

  1261.     { 112,  72,  58, 255 },     /* 75% green */

  1262.     {  84, 184, 198, 255 },     /* 75% magenta */

  1263.     {  65, 100, 212, 255 },     /* 75% red */

  1264.     {  35, 212, 114, 255 },     /* 75% blue */

  1265. };

  1266. 

  1267. static const uint8_t rainbow100[7][4] = {

  1268.     { 235, 128, 128, 255 },     /* 100% white */

  1269.     { 210,  16, 146, 255 },     /* 100% yellow */

  1270.     { 170, 166,  16, 255 },     /* 100% cyan */

  1271.     { 145,  54,  34, 255 },     /* 100% green */

  1272.     { 106, 202, 222, 255 },     /* 100% magenta */

  1273.     {  81,  90, 240, 255 },     /* 100% red */

  1274.     {  41, 240, 110, 255 },     /* 100% blue */

  1275. };

  1276. 

  1277. static const uint8_t rainbowhd[7][4] = {

  1278.     { 180, 128, 128, 255 },     /* 75% white */

  1279.     { 168,  44, 136, 255 },     /* 75% yellow */

  1280.     { 145, 147,  44, 255 },     /* 75% cyan */

  1281.     { 133,  63,  52, 255 },     /* 75% green */

  1282.     {  63, 193, 204, 255 },     /* 75% magenta */

  1283.     {  51, 109, 212, 255 },     /* 75% red */

  1284.     {  28, 212, 120, 255 },     /* 75% blue */

  1285. };

  1286. 

  1287. static const uint8_t wobnair[7][4] = {

  1288.     {  35, 212, 114, 255 },     /* 75% blue */

  1289.     {  19, 128, 128, 255 },     /* 7.5% intensity black */

  1290.     {  84, 184, 198, 255 },     /* 75% magenta */

  1291.     {  19, 128, 128, 255 },     /* 7.5% intensity black */

  1292.     { 131, 156,  44, 255 },     /* 75% cyan */

  1293.     {  19, 128, 128, 255 },     /* 7.5% intensity black */

  1294.     { 180, 128, 128, 255 },     /* 75% white */

  1295. };

  1296. 

  1297. static const uint8_t white[4] = { 235, 128, 128, 255 };

  1298. 

  1299. /* pluge pulses */

  1300. static const uint8_t neg4ire[4] = {  7, 128, 128, 255 };

  1301. static const uint8_t pos4ire[4] = { 24, 128, 128, 255 };

  1302. 

  1303. /* fudged Q/-I */

  1304. static const uint8_t i_pixel[4] = { 57, 156,  97, 255 };

  1305. static const uint8_t q_pixel[4] = { 44, 171, 147, 255 };

  1306. 

  1307. static const uint8_t gray40[4] = { 104, 128, 128, 255 };

  1308. static const uint8_t gray15[4] = {  49, 128, 128, 255 };

  1309. static const uint8_t   cyan[4] = { 188, 154,  16, 255 };

  1310. static const uint8_t yellow[4] = { 219,  16, 138, 255 };

  1311. static const uint8_t   blue[4] = {  32, 240, 118, 255 };

  1312. static const uint8_t    red[4] = {  63, 102, 240, 255 };

  1313. static const uint8_t black0[4] = {  16, 128, 128, 255 };

  1314. static const uint8_t black2[4] = {  20, 128, 128, 255 };

  1315. static const uint8_t black4[4] = {  25, 128, 128, 255 };

  1316. static const uint8_t   neg2[4] = {  12, 128, 128, 255 };

  1317. 

  1318. static void draw_bar(TestSourceContext *test, const uint8_t color[4],

  1319.                      int x, int y, int w, int h,

  1320.                      AVFrame *frame)

  1321. {

  1322.     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);

  1323.     uint8_t *p, *p0;

  1324.     int plane;

  1325. 

  1326.     x = FFMIN(x, test->w - 1);

  1327.     y = FFMIN(y, test->h - 1);

  1328.     w = FFMAX(FFMIN(w, test->w - x), 0);

  1329.     h = FFMAX(FFMIN(h, test->h - y), 0);

  1330. 

  1331.     av_assert0(x + w <= test->w);

  1332.     av_assert0(y + h <= test->h);

  1333. 

  1334.     for (plane = 0; frame->data[plane]; plane++) {

  1335.         const int c = color[plane];

  1336.         const int linesize = frame->linesize[plane];

  1337.         int i, px, py, pw, ph;

  1338. 

  1339.         if (plane == 1 || plane == 2) {

  1340.             px = x >> desc->log2_chroma_w;

  1341.             pw = AV_CEIL_RSHIFT(w, desc->log2_chroma_w);

  1342.             py = y >> desc->log2_chroma_h;

  1343.             ph = AV_CEIL_RSHIFT(h, desc->log2_chroma_h);

  1344.         } else {

  1345.             px = x;

  1346.             pw = w;

  1347.             py = y;

  1348.             ph = h;

  1349.         }

  1350. 

  1351.         p0 = p = frame->data[plane] + py * linesize + px;

  1352.         memset(p, c, pw);

  1353.         p += linesize;

  1354.         for (i = 1; i < ph; i++, p += linesize)

  1355.             memcpy(p, p0, pw);

  1356.     }

  1357. }

  1358. 

  1359. static int smptebars_query_formats(AVFilterContext *ctx)

  1360. {

  1361.     static const enum AVPixelFormat pix_fmts[] = {

  1362.         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,

  1363.         AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,

  1364.         AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,

  1365.         AV_PIX_FMT_NONE,

  1366.     };

  1367. 

  1368.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  1369.     if (!fmts_list)

  1370.         return AVERROR(ENOMEM);

  1371.     return ff_set_common_formats(ctx, fmts_list);

  1372. }

  1373. 

  1374. static const AVFilterPad smptebars_outputs[] = {

  1375.     {

  1376.         .name          = "default",

  1377.         .type          = AVMEDIA_TYPE_VIDEO,

  1378.         .config_props  = config_props,

  1379.     },

  1380.     { NULL }

  1381. };

  1382. 

  1383. #if CONFIG_PAL75BARS_FILTER

  1384. 

  1385. #define pal75bars_options options

  1386. AVFILTER_DEFINE_CLASS(pal75bars);

  1387. 

  1388. static void pal75bars_fill_picture(AVFilterContext *ctx, AVFrame *picref)

  1389. {

  1390.     TestSourceContext *test = ctx->priv;

  1391.     int r_w, i, x = 0;

  1392.     const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format);

  1393. 

  1394.     picref->color_range = AVCOL_RANGE_MPEG;

  1395.     picref->colorspace = AVCOL_SPC_BT470BG;

  1396. 

  1397.     r_w = FFALIGN((test->w + 7) / 8, 1 << pixdesc->log2_chroma_w);

  1398. 

  1399.     draw_bar(test, white, x, 0, r_w, test->h, picref);

  1400.     x += r_w;

  1401.     for (i = 1; i < 7; i++) {

  1402.         draw_bar(test, rainbow[i], x, 0, r_w, test->h, picref);

  1403.         x += r_w;

  1404.     }

  1405.     draw_bar(test, black0, x, 0, r_w, test->h, picref);

  1406. }

  1407. 

  1408. static av_cold int pal75bars_init(AVFilterContext *ctx)

  1409. {

  1410.     TestSourceContext *test = ctx->priv;

  1411. 

  1412.     test->fill_picture_fn = pal75bars_fill_picture;

  1413.     test->draw_once = 1;

  1414.     return init(ctx);

  1415. }

  1416. 

  1417. AVFilter ff_vsrc_pal75bars = {

  1418.     .name          = "pal75bars",

  1419.     .description   = NULL_IF_CONFIG_SMALL("Generate PAL 75% color bars."),

  1420.     .priv_size     = sizeof(TestSourceContext),

  1421.     .priv_class    = &pal75bars_class,

  1422.     .init          = pal75bars_init,

  1423.     .uninit        = uninit,

  1424.     .query_formats = smptebars_query_formats,

  1425.     .activate      = activate,

  1426.     .inputs        = NULL,

  1427.     .outputs       = smptebars_outputs,

  1428. };

  1429. 

  1430. #endif  /* CONFIG_PAL75BARS_FILTER */

  1431. 

  1432. #if CONFIG_PAL100BARS_FILTER

  1433. 

  1434. #define pal100bars_options options

  1435. AVFILTER_DEFINE_CLASS(pal100bars);

  1436. 

  1437. static void pal100bars_fill_picture(AVFilterContext *ctx, AVFrame *picref)

  1438. {

  1439.     TestSourceContext *test = ctx->priv;

  1440.     int r_w, i, x = 0;

  1441.     const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format);

  1442. 

  1443.     picref->color_range = AVCOL_RANGE_MPEG;

  1444.     picref->colorspace = AVCOL_SPC_BT470BG;

  1445. 

  1446.     r_w = FFALIGN((test->w + 7) / 8, 1 << pixdesc->log2_chroma_w);

  1447. 

  1448.     for (i = 0; i < 7; i++) {

  1449.         draw_bar(test, rainbow100[i], x, 0, r_w, test->h, picref);

  1450.         x += r_w;

  1451.     }

  1452.     draw_bar(test, black0, x, 0, r_w, test->h, picref);

  1453. }

  1454. 

  1455. static av_cold int pal100bars_init(AVFilterContext *ctx)

  1456. {

  1457.     TestSourceContext *test = ctx->priv;

  1458. 

  1459.     test->fill_picture_fn = pal100bars_fill_picture;

  1460.     test->draw_once = 1;

  1461.     return init(ctx);

  1462. }

  1463. 

  1464. AVFilter ff_vsrc_pal100bars = {

  1465.     .name          = "pal100bars",

  1466.     .description   = NULL_IF_CONFIG_SMALL("Generate PAL 100% color bars."),

  1467.     .priv_size     = sizeof(TestSourceContext),

  1468.     .priv_class    = &pal100bars_class,

  1469.     .init          = pal100bars_init,

  1470.     .uninit        = uninit,

  1471.     .query_formats = smptebars_query_formats,

  1472.     .activate      = activate,

  1473.     .inputs        = NULL,

  1474.     .outputs       = smptebars_outputs,

  1475. };

  1476. 

  1477. #endif  /* CONFIG_PAL100BARS_FILTER */

  1478. 

  1479. #if CONFIG_SMPTEBARS_FILTER

  1480. 

  1481. #define smptebars_options options

  1482. AVFILTER_DEFINE_CLASS(smptebars);

  1483. 

  1484. static void smptebars_fill_picture(AVFilterContext *ctx, AVFrame *picref)

  1485. {

  1486.     TestSourceContext *test = ctx->priv;

  1487.     int r_w, r_h, w_h, p_w, p_h, i, tmp, x = 0;

  1488.     const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format);

  1489. 

  1490.     picref->colorspace = AVCOL_SPC_BT470BG;

  1491. 

  1492.     r_w = FFALIGN((test->w + 6) / 7, 1 << pixdesc->log2_chroma_w);

  1493.     r_h = FFALIGN(test->h * 2 / 3, 1 << pixdesc->log2_chroma_h);

  1494.     w_h = FFALIGN(test->h * 3 / 4 - r_h,  1 << pixdesc->log2_chroma_h);

  1495.     p_w = FFALIGN(r_w * 5 / 4, 1 << pixdesc->log2_chroma_w);

  1496.     p_h = test->h - w_h - r_h;

  1497. 

  1498.     for (i = 0; i < 7; i++) {

  1499.         draw_bar(test, rainbow[i], x, 0,   r_w, r_h, picref);

  1500.         draw_bar(test, wobnair[i], x, r_h, r_w, w_h, picref);

  1501.         x += r_w;

  1502.     }

  1503.     x = 0;

  1504.     draw_bar(test, i_pixel, x, r_h + w_h, p_w, p_h, picref);

  1505.     x += p_w;

  1506.     draw_bar(test, white, x, r_h + w_h, p_w, p_h, picref);

  1507.     x += p_w;

  1508.     draw_bar(test, q_pixel, x, r_h + w_h, p_w, p_h, picref);

  1509.     x += p_w;

  1510.     tmp = FFALIGN(5 * r_w - x,  1 << pixdesc->log2_chroma_w);

  1511.     draw_bar(test, black0, x, r_h + w_h, tmp, p_h, picref);

  1512.     x += tmp;

  1513.     tmp = FFALIGN(r_w / 3,  1 << pixdesc->log2_chroma_w);

  1514.     draw_bar(test, neg4ire, x, r_h + w_h, tmp, p_h, picref);

  1515.     x += tmp;

  1516.     draw_bar(test, black0, x, r_h + w_h, tmp, p_h, picref);

  1517.     x += tmp;

  1518.     draw_bar(test, pos4ire, x, r_h + w_h, tmp, p_h, picref);

  1519.     x += tmp;

  1520.     draw_bar(test, black0, x, r_h + w_h, test->w - x, p_h, picref);

  1521. }

  1522. 

  1523. static av_cold int smptebars_init(AVFilterContext *ctx)

  1524. {

  1525.     TestSourceContext *test = ctx->priv;

  1526. 

  1527.     test->fill_picture_fn = smptebars_fill_picture;

  1528.     test->draw_once = 1;

  1529.     return init(ctx);

  1530. }

  1531. 

  1532. AVFilter ff_vsrc_smptebars = {

  1533.     .name          = "smptebars",

  1534.     .description   = NULL_IF_CONFIG_SMALL("Generate SMPTE color bars."),

  1535.     .priv_size     = sizeof(TestSourceContext),

  1536.     .priv_class    = &smptebars_class,

  1537.     .init          = smptebars_init,

  1538.     .uninit        = uninit,

  1539.     .query_formats = smptebars_query_formats,

  1540.     .activate      = activate,

  1541.     .inputs        = NULL,

  1542.     .outputs       = smptebars_outputs,

  1543. };

  1544. 

  1545. #endif  /* CONFIG_SMPTEBARS_FILTER */

  1546. 

  1547. #if CONFIG_SMPTEHDBARS_FILTER

  1548. 

  1549. #define smptehdbars_options options

  1550. AVFILTER_DEFINE_CLASS(smptehdbars);

  1551. 

  1552. static void smptehdbars_fill_picture(AVFilterContext *ctx, AVFrame *picref)

  1553. {

  1554.     TestSourceContext *test = ctx->priv;

  1555.     int d_w, r_w, r_h, l_w, i, tmp, x = 0, y = 0;

  1556.     const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format);

  1557. 

  1558.     picref->colorspace = AVCOL_SPC_BT709;

  1559. 

  1560.     d_w = FFALIGN(test->w / 8, 1 << pixdesc->log2_chroma_w);

  1561.     r_h = FFALIGN(test->h * 7 / 12, 1 << pixdesc->log2_chroma_h);

  1562.     draw_bar(test, gray40, x, 0, d_w, r_h, picref);

  1563.     x += d_w;

  1564. 

  1565.     r_w = FFALIGN((((test->w + 3) / 4) * 3) / 7, 1 << pixdesc->log2_chroma_w);

  1566.     for (i = 0; i < 7; i++) {

  1567.         draw_bar(test, rainbowhd[i], x, 0, r_w, r_h, picref);

  1568.         x += r_w;

  1569.     }

  1570.     draw_bar(test, gray40, x, 0, test->w - x, r_h, picref);

  1571.     y = r_h;

  1572.     r_h = FFALIGN(test->h / 12, 1 << pixdesc->log2_chroma_h);

  1573.     draw_bar(test, cyan, 0, y, d_w, r_h, picref);

  1574.     x = d_w;

  1575.     draw_bar(test, i_pixel, x, y, r_w, r_h, picref);

  1576.     x += r_w;

  1577.     tmp = r_w * 6;

  1578.     draw_bar(test, rainbowhd[0], x, y, tmp, r_h, picref);

  1579.     x += tmp;

  1580.     l_w = x;

  1581.     draw_bar(test, blue, x, y, test->w - x, r_h, picref);

  1582.     y += r_h;

  1583.     draw_bar(test, yellow, 0, y, d_w, r_h, picref);

  1584.     x = d_w;

  1585.     draw_bar(test, q_pixel, x, y, r_w, r_h, picref);

  1586.     x += r_w;

  1587. 

  1588.     for (i = 0; i < tmp; i += 1 << pixdesc->log2_chroma_w) {

  1589.         uint8_t yramp[4] = {0};

  1590. 

  1591.         yramp[0] = i * 255 / tmp;

  1592.         yramp[1] = 128;

  1593.         yramp[2] = 128;

  1594.         yramp[3] = 255;

  1595. 

  1596.         draw_bar(test, yramp, x, y, 1 << pixdesc->log2_chroma_w, r_h, picref);

  1597.         x += 1 << pixdesc->log2_chroma_w;

  1598.     }

  1599.     draw_bar(test, red, x, y, test->w - x, r_h, picref);

  1600.     y += r_h;

  1601.     draw_bar(test, gray15, 0, y, d_w, test->h - y, picref);

  1602.     x = d_w;

  1603.     tmp = FFALIGN(r_w * 3 / 2, 1 << pixdesc->log2_chroma_w);

  1604.     draw_bar(test, black0, x, y, tmp, test->h - y, picref);

  1605.     x += tmp;

  1606.     tmp = FFALIGN(r_w * 2, 1 << pixdesc->log2_chroma_w);

  1607.     draw_bar(test, white, x, y, tmp, test->h - y, picref);

  1608.     x += tmp;

  1609.     tmp = FFALIGN(r_w * 5 / 6, 1 << pixdesc->log2_chroma_w);

  1610.     draw_bar(test, black0, x, y, tmp, test->h - y, picref);

  1611.     x += tmp;

  1612.     tmp = FFALIGN(r_w / 3, 1 << pixdesc->log2_chroma_w);

  1613.     draw_bar(test,   neg2, x, y, tmp, test->h - y, picref);

  1614.     x += tmp;

  1615.     draw_bar(test, black0, x, y, tmp, test->h - y, picref);

  1616.     x += tmp;

  1617.     draw_bar(test, black2, x, y, tmp, test->h - y, picref);

  1618.     x += tmp;

  1619.     draw_bar(test, black0, x, y, tmp, test->h - y, picref);

  1620.     x += tmp;

  1621.     draw_bar(test, black4, x, y, tmp, test->h - y, picref);

  1622.     x += tmp;

  1623.     r_w = l_w - x;

  1624.     draw_bar(test, black0, x, y, r_w, test->h - y, picref);

  1625.     x += r_w;

  1626.     draw_bar(test, gray15, x, y, test->w - x, test->h - y, picref);

  1627. }

  1628. 

  1629. static av_cold int smptehdbars_init(AVFilterContext *ctx)

  1630. {

  1631.     TestSourceContext *test = ctx->priv;

  1632. 

  1633.     test->fill_picture_fn = smptehdbars_fill_picture;

  1634.     test->draw_once = 1;

  1635.     return init(ctx);

  1636. }

  1637. 

  1638. AVFilter ff_vsrc_smptehdbars = {

  1639.     .name          = "smptehdbars",

  1640.     .description   = NULL_IF_CONFIG_SMALL("Generate SMPTE HD color bars."),

  1641.     .priv_size     = sizeof(TestSourceContext),

  1642.     .priv_class    = &smptehdbars_class,

  1643.     .init          = smptehdbars_init,

  1644.     .uninit        = uninit,

  1645.     .query_formats = smptebars_query_formats,

  1646.     .activate      = activate,

  1647.     .inputs        = NULL,

  1648.     .outputs       = smptebars_outputs,

  1649. };

  1650. 

  1651. #endif  /* CONFIG_SMPTEHDBARS_FILTER */

  1652. #endif  /* CONFIG_SMPTEBARS_FILTER || CONFIG_SMPTEHDBARS_FILTER */

  1653. 

  1654. #if CONFIG_ALLYUV_FILTER

  1655. 

  1656. static const AVOption allyuv_options[] = {

  1657.     COMMON_OPTIONS_NOSIZE

  1658.     { NULL }

  1659. };

  1660. 

  1661. AVFILTER_DEFINE_CLASS(allyuv);

  1662. 

  1663. static void allyuv_fill_picture(AVFilterContext *ctx, AVFrame *frame)

  1664. {

  1665.     const int ys = frame->linesize[0];

  1666.     const int us = frame->linesize[1];

  1667.     const int vs = frame->linesize[2];

  1668.     int x, y, j;

  1669. 

  1670.     for (y = 0; y < 4096; y++) {

  1671.         for (x = 0; x < 2048; x++) {

  1672.             frame->data[0][y * ys + x] = ((x / 8) % 256);

  1673.             frame->data[0][y * ys + 4095 - x] = ((x / 8) % 256);

  1674.         }

  1675. 

  1676.         for (x = 0; x < 2048; x+=8) {

  1677.             for (j = 0; j < 8; j++) {

  1678.                 frame->data[1][vs * y + x + j]        = (y%16 + (j % 8) * 16);

  1679.                 frame->data[1][vs * y + 4095 - x - j] = (128 + y%16 + (j % 8) * 16);

  1680.             }

  1681.         }

  1682. 

  1683.         for (x = 0; x < 4096; x++)

  1684.             frame->data[2][y * us + x] = 256 * y / 4096;

  1685.     }

  1686. }

  1687. 

  1688. static av_cold int allyuv_init(AVFilterContext *ctx)

  1689. {

  1690.     TestSourceContext *test = ctx->priv;

  1691. 

  1692.     test->w = test->h = 4096;

  1693.     test->draw_once = 1;

  1694.     test->fill_picture_fn = allyuv_fill_picture;

  1695.     return init(ctx);

  1696. }

  1697. 

  1698. static int allyuv_query_formats(AVFilterContext *ctx)

  1699. {

  1700.     static const enum AVPixelFormat pix_fmts[] = {

  1701.         AV_PIX_FMT_YUV444P, AV_PIX_FMT_GBRP,

  1702.         AV_PIX_FMT_NONE

  1703.     };

  1704. 

  1705.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  1706.     if (!fmts_list)

  1707.         return AVERROR(ENOMEM);

  1708.     return ff_set_common_formats(ctx, fmts_list);

  1709. }

  1710. 

  1711. static const AVFilterPad avfilter_vsrc_allyuv_outputs[] = {

  1712.     {

  1713.         .name          = "default",

  1714.         .type          = AVMEDIA_TYPE_VIDEO,

  1715.         .config_props  = config_props,

  1716.     },

  1717.     { NULL }

  1718. };

  1719. 

  1720. AVFilter ff_vsrc_allyuv = {

  1721.     .name          = "allyuv",

  1722.     .description   = NULL_IF_CONFIG_SMALL("Generate all yuv colors."),

  1723.     .priv_size     = sizeof(TestSourceContext),

  1724.     .priv_class    = &allyuv_class,

  1725.     .init          = allyuv_init,

  1726.     .uninit        = uninit,

  1727.     .query_formats = allyuv_query_formats,

  1728.     .activate      = activate,

  1729.     .inputs        = NULL,

  1730.     .outputs       = avfilter_vsrc_allyuv_outputs,

  1731. };

  1732. 

  1733. #endif /* CONFIG_ALLYUV_FILTER */

  1734. 

  1735. #if CONFIG_ALLRGB_FILTER

  1736. 

  1737. static const AVOption allrgb_options[] = {

  1738.     COMMON_OPTIONS_NOSIZE

  1739.     { NULL }

  1740. };

  1741. 

  1742. AVFILTER_DEFINE_CLASS(allrgb);

  1743. 

  1744. static void allrgb_fill_picture(AVFilterContext *ctx, AVFrame *frame)

  1745. {

  1746.     unsigned x, y;

  1747.     const int linesize = frame->linesize[0];

  1748.     uint8_t *line = frame->data[0];

  1749. 

  1750.     for (y = 0; y < 4096; y++) {

  1751.         uint8_t *dst = line;

  1752. 

  1753.         for (x = 0; x < 4096; x++) {

  1754.             *dst++ = x;

  1755.             *dst++ = y;

  1756.             *dst++ = (x >> 8) | ((y >> 8) << 4);

  1757.         }

  1758.         line += linesize;

  1759.     }

  1760. }

  1761. 

  1762. static av_cold int allrgb_init(AVFilterContext *ctx)

  1763. {

  1764.     TestSourceContext *test = ctx->priv;

  1765. 

  1766.     test->w = test->h = 4096;

  1767.     test->draw_once = 1;

  1768.     test->fill_picture_fn = allrgb_fill_picture;

  1769.     return init(ctx);

  1770. }

  1771. 

  1772. static int allrgb_config_props(AVFilterLink *outlink)

  1773. {

  1774.     TestSourceContext *test = outlink->src->priv;

  1775. 

  1776.     ff_fill_rgba_map(test->rgba_map, outlink->format);

  1777.     return config_props(outlink);

  1778. }

  1779. 

  1780. static int allrgb_query_formats(AVFilterContext *ctx)

  1781. {

  1782.     static const enum AVPixelFormat pix_fmts[] = {

  1783.         AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE

  1784.     };

  1785. 

  1786.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  1787.     if (!fmts_list)

  1788.         return AVERROR(ENOMEM);

  1789.     return ff_set_common_formats(ctx, fmts_list);

  1790. }

  1791. 

  1792. static const AVFilterPad avfilter_vsrc_allrgb_outputs[] = {

  1793.     {

  1794.         .name          = "default",

  1795.         .type          = AVMEDIA_TYPE_VIDEO,

  1796.         .config_props  = allrgb_config_props,

  1797.     },

  1798.     { NULL }

  1799. };

  1800. 

  1801. AVFilter ff_vsrc_allrgb = {

  1802.     .name          = "allrgb",

  1803.     .description   = NULL_IF_CONFIG_SMALL("Generate all RGB colors."),

  1804.     .priv_size     = sizeof(TestSourceContext),

  1805.     .priv_class    = &allrgb_class,

  1806.     .init          = allrgb_init,

  1807.     .uninit        = uninit,

  1808.     .query_formats = allrgb_query_formats,

  1809.     .activate      = activate,

  1810.     .inputs        = NULL,

  1811.     .outputs       = avfilter_vsrc_allrgb_outputs,

  1812. };

  1813. 

  1814. #endif /* CONFIG_ALLRGB_FILTER */