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.
100581 Commits
32 Branches
709MB
Tree: 482aeda8bf
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '482aeda8bf'
${ noResults }
FFmpeg/libavfilter/vsrc_testsrc.c

1810 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. #define NOSIZE_OPTIONS_OFFSET 2

  103. /* Filters using COMMON_OPTIONS_NOSIZE also use the following options

  104.  * via &options[NOSIZE_OPTIONS_OFFSET]. So don't break it. */

  105. static const AVOption options[] = {

  106.     COMMON_OPTIONS

  107.     { NULL }

  108. };

  109. 

  110. static av_cold int init(AVFilterContext *ctx)

  111. {

  112.     TestSourceContext *test = ctx->priv;

  113. 

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

  115.     test->nb_frame = 0;

  116.     test->pts = 0;

  117. 

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

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

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

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

  122.     return 0;

  123. }

  124. 

  125. static av_cold void uninit(AVFilterContext *ctx)

  126. {

  127.     TestSourceContext *test = ctx->priv;

  128. 

  129.     av_frame_free(&test->picref);

  130. }

  131. 

  132. static int config_props(AVFilterLink *outlink)

  133. {

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

  135. 

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

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

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

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

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

  141. 

  142.     return 0;

  143. }

  144. 

  145. static int activate(AVFilterContext *ctx)

  146. {

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

  148.     TestSourceContext *test = ctx->priv;

  149.     AVFrame *frame;

  150. 

  151.     if (!ff_outlink_frame_wanted(outlink))

  152.         return FFERROR_NOT_READY;

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

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

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

  156.         return 0;

  157.     }

  158. 

  159.     if (test->draw_once) {

  160.         if (test->draw_once_reset) {

  161.             av_frame_free(&test->picref);

  162.             test->draw_once_reset = 0;

  163.         }

  164.         if (!test->picref) {

  165.             test->picref =

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

  167.             if (!test->picref)

  168.                 return AVERROR(ENOMEM);

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

  170.         }

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

  172.     } else

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

  174. 

  175.     if (!frame)

  176.         return AVERROR(ENOMEM);

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

  178.     frame->key_frame           = 1;

  179.     frame->interlaced_frame    = 0;

  180.     frame->pict_type           = AV_PICTURE_TYPE_I;

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

  182.     if (!test->draw_once)

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

  184. 

  185.     test->pts++;

  186.     test->nb_frame++;

  187. 

  188.     return ff_filter_frame(outlink, frame);

  189. }

  190. 

  191. #if CONFIG_COLOR_FILTER

  192. 

  193. static const AVOption color_options[] = {

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

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

  196.     COMMON_OPTIONS

  197.     { NULL }

  198. };

  199. 

  200. AVFILTER_DEFINE_CLASS(color);

  201. 

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

  203. {

  204.     TestSourceContext *test = ctx->priv;

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

  206.                       picref->data, picref->linesize,

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

  208. }

  209. 

  210. static av_cold int color_init(AVFilterContext *ctx)

  211. {

  212.     TestSourceContext *test = ctx->priv;

  213.     test->fill_picture_fn = color_fill_picture;

  214.     test->draw_once = 1;

  215.     return init(ctx);

  216. }

  217. 

  218. static int color_query_formats(AVFilterContext *ctx)

  219. {

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

  221. }

  222. 

  223. static int color_config_props(AVFilterLink *inlink)

  224. {

  225.     AVFilterContext *ctx = inlink->src;

  226.     TestSourceContext *test = ctx->priv;

  227.     int ret;

  228. 

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

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

  231. 

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

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

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

  235.         return AVERROR(EINVAL);

  236. 

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

  238.         return ret;

  239. 

  240.     return 0;

  241. }

  242. 

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

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

  245. {

  246.     TestSourceContext *test = ctx->priv;

  247.     int ret;

  248. 

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

  250.     if (ret < 0)

  251.         return ret;

  252. 

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

  254.     test->draw_once_reset = 1;

  255.     return 0;

  256. }

  257. 

  258. static const AVFilterPad color_outputs[] = {

  259.     {

  260.         .name          = "default",

  261.         .type          = AVMEDIA_TYPE_VIDEO,

  262.         .config_props  = color_config_props,

  263.     },

  264.     {  NULL }

  265. };

  266. 

  267. AVFilter ff_vsrc_color = {

  268.     .name            = "color",

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

  270.     .priv_class      = &color_class,

  271.     .priv_size       = sizeof(TestSourceContext),

  272.     .init            = color_init,

  273.     .uninit          = uninit,

  274.     .activate        = activate,

  275.     .query_formats   = color_query_formats,

  276.     .inputs          = NULL,

  277.     .outputs         = color_outputs,

  278.     .process_command = color_process_command,

  279. };

  280. 

  281. #endif /* CONFIG_COLOR_FILTER */

  282. 

  283. #if CONFIG_HALDCLUTSRC_FILTER

  284. 

  285. static const AVOption haldclutsrc_options[] = {

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

  287.     COMMON_OPTIONS_NOSIZE

  288.     { NULL }

  289. };

  290. 

  291. AVFILTER_DEFINE_CLASS(haldclutsrc);

  292. 

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

  294. {

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

  296.     uint32_t alpha = 0;

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

  298.     int level = hc->level;

  299.     float scale;

  300.     const int w = frame->width;

  301.     const int h = frame->height;

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

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

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

  305.     uint8_t rgba_map[4];

  306. 

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

  308. 

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

  310. 

  311.     switch (frame->format) {

  312.     case AV_PIX_FMT_RGB48:

  313.     case AV_PIX_FMT_BGR48:

  314.     case AV_PIX_FMT_RGBA64:

  315.     case AV_PIX_FMT_BGRA64:

  316.         is16bit = 1;

  317.         alpha = 0xffff;

  318.         break;

  319.     case AV_PIX_FMT_RGBA:

  320.     case AV_PIX_FMT_BGRA:

  321.     case AV_PIX_FMT_ARGB:

  322.     case AV_PIX_FMT_ABGR:

  323.         alpha = 0xff;

  324.         break;

  325.     }

  326. 

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

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

  329. 

  330. #define LOAD_CLUT(nbits) do {                                                   \

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

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

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

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

  335.     if (step == 4)                                                              \

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

  337. } while (0)

  338. 

  339.     level *= level;

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

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

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

  343.                 if (!is16bit)

  344.                     LOAD_CLUT(8);

  345.                 else

  346.                     LOAD_CLUT(16);

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

  348.                     x = 0;

  349.                     y++;

  350.                 }

  351.             }

  352.         }

  353.     }

  354. }

  355. 

  356. static av_cold int haldclutsrc_init(AVFilterContext *ctx)

  357. {

  358.     TestSourceContext *hc = ctx->priv;

  359.     hc->fill_picture_fn = haldclutsrc_fill_picture;

  360.     hc->draw_once = 1;

  361.     return init(ctx);

  362. }

  363. 

  364. static int haldclutsrc_query_formats(AVFilterContext *ctx)

  365. {

  366.     static const enum AVPixelFormat pix_fmts[] = {

  367.         AV_PIX_FMT_RGB24,  AV_PIX_FMT_BGR24,

  368.         AV_PIX_FMT_RGBA,   AV_PIX_FMT_BGRA,

  369.         AV_PIX_FMT_ARGB,   AV_PIX_FMT_ABGR,

  370.         AV_PIX_FMT_0RGB,   AV_PIX_FMT_0BGR,

  371.         AV_PIX_FMT_RGB0,   AV_PIX_FMT_BGR0,

  372.         AV_PIX_FMT_RGB48,  AV_PIX_FMT_BGR48,

  373.         AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,

  374.         AV_PIX_FMT_NONE,

  375.     };

  376. 

  377.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  378.     if (!fmts_list)

  379.         return AVERROR(ENOMEM);

  380.     return ff_set_common_formats(ctx, fmts_list);

  381. }

  382. 

  383. static int haldclutsrc_config_props(AVFilterLink *outlink)

  384. {

  385.     AVFilterContext *ctx = outlink->src;

  386.     TestSourceContext *hc = ctx->priv;

  387. 

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

  389.     return config_props(outlink);

  390. }

  391. 

  392. static const AVFilterPad haldclutsrc_outputs[] = {

  393.     {

  394.         .name          = "default",

  395.         .type          = AVMEDIA_TYPE_VIDEO,

  396.         .config_props  = haldclutsrc_config_props,

  397.     },

  398.     {  NULL }

  399. };

  400. 

  401. AVFilter ff_vsrc_haldclutsrc = {

  402.     .name          = "haldclutsrc",

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

  404.     .priv_class    = &haldclutsrc_class,

  405.     .priv_size     = sizeof(TestSourceContext),

  406.     .init          = haldclutsrc_init,

  407.     .uninit        = uninit,

  408.     .query_formats = haldclutsrc_query_formats,

  409.     .activate      = activate,

  410.     .inputs        = NULL,

  411.     .outputs       = haldclutsrc_outputs,

  412. };

  413. #endif /* CONFIG_HALDCLUTSRC_FILTER */

  414. 

  415. #if CONFIG_NULLSRC_FILTER

  416. 

  417. #define nullsrc_options options

  418. AVFILTER_DEFINE_CLASS(nullsrc);

  419. 

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

  421. 

  422. static av_cold int nullsrc_init(AVFilterContext *ctx)

  423. {

  424.     TestSourceContext *test = ctx->priv;

  425. 

  426.     test->fill_picture_fn = nullsrc_fill_picture;

  427.     return init(ctx);

  428. }

  429. 

  430. static const AVFilterPad nullsrc_outputs[] = {

  431.     {

  432.         .name          = "default",

  433.         .type          = AVMEDIA_TYPE_VIDEO,

  434.         .config_props  = config_props,

  435.     },

  436.     { NULL },

  437. };

  438. 

  439. AVFilter ff_vsrc_nullsrc = {

  440.     .name        = "nullsrc",

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

  442.     .init        = nullsrc_init,

  443.     .uninit      = uninit,

  444.     .activate    = activate,

  445.     .priv_size   = sizeof(TestSourceContext),

  446.     .priv_class  = &nullsrc_class,

  447.     .inputs      = NULL,

  448.     .outputs     = nullsrc_outputs,

  449. };

  450. 

  451. #endif /* CONFIG_NULLSRC_FILTER */

  452. 

  453. #if CONFIG_TESTSRC_FILTER

  454. 

  455. static const AVOption testsrc_options[] = {

  456.     COMMON_OPTIONS

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

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

  459.     { NULL }

  460. };

  461. 

  462. AVFILTER_DEFINE_CLASS(testsrc);

  463. 

  464. /**

  465.  * Fill a rectangle with value val.

  466.  *

  467.  * @param val the RGB value to set

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

  469.  * @param dst_linesize linesize of destination

  470.  * @param segment_width width of the segment

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

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

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

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

  475.  */

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

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

  478. {

  479.     int i;

  480.     int step = 3;

  481. 

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

  483.     w *= segment_width * step;

  484.     h *= segment_width;

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

  486.         memset(dst, val, w);

  487.         dst += dst_linesize;

  488.     }

  489. }

  490. 

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

  492.                        int segment_width)

  493. {

  494. #define TOP_HBAR        1

  495. #define MID_HBAR        2

  496. #define BOT_HBAR        4

  497. #define LEFT_TOP_VBAR   8

  498. #define LEFT_BOT_VBAR  16

  499. #define RIGHT_TOP_VBAR 32

  500. #define RIGHT_BOT_VBAR 64

  501.     struct segments {

  502.         int x, y, w, h;

  503.     } segments[] = {

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

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

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

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

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

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

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

  511.     };

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

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

  514.         /* 1 */                                                        RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,

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

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

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

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

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

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

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

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

  523.     };

  524.     unsigned mask = masks[digit];

  525.     int i;

  526. 

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

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

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

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

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

  532. }

  533. 

  534. #define GRADIENT_SIZE (6 * 256)

  535. 

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

  537. {

  538.     TestSourceContext *test = ctx->priv;

  539.     uint8_t *p, *p0;

  540.     int x, y;

  541.     int color, color_rest;

  542.     int icolor;

  543.     int radius;

  544.     int quad0, quad;

  545.     int dquad_x, dquad_y;

  546.     int grad, dgrad, rgrad, drgrad;

  547.     int seg_size;

  548.     int second;

  549.     int i;

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

  551.     int width  = frame->width;

  552.     int height = frame->height;

  553. 

  554.     /* draw colored bars and circle */

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

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

  557.     dquad_y = 1 - height;

  558.     p0 = data;

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

  560.         p = p0;

  561.         color = 0;

  562.         color_rest = 0;

  563.         quad = quad0;

  564.         dquad_x = 1 - width;

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

  566.             icolor = color;

  567.             if (quad < 0)

  568.                 icolor ^= 7;

  569.             quad += dquad_x;

  570.             dquad_x += 2;

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

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

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

  574.             color_rest += 8;

  575.             if (color_rest >= width) {

  576.                 color_rest -= width;

  577.                 color++;

  578.             }

  579.         }

  580.         quad0 += dquad_y;

  581.         dquad_y += 2;

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

  583.     }

  584. 

  585.     /* draw sliding color line */

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

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

  588.         GRADIENT_SIZE;

  589.     rgrad = 0;

  590.     dgrad = GRADIENT_SIZE / width;

  591.     drgrad = GRADIENT_SIZE % width;

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

  593.         *(p++) =

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

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

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

  597.         *(p++) =

  598.             grad >= 4 * 256 ? 0 :

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

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

  601.         *(p++) =

  602.             grad < 2 * 256 ? 0 :

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

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

  605.         grad += dgrad;

  606.         rgrad += drgrad;

  607.         if (rgrad >= GRADIENT_SIZE) {

  608.             grad++;

  609.             rgrad -= GRADIENT_SIZE;

  610.         }

  611.         if (grad >= GRADIENT_SIZE)

  612.             grad -= GRADIENT_SIZE;

  613.     }

  614.     p = p0;

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

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

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

  618.     }

  619. 

  620.     /* draw digits */

  621.     seg_size = width / 80;

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

  623.         int64_t p10decimals = 1;

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

  625.                       ff_exp10(test->nb_decimals);

  626.         if (time >= INT_MAX)

  627.             return;

  628. 

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

  630.             p10decimals *= 10;

  631. 

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

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

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

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

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

  637.             p -= 3 * 8 * seg_size;

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

  639.             second /= 10;

  640.             if (second == 0)

  641.                 break;

  642.         }

  643.     }

  644. }

  645. 

  646. static av_cold int test_init(AVFilterContext *ctx)

  647. {

  648.     TestSourceContext *test = ctx->priv;

  649. 

  650.     test->fill_picture_fn = test_fill_picture;

  651.     return init(ctx);

  652. }

  653. 

  654. static int test_query_formats(AVFilterContext *ctx)

  655. {

  656.     static const enum AVPixelFormat pix_fmts[] = {

  657.         AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE

  658.     };

  659. 

  660.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  661.     if (!fmts_list)

  662.         return AVERROR(ENOMEM);

  663.     return ff_set_common_formats(ctx, fmts_list);

  664. }

  665. 

  666. static const AVFilterPad avfilter_vsrc_testsrc_outputs[] = {

  667.     {

  668.         .name          = "default",

  669.         .type          = AVMEDIA_TYPE_VIDEO,

  670.         .config_props  = config_props,

  671.     },

  672.     { NULL }

  673. };

  674. 

  675. AVFilter ff_vsrc_testsrc = {

  676.     .name          = "testsrc",

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

  678.     .priv_size     = sizeof(TestSourceContext),

  679.     .priv_class    = &testsrc_class,

  680.     .init          = test_init,

  681.     .uninit        = uninit,

  682.     .query_formats = test_query_formats,

  683.     .activate      = activate,

  684.     .inputs        = NULL,

  685.     .outputs       = avfilter_vsrc_testsrc_outputs,

  686. };

  687. 

  688. #endif /* CONFIG_TESTSRC_FILTER */

  689. 

  690. #if CONFIG_TESTSRC2_FILTER

  691. 

  692. static const AVOption testsrc2_options[] = {

  693.     COMMON_OPTIONS

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

  695.     { NULL }

  696. };

  697. 

  698. AVFILTER_DEFINE_CLASS(testsrc2);

  699. 

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

  701. {

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

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

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

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

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

  707. }

  708. 

  709. static uint32_t color_gradient(unsigned index)

  710. {

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

  712.     switch (index >> 8) {

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

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

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

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

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

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

  719.     }

  720.     av_assert0(0);

  721. }

  722. 

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

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

  725. {

  726.     int x = x0;

  727. 

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

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

  730.             x = x0;

  731.             y0 += 16;

  732.             continue;

  733.         }

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

  735.                       frame->width, frame->height,

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

  737.         x += 8;

  738.     }

  739. }

  740. 

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

  742. {

  743.     TestSourceContext *s = ctx->priv;

  744.     FFDrawColor color;

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

  746. 

  747.     /* colored background */

  748.     {

  749.         unsigned i, x = 0, x2;

  750. 

  751.         x = 0;

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

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

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

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

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

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

  758.                                  alpha);

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

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

  761.             x = x2;

  762.         }

  763.     }

  764. 

  765.     /* oblique gradient */

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

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

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

  769. 

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

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

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

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

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

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

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

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

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

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

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

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

  782.                               x, y, dx, 16);

  783.         }

  784.     }

  785. 

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

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

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

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

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

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

  792.         int cycle = l << 2;

  793.         int pos, xh, yh;

  794.         int c, i;

  795. 

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

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

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

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

  800.                  pos < 2 * l ? l :

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

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

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

  804.                  pos < 3 * l ? l :

  805.                                cycle - pos;

  806.             xh -= l >> 1;

  807.             yh -= l >> 1;

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

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

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

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

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

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

  814.                                   x, y, 8, 8);

  815.             }

  816.         }

  817.     }

  818. 

  819.     /* bottom left: beating rectangles */

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

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

  822.         int cycle = l << 3;

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

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

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

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

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

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

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

  830. 

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

  832.         step = size / l;

  833.         size %= l;

  834.         if (step & 1)

  835.             size = l - size;

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

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

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

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

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

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

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

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

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

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

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

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

  848.         if (step == 3)

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

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

  851.     }

  852. 

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

  854.     {

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

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

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

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

  859.         unsigned x, y, i, r;

  860.         uint8_t alpha[256];

  861. 

  862.         r = s->pts;

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

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

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

  866.                     continue;

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

  868.                     r = r * 1664525 + 1013904223;

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

  870.                 }

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

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

  873.                                    frame->width, frame->height,

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

  875.             }

  876.         }

  877.     }

  878. 

  879.     /* bouncing square */

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

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

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

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

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

  885.         if (x > w)

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

  887.         if (y > h)

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

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

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

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

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

  893.                           x, y, 8, 8);

  894.     }

  895. 

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

  897.     {

  898.         char buf[256];

  899.         unsigned time;

  900. 

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

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

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

  904.                            frame->width, frame->height,

  905.                            2, 2, 100, 36);

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

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

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

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

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

  911.     }

  912. }

  913. static av_cold int test2_init(AVFilterContext *ctx)

  914. {

  915.     TestSourceContext *s = ctx->priv;

  916. 

  917.     s->fill_picture_fn = test2_fill_picture;

  918.     return init(ctx);

  919. }

  920. 

  921. static int test2_query_formats(AVFilterContext *ctx)

  922. {

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

  924. }

  925. 

  926. static int test2_config_props(AVFilterLink *inlink)

  927. {

  928.     AVFilterContext *ctx = inlink->src;

  929.     TestSourceContext *s = ctx->priv;

  930. 

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

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

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

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

  935.         return AVERROR(EINVAL);

  936.     return config_props(inlink);

  937. }

  938. 

  939. static const AVFilterPad avfilter_vsrc_testsrc2_outputs[] = {

  940.     {

  941.         .name          = "default",

  942.         .type          = AVMEDIA_TYPE_VIDEO,

  943.         .config_props  = test2_config_props,

  944.     },

  945.     { NULL }

  946. };

  947. 

  948. AVFilter ff_vsrc_testsrc2 = {

  949.     .name          = "testsrc2",

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

  951.     .priv_size     = sizeof(TestSourceContext),

  952.     .priv_class    = &testsrc2_class,

  953.     .init          = test2_init,

  954.     .uninit        = uninit,

  955.     .query_formats = test2_query_formats,

  956.     .activate      = activate,

  957.     .inputs        = NULL,

  958.     .outputs       = avfilter_vsrc_testsrc2_outputs,

  959. };

  960. 

  961. #endif /* CONFIG_TESTSRC2_FILTER */

  962. 

  963. #if CONFIG_RGBTESTSRC_FILTER

  964. 

  965. #define rgbtestsrc_options options

  966. AVFILTER_DEFINE_CLASS(rgbtestsrc);

  967. 

  968. #define R 0

  969. #define G 1

  970. #define B 2

  971. #define A 3

  972. 

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

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

  975.                               uint8_t rgba_map[4])

  976. {

  977.     uint32_t v;

  978.     uint8_t *p;

  979. 

  980.     switch (fmt) {

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

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

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

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

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

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

  987.     case AV_PIX_FMT_RGB24:

  988.     case AV_PIX_FMT_BGR24:

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

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

  991.         AV_WL24(p, v);

  992.         break;

  993.     case AV_PIX_FMT_RGBA:

  994.     case AV_PIX_FMT_BGRA:

  995.     case AV_PIX_FMT_ARGB:

  996.     case AV_PIX_FMT_ABGR:

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

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

  999.         AV_WL32(p, v);

  1000.         break;

  1001.     }

  1002. }

  1003. 

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

  1005. {

  1006.     TestSourceContext *test = ctx->priv;

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

  1008. 

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

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

  1011.              int c = 256*x/w;

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

  1013. 

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

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

  1016.              else                b = c;

  1017. 

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

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

  1020.          }

  1021.      }

  1022. }

  1023. 

  1024. static av_cold int rgbtest_init(AVFilterContext *ctx)

  1025. {

  1026.     TestSourceContext *test = ctx->priv;

  1027. 

  1028.     test->draw_once = 1;

  1029.     test->fill_picture_fn = rgbtest_fill_picture;

  1030.     return init(ctx);

  1031. }

  1032. 

  1033. static int rgbtest_query_formats(AVFilterContext *ctx)

  1034. {

  1035.     static const enum AVPixelFormat pix_fmts[] = {

  1036.         AV_PIX_FMT_RGBA, AV_PIX_FMT_ARGB, AV_PIX_FMT_BGRA, AV_PIX_FMT_ABGR,

  1037.         AV_PIX_FMT_BGR24, AV_PIX_FMT_RGB24,

  1038.         AV_PIX_FMT_RGB444, AV_PIX_FMT_BGR444,

  1039.         AV_PIX_FMT_RGB565, AV_PIX_FMT_BGR565,

  1040.         AV_PIX_FMT_RGB555, AV_PIX_FMT_BGR555,

  1041.         AV_PIX_FMT_NONE

  1042.     };

  1043. 

  1044.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  1045.     if (!fmts_list)

  1046.         return AVERROR(ENOMEM);

  1047.     return ff_set_common_formats(ctx, fmts_list);

  1048. }

  1049. 

  1050. static int rgbtest_config_props(AVFilterLink *outlink)

  1051. {

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

  1053. 

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

  1055.     return config_props(outlink);

  1056. }

  1057. 

  1058. static const AVFilterPad avfilter_vsrc_rgbtestsrc_outputs[] = {

  1059.     {

  1060.         .name          = "default",

  1061.         .type          = AVMEDIA_TYPE_VIDEO,

  1062.         .config_props  = rgbtest_config_props,

  1063.     },

  1064.     { NULL }

  1065. };

  1066. 

  1067. AVFilter ff_vsrc_rgbtestsrc = {

  1068.     .name          = "rgbtestsrc",

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

  1070.     .priv_size     = sizeof(TestSourceContext),

  1071.     .priv_class    = &rgbtestsrc_class,

  1072.     .init          = rgbtest_init,

  1073.     .uninit        = uninit,

  1074.     .query_formats = rgbtest_query_formats,

  1075.     .activate      = activate,

  1076.     .inputs        = NULL,

  1077.     .outputs       = avfilter_vsrc_rgbtestsrc_outputs,

  1078. };

  1079. 

  1080. #endif /* CONFIG_RGBTESTSRC_FILTER */

  1081. 

  1082. #if CONFIG_YUVTESTSRC_FILTER

  1083. 

  1084. #define yuvtestsrc_options options

  1085. AVFILTER_DEFINE_CLASS(yuvtestsrc);

  1086. 

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

  1088. {

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

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

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

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

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

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

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

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

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

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

  1099. 

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

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

  1102.             int c = factor * x / w;

  1103. 

  1104.             ydst[x] = c;

  1105.             udst[x] = mid;

  1106.             vdst[x] = mid;

  1107.         }

  1108. 

  1109.         ydst += ylinesize;

  1110.         udst += ulinesize;

  1111.         vdst += vlinesize;

  1112.     }

  1113. 

  1114.     h += h;

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

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

  1117.             int c = factor * x / w;

  1118. 

  1119.             ydst[x] = mid;

  1120.             udst[x] = c;

  1121.             vdst[x] = mid;

  1122.         }

  1123. 

  1124.         ydst += ylinesize;

  1125.         udst += ulinesize;

  1126.         vdst += vlinesize;

  1127.     }

  1128. 

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

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

  1131.             int c = factor * x / w;

  1132. 

  1133.             ydst[x] = mid;

  1134.             udst[x] = mid;

  1135.             vdst[x] = c;

  1136.         }

  1137. 

  1138.         ydst += ylinesize;

  1139.         udst += ulinesize;

  1140.         vdst += vlinesize;

  1141.     }

  1142. }

  1143. 

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

  1145. {

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

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

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

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

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

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

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

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

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

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

  1156. 

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

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

  1159.             int c = factor * x / w;

  1160. 

  1161.             ydst[x] = c;

  1162.             udst[x] = mid;

  1163.             vdst[x] = mid;

  1164.         }

  1165. 

  1166.         ydst += ylinesize;

  1167.         udst += ulinesize;

  1168.         vdst += vlinesize;

  1169.     }

  1170. 

  1171.     h += h;

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

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

  1174.             int c = factor * x / w;

  1175. 

  1176.             ydst[x] = mid;

  1177.             udst[x] = c;

  1178.             vdst[x] = mid;

  1179.         }

  1180. 

  1181.         ydst += ylinesize;

  1182.         udst += ulinesize;

  1183.         vdst += vlinesize;

  1184.     }

  1185. 

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

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

  1188.             int c = factor * x / w;

  1189. 

  1190.             ydst[x] = mid;

  1191.             udst[x] = mid;

  1192.             vdst[x] = c;

  1193.         }

  1194. 

  1195.         ydst += ylinesize;

  1196.         udst += ulinesize;

  1197.         vdst += vlinesize;

  1198.     }

  1199. }

  1200. 

  1201. static av_cold int yuvtest_init(AVFilterContext *ctx)

  1202. {

  1203.     TestSourceContext *test = ctx->priv;

  1204. 

  1205.     test->draw_once = 1;

  1206.     return init(ctx);

  1207. }

  1208. 

  1209. static int yuvtest_query_formats(AVFilterContext *ctx)

  1210. {

  1211.     static const enum AVPixelFormat pix_fmts[] = {

  1212.         AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,

  1213.         AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10,

  1214.         AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14,

  1215.         AV_PIX_FMT_YUV444P16,

  1216.         AV_PIX_FMT_NONE

  1217.     };

  1218. 

  1219.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  1220.     if (!fmts_list)

  1221.         return AVERROR(ENOMEM);

  1222.     return ff_set_common_formats(ctx, fmts_list);

  1223. }

  1224. 

  1225. static int yuvtest_config_props(AVFilterLink *outlink)

  1226. {

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

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

  1229. 

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

  1231.     return config_props(outlink);

  1232. }

  1233. 

  1234. static const AVFilterPad avfilter_vsrc_yuvtestsrc_outputs[] = {

  1235.     {

  1236.         .name          = "default",

  1237.         .type          = AVMEDIA_TYPE_VIDEO,

  1238.         .config_props  = yuvtest_config_props,

  1239.     },

  1240.     { NULL }

  1241. };

  1242. 

  1243. AVFilter ff_vsrc_yuvtestsrc = {

  1244.     .name          = "yuvtestsrc",

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

  1246.     .priv_size     = sizeof(TestSourceContext),

  1247.     .priv_class    = &yuvtestsrc_class,

  1248.     .init          = yuvtest_init,

  1249.     .uninit        = uninit,

  1250.     .query_formats = yuvtest_query_formats,

  1251.     .activate      = activate,

  1252.     .inputs        = NULL,

  1253.     .outputs       = avfilter_vsrc_yuvtestsrc_outputs,

  1254. };

  1255. 

  1256. #endif /* CONFIG_YUVTESTSRC_FILTER */

  1257. 

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

  1259. 

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

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

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

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

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

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

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

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

  1268. };

  1269. 

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

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

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

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

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

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

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

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

  1278. };

  1279. 

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

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

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

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

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

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

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

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

  1288. };

  1289. 

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

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

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

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

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

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

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

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

  1298. };

  1299. 

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

  1301. 

  1302. /* pluge pulses */

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

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

  1305. 

  1306. /* fudged Q/-I */

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

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

  1309. 

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

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

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

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

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

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

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

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

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

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

  1320. 

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

  1322.                      int x, int y, int w, int h,

  1323.                      AVFrame *frame)

  1324. {

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

  1326.     uint8_t *p, *p0;

  1327.     int plane;

  1328. 

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

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

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

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

  1333. 

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

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

  1336. 

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

  1338.         const int c = color[plane];

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

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

  1341. 

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

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

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

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

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

  1347.         } else {

  1348.             px = x;

  1349.             pw = w;

  1350.             py = y;

  1351.             ph = h;

  1352.         }

  1353. 

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

  1355.         memset(p, c, pw);

  1356.         p += linesize;

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

  1358.             memcpy(p, p0, pw);

  1359.     }

  1360. }

  1361. 

  1362. static int smptebars_query_formats(AVFilterContext *ctx)

  1363. {

  1364.     static const enum AVPixelFormat pix_fmts[] = {

  1365.         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,

  1366.         AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,

  1367.         AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,

  1368.         AV_PIX_FMT_NONE,

  1369.     };

  1370. 

  1371.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  1372.     if (!fmts_list)

  1373.         return AVERROR(ENOMEM);

  1374.     return ff_set_common_formats(ctx, fmts_list);

  1375. }

  1376. 

  1377. static const AVFilterPad smptebars_outputs[] = {

  1378.     {

  1379.         .name          = "default",

  1380.         .type          = AVMEDIA_TYPE_VIDEO,

  1381.         .config_props  = config_props,

  1382.     },

  1383.     { NULL }

  1384. };

  1385. 

  1386. #if CONFIG_PAL75BARS_FILTER

  1387. 

  1388. #define pal75bars_options options

  1389. AVFILTER_DEFINE_CLASS(pal75bars);

  1390. 

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

  1392. {

  1393.     TestSourceContext *test = ctx->priv;

  1394.     int r_w, i, x = 0;

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

  1396. 

  1397.     picref->color_range = AVCOL_RANGE_MPEG;

  1398.     picref->colorspace = AVCOL_SPC_BT470BG;

  1399. 

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

  1401. 

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

  1403.     x += r_w;

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

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

  1406.         x += r_w;

  1407.     }

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

  1409. }

  1410. 

  1411. static av_cold int pal75bars_init(AVFilterContext *ctx)

  1412. {

  1413.     TestSourceContext *test = ctx->priv;

  1414. 

  1415.     test->fill_picture_fn = pal75bars_fill_picture;

  1416.     test->draw_once = 1;

  1417.     return init(ctx);

  1418. }

  1419. 

  1420. AVFilter ff_vsrc_pal75bars = {

  1421.     .name          = "pal75bars",

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

  1423.     .priv_size     = sizeof(TestSourceContext),

  1424.     .priv_class    = &pal75bars_class,

  1425.     .init          = pal75bars_init,

  1426.     .uninit        = uninit,

  1427.     .query_formats = smptebars_query_formats,

  1428.     .activate      = activate,

  1429.     .inputs        = NULL,

  1430.     .outputs       = smptebars_outputs,

  1431. };

  1432. 

  1433. #endif  /* CONFIG_PAL75BARS_FILTER */

  1434. 

  1435. #if CONFIG_PAL100BARS_FILTER

  1436. 

  1437. #define pal100bars_options options

  1438. AVFILTER_DEFINE_CLASS(pal100bars);

  1439. 

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

  1441. {

  1442.     TestSourceContext *test = ctx->priv;

  1443.     int r_w, i, x = 0;

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

  1445. 

  1446.     picref->color_range = AVCOL_RANGE_MPEG;

  1447.     picref->colorspace = AVCOL_SPC_BT470BG;

  1448. 

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

  1450. 

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

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

  1453.         x += r_w;

  1454.     }

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

  1456. }

  1457. 

  1458. static av_cold int pal100bars_init(AVFilterContext *ctx)

  1459. {

  1460.     TestSourceContext *test = ctx->priv;

  1461. 

  1462.     test->fill_picture_fn = pal100bars_fill_picture;

  1463.     test->draw_once = 1;

  1464.     return init(ctx);

  1465. }

  1466. 

  1467. AVFilter ff_vsrc_pal100bars = {

  1468.     .name          = "pal100bars",

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

  1470.     .priv_size     = sizeof(TestSourceContext),

  1471.     .priv_class    = &pal100bars_class,

  1472.     .init          = pal100bars_init,

  1473.     .uninit        = uninit,

  1474.     .query_formats = smptebars_query_formats,

  1475.     .activate      = activate,

  1476.     .inputs        = NULL,

  1477.     .outputs       = smptebars_outputs,

  1478. };

  1479. 

  1480. #endif  /* CONFIG_PAL100BARS_FILTER */

  1481. 

  1482. #if CONFIG_SMPTEBARS_FILTER

  1483. 

  1484. #define smptebars_options options

  1485. AVFILTER_DEFINE_CLASS(smptebars);

  1486. 

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

  1488. {

  1489.     TestSourceContext *test = ctx->priv;

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

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

  1492. 

  1493.     picref->colorspace = AVCOL_SPC_BT470BG;

  1494. 

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

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

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

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

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

  1500. 

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

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

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

  1504.         x += r_w;

  1505.     }

  1506.     x = 0;

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

  1508.     x += p_w;

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

  1510.     x += p_w;

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

  1512.     x += p_w;

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

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

  1515.     x += tmp;

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

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

  1518.     x += tmp;

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

  1520.     x += tmp;

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

  1522.     x += tmp;

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

  1524. }

  1525. 

  1526. static av_cold int smptebars_init(AVFilterContext *ctx)

  1527. {

  1528.     TestSourceContext *test = ctx->priv;

  1529. 

  1530.     test->fill_picture_fn = smptebars_fill_picture;

  1531.     test->draw_once = 1;

  1532.     return init(ctx);

  1533. }

  1534. 

  1535. AVFilter ff_vsrc_smptebars = {

  1536.     .name          = "smptebars",

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

  1538.     .priv_size     = sizeof(TestSourceContext),

  1539.     .priv_class    = &smptebars_class,

  1540.     .init          = smptebars_init,

  1541.     .uninit        = uninit,

  1542.     .query_formats = smptebars_query_formats,

  1543.     .activate      = activate,

  1544.     .inputs        = NULL,

  1545.     .outputs       = smptebars_outputs,

  1546. };

  1547. 

  1548. #endif  /* CONFIG_SMPTEBARS_FILTER */

  1549. 

  1550. #if CONFIG_SMPTEHDBARS_FILTER

  1551. 

  1552. #define smptehdbars_options options

  1553. AVFILTER_DEFINE_CLASS(smptehdbars);

  1554. 

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

  1556. {

  1557.     TestSourceContext *test = ctx->priv;

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

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

  1560. 

  1561.     picref->colorspace = AVCOL_SPC_BT709;

  1562. 

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

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

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

  1566.     x += d_w;

  1567. 

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

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

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

  1571.         x += r_w;

  1572.     }

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

  1574.     y = r_h;

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

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

  1577.     x = d_w;

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

  1579.     x += r_w;

  1580.     tmp = r_w * 6;

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

  1582.     x += tmp;

  1583.     l_w = x;

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

  1585.     y += r_h;

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

  1587.     x = d_w;

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

  1589.     x += r_w;

  1590. 

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

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

  1593. 

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

  1595.         yramp[1] = 128;

  1596.         yramp[2] = 128;

  1597.         yramp[3] = 255;

  1598. 

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

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

  1601.     }

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

  1603.     y += r_h;

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

  1605.     x = d_w;

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

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

  1608.     x += tmp;

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

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

  1611.     x += tmp;

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

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

  1614.     x += tmp;

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

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

  1617.     x += tmp;

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

  1619.     x += tmp;

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

  1621.     x += tmp;

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

  1623.     x += tmp;

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

  1625.     x += tmp;

  1626.     r_w = l_w - x;

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

  1628.     x += r_w;

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

  1630. }

  1631. 

  1632. static av_cold int smptehdbars_init(AVFilterContext *ctx)

  1633. {

  1634.     TestSourceContext *test = ctx->priv;

  1635. 

  1636.     test->fill_picture_fn = smptehdbars_fill_picture;

  1637.     test->draw_once = 1;

  1638.     return init(ctx);

  1639. }

  1640. 

  1641. AVFilter ff_vsrc_smptehdbars = {

  1642.     .name          = "smptehdbars",

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

  1644.     .priv_size     = sizeof(TestSourceContext),

  1645.     .priv_class    = &smptehdbars_class,

  1646.     .init          = smptehdbars_init,

  1647.     .uninit        = uninit,

  1648.     .query_formats = smptebars_query_formats,

  1649.     .activate      = activate,

  1650.     .inputs        = NULL,

  1651.     .outputs       = smptebars_outputs,

  1652. };

  1653. 

  1654. #endif  /* CONFIG_SMPTEHDBARS_FILTER */

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

  1656. 

  1657. #if CONFIG_ALLYUV_FILTER

  1658. 

  1659. #define allyuv_options &options[NOSIZE_OPTIONS_OFFSET]

  1660. AVFILTER_DEFINE_CLASS(allyuv);

  1661. 

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

  1663. {

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

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

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

  1667.     int x, y, j;

  1668. 

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

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

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

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

  1673.         }

  1674. 

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

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

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

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

  1679.             }

  1680.         }

  1681. 

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

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

  1684.     }

  1685. }

  1686. 

  1687. static av_cold int allyuv_init(AVFilterContext *ctx)

  1688. {

  1689.     TestSourceContext *test = ctx->priv;

  1690. 

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

  1692.     test->draw_once = 1;

  1693.     test->fill_picture_fn = allyuv_fill_picture;

  1694.     return init(ctx);

  1695. }

  1696. 

  1697. static int allyuv_query_formats(AVFilterContext *ctx)

  1698. {

  1699.     static const enum AVPixelFormat pix_fmts[] = {

  1700.         AV_PIX_FMT_YUV444P, AV_PIX_FMT_GBRP,

  1701.         AV_PIX_FMT_NONE

  1702.     };

  1703. 

  1704.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  1705.     if (!fmts_list)

  1706.         return AVERROR(ENOMEM);

  1707.     return ff_set_common_formats(ctx, fmts_list);

  1708. }

  1709. 

  1710. static const AVFilterPad avfilter_vsrc_allyuv_outputs[] = {

  1711.     {

  1712.         .name          = "default",

  1713.         .type          = AVMEDIA_TYPE_VIDEO,

  1714.         .config_props  = config_props,

  1715.     },

  1716.     { NULL }

  1717. };

  1718. 

  1719. AVFilter ff_vsrc_allyuv = {

  1720.     .name          = "allyuv",

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

  1722.     .priv_size     = sizeof(TestSourceContext),

  1723.     .priv_class    = &allyuv_class,

  1724.     .init          = allyuv_init,

  1725.     .uninit        = uninit,

  1726.     .query_formats = allyuv_query_formats,

  1727.     .activate      = activate,

  1728.     .inputs        = NULL,

  1729.     .outputs       = avfilter_vsrc_allyuv_outputs,

  1730. };

  1731. 

  1732. #endif /* CONFIG_ALLYUV_FILTER */

  1733. 

  1734. #if CONFIG_ALLRGB_FILTER

  1735. 

  1736. #define allrgb_options &options[NOSIZE_OPTIONS_OFFSET]

  1737. AVFILTER_DEFINE_CLASS(allrgb);

  1738. 

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

  1740. {

  1741.     unsigned x, y;

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

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

  1744. 

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

  1746.         uint8_t *dst = line;

  1747. 

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

  1749.             *dst++ = x;

  1750.             *dst++ = y;

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

  1752.         }

  1753.         line += linesize;

  1754.     }

  1755. }

  1756. 

  1757. static av_cold int allrgb_init(AVFilterContext *ctx)

  1758. {

  1759.     TestSourceContext *test = ctx->priv;

  1760. 

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

  1762.     test->draw_once = 1;

  1763.     test->fill_picture_fn = allrgb_fill_picture;

  1764.     return init(ctx);

  1765. }

  1766. 

  1767. static int allrgb_config_props(AVFilterLink *outlink)

  1768. {

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

  1770. 

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

  1772.     return config_props(outlink);

  1773. }

  1774. 

  1775. static int allrgb_query_formats(AVFilterContext *ctx)

  1776. {

  1777.     static const enum AVPixelFormat pix_fmts[] = {

  1778.         AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE

  1779.     };

  1780. 

  1781.     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

  1782.     if (!fmts_list)

  1783.         return AVERROR(ENOMEM);

  1784.     return ff_set_common_formats(ctx, fmts_list);

  1785. }

  1786. 

  1787. static const AVFilterPad avfilter_vsrc_allrgb_outputs[] = {

  1788.     {

  1789.         .name          = "default",

  1790.         .type          = AVMEDIA_TYPE_VIDEO,

  1791.         .config_props  = allrgb_config_props,

  1792.     },

  1793.     { NULL }

  1794. };

  1795. 

  1796. AVFilter ff_vsrc_allrgb = {

  1797.     .name          = "allrgb",

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

  1799.     .priv_size     = sizeof(TestSourceContext),

  1800.     .priv_class    = &allrgb_class,

  1801.     .init          = allrgb_init,

  1802.     .uninit        = uninit,

  1803.     .query_formats = allrgb_query_formats,

  1804.     .activate      = activate,

  1805.     .inputs        = NULL,

  1806.     .outputs       = avfilter_vsrc_allrgb_outputs,

  1807. };

  1808. 

  1809. #endif /* CONFIG_ALLRGB_FILTER */