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