FFmpeg
vsrc_testsrc.c
Go to the documentation of this file.
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 "config_components.h"
37 
38 #include <float.h>
39 
40 #include "libavutil/avassert.h"
41 #include "libavutil/common.h"
42 #include "libavutil/ffmath.h"
43 #include "libavutil/opt.h"
44 #include "libavutil/imgutils.h"
45 #include "libavutil/intreadwrite.h"
46 #include "libavutil/parseutils.h"
48 #include "avfilter.h"
49 #include "drawutils.h"
50 #include "filters.h"
51 #include "formats.h"
52 #include "internal.h"
53 #include "video.h"
54 
55 typedef struct TestSourceContext {
56  const AVClass *class;
57  int w, h;
58  int pw, ph;
59  unsigned int nb_frame;
61  int64_t pts;
62  int64_t duration; ///< duration expressed in microseconds
63  AVRational sar; ///< sample aspect ratio
64  int draw_once; ///< draw only the first frame, always put out the same picture
65  int draw_once_reset; ///< draw only the first frame or in case of reset
66  AVFrame *picref; ///< cached reference containing the painted picture
67 
69 
70  /* only used by testsrc */
72 
73  /* only used by testsrc2 */
74  int alpha;
75 
76  /* only used by colorspectrum */
77  int type;
78 
79  /* only used by color */
82  uint8_t color_rgba[4];
83 
84  /* only used by rgbtest */
85  uint8_t rgba_map[4];
87  int depth;
88 
89  /* only used by haldclut */
90  int level;
91 
92  /* only used by zoneplate */
93  int k0, kx, ky, kt;
94  int kxt, kyt, kxy;
95  int kx2, ky2, kt2;
96  int xo, yo, to, kU, kV;
98  uint8_t *lut;
99  int (*fill_slice_fn)(AVFilterContext *ctx, void *arg, int job, int nb_jobs);
101 
102 #define OFFSET(x) offsetof(TestSourceContext, x)
103 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
104 #define FLAGSR AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
105 
106 #define SIZE_OPTIONS \
107  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },\
108  { "s", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "320x240"}, 0, 0, FLAGS },\
109 
110 #define COMMON_OPTIONS_NOSIZE \
111  { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },\
112  { "r", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS },\
113  { "duration", "set video duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },\
114  { "d", "set video duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = -1}, -1, INT64_MAX, FLAGS },\
115  { "sar", "set video sample aspect ratio", OFFSET(sar), AV_OPT_TYPE_RATIONAL, {.dbl= 1}, 0, INT_MAX, FLAGS },
116 
117 #define COMMON_OPTIONS SIZE_OPTIONS COMMON_OPTIONS_NOSIZE
118 
119 #define NOSIZE_OPTIONS_OFFSET 2
120 /* Filters using COMMON_OPTIONS_NOSIZE also use the following options
121  * via &options[NOSIZE_OPTIONS_OFFSET]. So don't break it. */
122 static const AVOption options[] = {
124  { NULL }
125 };
126 
128 {
129  TestSourceContext *test = ctx->priv;
130 
131  test->time_base = av_inv_q(test->frame_rate);
132  test->nb_frame = 0;
133  test->pts = 0;
134 
135  av_log(ctx, AV_LOG_VERBOSE, "size:%dx%d rate:%d/%d duration:%f sar:%d/%d\n",
136  test->w, test->h, test->frame_rate.num, test->frame_rate.den,
137  test->duration < 0 ? -1 : (double)test->duration/1000000,
138  test->sar.num, test->sar.den);
139  return 0;
140 }
141 
143 {
144  TestSourceContext *test = ctx->priv;
145 
146  av_frame_free(&test->picref);
147  av_freep(&test->lut);
148 }
149 
150 static int config_props(AVFilterLink *outlink)
151 {
152  TestSourceContext *test = outlink->src->priv;
153 
154  outlink->w = test->w;
155  outlink->h = test->h;
156  outlink->sample_aspect_ratio = test->sar;
157  outlink->frame_rate = test->frame_rate;
158  outlink->time_base = test->time_base;
159 
160  return 0;
161 }
162 
163 static const AVFilterPad outputs[] = {
164  {
165  .name = "default",
166  .type = AVMEDIA_TYPE_VIDEO,
167  .config_props = config_props,
168  },
169 };
170 
172 {
173  AVFilterLink *outlink = ctx->outputs[0];
174  TestSourceContext *test = ctx->priv;
175  AVFrame *frame;
176 
177  if (!ff_outlink_frame_wanted(outlink))
178  return FFERROR_NOT_READY;
179  if (test->duration >= 0 &&
180  av_rescale_q(test->pts, test->time_base, AV_TIME_BASE_Q) >= test->duration) {
181  ff_outlink_set_status(outlink, AVERROR_EOF, test->pts);
182  return 0;
183  }
184 
185  if (test->draw_once) {
186  if (test->draw_once_reset) {
187  av_frame_free(&test->picref);
188  test->draw_once_reset = 0;
189  }
190  if (!test->picref) {
191  test->picref =
192  ff_get_video_buffer(outlink, test->w, test->h);
193  if (!test->picref)
194  return AVERROR(ENOMEM);
195  test->fill_picture_fn(outlink->src, test->picref);
196  }
197  frame = av_frame_clone(test->picref);
198  } else
199  frame = ff_get_video_buffer(outlink, test->w, test->h);
200 
201  if (!frame)
202  return AVERROR(ENOMEM);
203  frame->pts = test->pts;
204  frame->duration = 1;
206 #if FF_API_INTERLACED_FRAME
208  frame->interlaced_frame = 0;
210 #endif
214  if (!test->draw_once)
215  test->fill_picture_fn(outlink->src, frame);
216 
217  test->pts++;
218  test->nb_frame++;
219 
220  return ff_filter_frame(outlink, frame);
221 }
222 
223 #if CONFIG_COLOR_FILTER
224 
225 static const AVOption color_options[] = {
226  { "color", "set color", OFFSET(color_rgba), AV_OPT_TYPE_COLOR, {.str = "black"}, 0, 0, FLAGSR },
227  { "c", "set color", OFFSET(color_rgba), AV_OPT_TYPE_COLOR, {.str = "black"}, 0, 0, FLAGSR },
229  { NULL }
230 };
231 
233 
234 static void color_fill_picture(AVFilterContext *ctx, AVFrame *picref)
235 {
236  TestSourceContext *test = ctx->priv;
237  ff_fill_rectangle(&test->draw, &test->color,
238  picref->data, picref->linesize,
239  0, 0, test->w, test->h);
240 }
241 
242 static av_cold int color_init(AVFilterContext *ctx)
243 {
244  TestSourceContext *test = ctx->priv;
245  test->fill_picture_fn = color_fill_picture;
246  test->draw_once = 1;
247  return init(ctx);
248 }
249 
250 static int color_query_formats(AVFilterContext *ctx)
251 {
253 }
254 
255 static int color_config_props(AVFilterLink *inlink)
256 {
257  AVFilterContext *ctx = inlink->src;
258  TestSourceContext *test = ctx->priv;
259  int ret;
260 
261  ff_draw_init2(&test->draw, inlink->format, inlink->colorspace,
262  inlink->color_range, 0);
263  ff_draw_color(&test->draw, &test->color, test->color_rgba);
264 
265  test->w = ff_draw_round_to_sub(&test->draw, 0, -1, test->w);
266  test->h = ff_draw_round_to_sub(&test->draw, 1, -1, test->h);
267  if (av_image_check_size(test->w, test->h, 0, ctx) < 0)
268  return AVERROR(EINVAL);
269 
270  if ((ret = config_props(inlink)) < 0)
271  return ret;
272 
273  return 0;
274 }
275 
276 static int color_process_command(AVFilterContext *ctx, const char *cmd, const char *args,
277  char *res, int res_len, int flags)
278 {
279  TestSourceContext *test = ctx->priv;
280  int ret;
281 
282  ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
283  if (ret < 0)
284  return ret;
285 
286  ff_draw_color(&test->draw, &test->color, test->color_rgba);
287  test->draw_once_reset = 1;
288  return 0;
289 }
290 
291 static const AVFilterPad color_outputs[] = {
292  {
293  .name = "default",
294  .type = AVMEDIA_TYPE_VIDEO,
295  .config_props = color_config_props,
296  },
297 };
298 
299 const AVFilter ff_vsrc_color = {
300  .name = "color",
301  .description = NULL_IF_CONFIG_SMALL("Provide an uniformly colored input."),
302  .priv_class = &color_class,
303  .priv_size = sizeof(TestSourceContext),
304  .init = color_init,
305  .uninit = uninit,
306  .activate = activate,
307  .inputs = NULL,
308  FILTER_OUTPUTS(color_outputs),
309  FILTER_QUERY_FUNC(color_query_formats),
310  .process_command = color_process_command,
311 };
312 
313 #endif /* CONFIG_COLOR_FILTER */
314 
315 #if CONFIG_HALDCLUTSRC_FILTER
316 
317 static const AVOption haldclutsrc_options[] = {
318  { "level", "set level", OFFSET(level), AV_OPT_TYPE_INT, {.i64 = 6}, 2, 16, FLAGS },
320  { NULL }
321 };
322 
323 AVFILTER_DEFINE_CLASS(haldclutsrc);
324 
325 static void haldclutsrc_fill_picture(AVFilterContext *ctx, AVFrame *frame)
326 {
327  int i, j, k, x = 0, y = 0, is16bit = 0, step;
328  uint32_t alpha = 0;
329  const TestSourceContext *hc = ctx->priv;
330  int level = hc->level;
331  float scale;
332  const int w = frame->width;
333  const int h = frame->height;
334  uint8_t *data = frame->data[0];
335  const ptrdiff_t linesize = frame->linesize[0];
337  const int depth = desc->comp[0].depth;
338  const int planar = desc->flags & AV_PIX_FMT_FLAG_PLANAR;
340  uint8_t rgba_map[4];
341 
342  av_assert0(w == h && w == level*level*level);
343 
344  ff_fill_rgba_map(rgba_map, frame->format);
345 
346  alpha = (1 << depth) - 1;
347  is16bit = depth > 8;
348 
349  step = av_get_padded_bits_per_pixel(desc) >> (3 + is16bit);
350  scale = ((float)alpha) / (level*level - 1);
351 
352 #define LOAD_CLUT(nbits) do { \
353  uint##nbits##_t *dst = ((uint##nbits##_t *)(data + y*linesize)) + x*step; \
354  dst[rgba_map[0]] = av_clip_uint##nbits(i * scale); \
355  dst[rgba_map[1]] = av_clip_uint##nbits(j * scale); \
356  dst[rgba_map[2]] = av_clip_uint##nbits(k * scale); \
357  if (step == 4) \
358  dst[rgba_map[3]] = alpha; \
359 } while (0)
360 
361 #define LOAD_CLUT_PLANAR(type, nbits) do { \
362  type *dst = ((type *)(frame->data[2] + y*frame->linesize[2])) + x; \
363  dst[0] = av_clip_uintp2(i * scale, nbits); \
364  dst = ((type *)(frame->data[0] + y*frame->linesize[0])) + x; \
365  dst[0] = av_clip_uintp2(j * scale, nbits); \
366  dst = ((type *)(frame->data[1] + y*frame->linesize[1])) + x; \
367  dst[0] = av_clip_uintp2(k * scale, nbits); \
368  if (planes == 4) { \
369  dst = ((type *)(frame->data[3] + y*linesize)) + x; \
370  dst[0] = alpha; \
371  } \
372 } while (0)
373 
374  level *= level;
375  for (k = 0; k < level; k++) {
376  for (j = 0; j < level; j++) {
377  for (i = 0; i < level; i++) {
378  if (!planar) {
379  if (!is16bit)
380  LOAD_CLUT(8);
381  else
382  LOAD_CLUT(16);
383  } else {
384  switch (depth) {
385  case 8: LOAD_CLUT_PLANAR(uint8_t, 8); break;
386  case 9: LOAD_CLUT_PLANAR(uint16_t, 9); break;
387  case 10: LOAD_CLUT_PLANAR(uint16_t,10); break;
388  case 12: LOAD_CLUT_PLANAR(uint16_t,12); break;
389  case 14: LOAD_CLUT_PLANAR(uint16_t,14); break;
390  case 16: LOAD_CLUT_PLANAR(uint16_t,16); break;
391  }
392  }
393  if (++x == w) {
394  x = 0;
395  y++;
396  }
397  }
398  }
399  }
400 }
401 
402 static av_cold int haldclutsrc_init(AVFilterContext *ctx)
403 {
404  TestSourceContext *hc = ctx->priv;
405  hc->fill_picture_fn = haldclutsrc_fill_picture;
406  hc->draw_once = 1;
407  return init(ctx);
408 }
409 
410 static const enum AVPixelFormat haldclutsrc_pix_fmts[] = {
425 };
426 
427 static int haldclutsrc_config_props(AVFilterLink *outlink)
428 {
429  AVFilterContext *ctx = outlink->src;
430  TestSourceContext *hc = ctx->priv;
431 
432  hc->w = hc->h = hc->level * hc->level * hc->level;
433  return config_props(outlink);
434 }
435 
436 static const AVFilterPad haldclutsrc_outputs[] = {
437  {
438  .name = "default",
439  .type = AVMEDIA_TYPE_VIDEO,
440  .config_props = haldclutsrc_config_props,
441  },
442 };
443 
445  .name = "haldclutsrc",
446  .description = NULL_IF_CONFIG_SMALL("Provide an identity Hald CLUT."),
447  .priv_class = &haldclutsrc_class,
448  .priv_size = sizeof(TestSourceContext),
449  .init = haldclutsrc_init,
450  .uninit = uninit,
451  .activate = activate,
452  .inputs = NULL,
453  FILTER_OUTPUTS(haldclutsrc_outputs),
454  FILTER_PIXFMTS_ARRAY(haldclutsrc_pix_fmts),
455 };
456 #endif /* CONFIG_HALDCLUTSRC_FILTER */
457 
458 AVFILTER_DEFINE_CLASS_EXT(nullsrc_yuvtestsrc, "nullsrc/yuvtestsrc", options);
459 
460 #if CONFIG_NULLSRC_FILTER
461 
462 static void nullsrc_fill_picture(AVFilterContext *ctx, AVFrame *picref) { }
463 
464 static av_cold int nullsrc_init(AVFilterContext *ctx)
465 {
466  TestSourceContext *test = ctx->priv;
467 
468  test->fill_picture_fn = nullsrc_fill_picture;
469  return init(ctx);
470 }
471 
472 const AVFilter ff_vsrc_nullsrc = {
473  .name = "nullsrc",
474  .description = NULL_IF_CONFIG_SMALL("Null video source, return unprocessed video frames."),
475  .priv_class = &nullsrc_yuvtestsrc_class,
476  .init = nullsrc_init,
477  .uninit = uninit,
478  .activate = activate,
479  .priv_size = sizeof(TestSourceContext),
480  .inputs = NULL,
482 };
483 
484 #endif /* CONFIG_NULLSRC_FILTER */
485 
486 #if CONFIG_TESTSRC_FILTER
487 
488 static const AVOption testsrc_options[] = {
490  { "decimals", "set number of decimals to show", OFFSET(nb_decimals), AV_OPT_TYPE_INT, {.i64=0}, 0, 17, FLAGS },
491  { "n", "set number of decimals to show", OFFSET(nb_decimals), AV_OPT_TYPE_INT, {.i64=0}, 0, 17, FLAGS },
492  { NULL }
493 };
494 
495 AVFILTER_DEFINE_CLASS(testsrc);
496 
497 /**
498  * Fill a rectangle with value val.
499  *
500  * @param val the RGB value to set
501  * @param dst pointer to the destination buffer to fill
502  * @param dst_linesize linesize of destination
503  * @param segment_width width of the segment
504  * @param x horizontal coordinate where to draw the rectangle in the destination buffer
505  * @param y horizontal coordinate where to draw the rectangle in the destination buffer
506  * @param w width of the rectangle to draw, expressed as a number of segment_width units
507  * @param h height of the rectangle to draw, expressed as a number of segment_width units
508  */
509 static void draw_rectangle(unsigned val, uint8_t *dst, ptrdiff_t dst_linesize, int segment_width,
510  int x, int y, int w, int h)
511 {
512  int i;
513  int step = 3;
514 
515  dst += segment_width * (step * x + y * dst_linesize);
516  w *= segment_width * step;
517  h *= segment_width;
518  for (i = 0; i < h; i++) {
519  memset(dst, val, w);
520  dst += dst_linesize;
521  }
522 }
523 
524 static void draw_digit(int digit, uint8_t *dst, ptrdiff_t dst_linesize,
525  int segment_width)
526 {
527 #define TOP_HBAR 1
528 #define MID_HBAR 2
529 #define BOT_HBAR 4
530 #define LEFT_TOP_VBAR 8
531 #define LEFT_BOT_VBAR 16
532 #define RIGHT_TOP_VBAR 32
533 #define RIGHT_BOT_VBAR 64
534  struct segments {
535  int x, y, w, h;
536  } segments[] = {
537  { 1, 0, 5, 1 }, /* TOP_HBAR */
538  { 1, 6, 5, 1 }, /* MID_HBAR */
539  { 1, 12, 5, 1 }, /* BOT_HBAR */
540  { 0, 1, 1, 5 }, /* LEFT_TOP_VBAR */
541  { 0, 7, 1, 5 }, /* LEFT_BOT_VBAR */
542  { 6, 1, 1, 5 }, /* RIGHT_TOP_VBAR */
543  { 6, 7, 1, 5 } /* RIGHT_BOT_VBAR */
544  };
545  static const unsigned char masks[10] = {
546  /* 0 */ TOP_HBAR |BOT_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
547  /* 1 */ RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
548  /* 2 */ TOP_HBAR|MID_HBAR|BOT_HBAR|LEFT_BOT_VBAR |RIGHT_TOP_VBAR,
549  /* 3 */ TOP_HBAR|MID_HBAR|BOT_HBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
550  /* 4 */ MID_HBAR |LEFT_TOP_VBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
551  /* 5 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR |RIGHT_BOT_VBAR,
552  /* 6 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR |RIGHT_BOT_VBAR,
553  /* 7 */ TOP_HBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
554  /* 8 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
555  /* 9 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
556  };
557  unsigned mask = masks[digit];
558  int i;
559 
560  draw_rectangle(0, dst, dst_linesize, segment_width, 0, 0, 8, 13);
561  for (i = 0; i < FF_ARRAY_ELEMS(segments); i++)
562  if (mask & (1<<i))
563  draw_rectangle(255, dst, dst_linesize, segment_width,
564  segments[i].x, segments[i].y, segments[i].w, segments[i].h);
565 }
566 
567 #define GRADIENT_SIZE (6 * 256)
568 
569 static void test_fill_picture(AVFilterContext *ctx, AVFrame *frame)
570 {
571  TestSourceContext *test = ctx->priv;
572  uint8_t *p, *p0;
573  int x, y;
574  int color, color_rest;
575  int icolor;
576  int radius;
577  int quad0, quad;
578  int dquad_x, dquad_y;
579  int grad, dgrad, rgrad, drgrad;
580  int seg_size;
581  int second;
582  int i;
583  uint8_t *data = frame->data[0];
584  int width = frame->width;
585  int height = frame->height;
586 
587  /* draw colored bars and circle */
588  radius = (width + height) / 4;
589  quad0 = width * width / 4 + height * height / 4 - radius * radius;
590  dquad_y = 1 - height;
591  p0 = data;
592  for (y = 0; y < height; y++) {
593  p = p0;
594  color = 0;
595  color_rest = 0;
596  quad = quad0;
597  dquad_x = 1 - width;
598  for (x = 0; x < width; x++) {
599  icolor = color;
600  if (quad < 0)
601  icolor ^= 7;
602  quad += dquad_x;
603  dquad_x += 2;
604  *(p++) = icolor & 1 ? 255 : 0;
605  *(p++) = icolor & 2 ? 255 : 0;
606  *(p++) = icolor & 4 ? 255 : 0;
607  color_rest += 8;
608  if (color_rest >= width) {
609  color_rest -= width;
610  color++;
611  }
612  }
613  quad0 += dquad_y;
614  dquad_y += 2;
615  p0 += frame->linesize[0];
616  }
617 
618  /* draw sliding color line */
619  p0 = p = data + frame->linesize[0] * (height * 3/4);
620  grad = (256 * test->nb_frame * test->time_base.num / test->time_base.den) %
621  GRADIENT_SIZE;
622  rgrad = 0;
623  dgrad = GRADIENT_SIZE / width;
624  drgrad = GRADIENT_SIZE % width;
625  for (x = 0; x < width; x++) {
626  *(p++) =
627  grad < 256 || grad >= 5 * 256 ? 255 :
628  grad >= 2 * 256 && grad < 4 * 256 ? 0 :
629  grad < 2 * 256 ? 2 * 256 - 1 - grad : grad - 4 * 256;
630  *(p++) =
631  grad >= 4 * 256 ? 0 :
632  grad >= 1 * 256 && grad < 3 * 256 ? 255 :
633  grad < 1 * 256 ? grad : 4 * 256 - 1 - grad;
634  *(p++) =
635  grad < 2 * 256 ? 0 :
636  grad >= 3 * 256 && grad < 5 * 256 ? 255 :
637  grad < 3 * 256 ? grad - 2 * 256 : 6 * 256 - 1 - grad;
638  grad += dgrad;
639  rgrad += drgrad;
640  if (rgrad >= GRADIENT_SIZE) {
641  grad++;
642  rgrad -= GRADIENT_SIZE;
643  }
644  if (grad >= GRADIENT_SIZE)
645  grad -= GRADIENT_SIZE;
646  }
647  p = p0;
648  for (y = height / 8; y > 0; y--) {
649  memcpy(p+frame->linesize[0], p, 3 * width);
650  p += frame->linesize[0];
651  }
652 
653  /* draw digits */
654  seg_size = width / 80;
655  if (seg_size >= 1 && height >= 13 * seg_size) {
656  int64_t p10decimals = 1;
657  double time = av_q2d(test->time_base) * test->nb_frame *
658  ff_exp10(test->nb_decimals);
659  if (time >= INT_MAX)
660  return;
661 
662  for (x = 0; x < test->nb_decimals; x++)
663  p10decimals *= 10;
664 
665  second = av_rescale_rnd(test->nb_frame * test->time_base.num, p10decimals, test->time_base.den, AV_ROUND_ZERO);
666  x = width - (width - seg_size * 64) / 2;
667  y = (height - seg_size * 13) / 2;
668  p = data + (x*3 + y * frame->linesize[0]);
669  for (i = 0; i < 8; i++) {
670  p -= 3 * 8 * seg_size;
671  draw_digit(second % 10, p, frame->linesize[0], seg_size);
672  second /= 10;
673  if (second == 0)
674  break;
675  }
676  }
677 }
678 
679 static av_cold int test_init(AVFilterContext *ctx)
680 {
681  TestSourceContext *test = ctx->priv;
682 
683  test->fill_picture_fn = test_fill_picture;
684  return init(ctx);
685 }
686 
687 const AVFilter ff_vsrc_testsrc = {
688  .name = "testsrc",
689  .description = NULL_IF_CONFIG_SMALL("Generate test pattern."),
690  .priv_size = sizeof(TestSourceContext),
691  .priv_class = &testsrc_class,
692  .init = test_init,
693  .uninit = uninit,
694  .activate = activate,
695  .inputs = NULL,
698 };
699 
700 #endif /* CONFIG_TESTSRC_FILTER */
701 
702 #if CONFIG_TESTSRC2_FILTER
703 
704 static const AVOption testsrc2_options[] = {
706  { "alpha", "set global alpha (opacity)", OFFSET(alpha), AV_OPT_TYPE_INT, {.i64 = 255}, 0, 255, FLAGS },
707  { NULL }
708 };
709 
710 AVFILTER_DEFINE_CLASS(testsrc2);
711 
712 static void set_color(TestSourceContext *s, FFDrawColor *color, uint32_t argb)
713 {
714  uint8_t rgba[4] = { (argb >> 16) & 0xFF,
715  (argb >> 8) & 0xFF,
716  (argb >> 0) & 0xFF,
717  (argb >> 24) & 0xFF, };
718  ff_draw_color(&s->draw, color, rgba);
719 }
720 
721 static uint32_t color_gradient(unsigned index)
722 {
723  unsigned si = index & 0xFF, sd = 0xFF - si;
724  switch (index >> 8) {
725  case 0: return 0xFF0000 + (si << 8);
726  case 1: return 0x00FF00 + (sd << 16);
727  case 2: return 0x00FF00 + (si << 0);
728  case 3: return 0x0000FF + (sd << 8);
729  case 4: return 0x0000FF + (si << 16);
730  case 5: return 0xFF0000 + (sd << 0);
731  default: av_assert0(0); return 0;
732  }
733 }
734 
736  int x0, int y0, const uint8_t *text)
737 {
738  int x = x0;
739 
740  for (; *text; text++) {
741  if (*text == '\n') {
742  x = x0;
743  y0 += 16;
744  continue;
745  }
747  frame->width, frame->height,
748  avpriv_vga16_font + *text * 16, 1, 8, 16, 0, 0, x, y0);
749  x += 8;
750  }
751 }
752 
753 static void test2_fill_picture(AVFilterContext *ctx, AVFrame *frame)
754 {
755  TestSourceContext *s = ctx->priv;
757  unsigned alpha = (uint32_t)s->alpha << 24;
758 
759  /* colored background */
760  {
761  unsigned i, x = 0, x2;
762 
763  x = 0;
764  for (i = 1; i < 7; i++) {
765  x2 = av_rescale(i, s->w, 6);
766  x2 = ff_draw_round_to_sub(&s->draw, 0, 0, x2);
767  set_color(s, &color, ((i & 1) ? 0xFF0000 : 0) |
768  ((i & 2) ? 0x00FF00 : 0) |
769  ((i & 4) ? 0x0000FF : 0) |
770  alpha);
772  x, 0, x2 - x, frame->height);
773  x = x2;
774  }
775  }
776 
777  /* oblique gradient */
778  /* note: too slow if using blending */
779  if (s->h >= 64) {
780  unsigned x, dx, y0, y, g0, g;
781 
782  dx = ff_draw_round_to_sub(&s->draw, 0, +1, 1);
783  y0 = av_rescale_q(s->pts, s->time_base, av_make_q(2, s->h - 16));
784  g0 = av_rescale_q(s->pts, s->time_base, av_make_q(1, 128));
785  for (x = 0; x < s->w; x += dx) {
786  g = (av_rescale(x, 6 * 256, s->w) + g0) % (6 * 256);
787  set_color(s, &color, color_gradient(g) | alpha);
788  y = y0 + av_rescale(x, s->h / 2, s->w);
789  y %= 2 * (s->h - 16);
790  if (y > s->h - 16)
791  y = 2 * (s->h - 16) - y;
792  y = ff_draw_round_to_sub(&s->draw, 1, 0, y);
794  x, y, dx, 16);
795  }
796  }
797 
798  /* top right: draw clock hands */
799  if (s->w >= 64 && s->h >= 64) {
800  int l = (FFMIN(s->w, s->h) - 32) >> 1;
801  int steps = FFMAX(4, l >> 5);
802  int xc = (s->w >> 2) + (s->w >> 1);
803  int yc = (s->h >> 2);
804  int cycle = l << 2;
805  int pos, xh, yh;
806  int c, i;
807 
808  for (c = 0; c < 3; c++) {
809  set_color(s, &color, (0xBBBBBB ^ (0xFF << (c << 3))) | alpha);
810  pos = av_rescale_q(s->pts, s->time_base, av_make_q(64 >> (c << 1), cycle)) % cycle;
811  xh = pos < 1 * l ? pos :
812  pos < 2 * l ? l :
813  pos < 3 * l ? 3 * l - pos : 0;
814  yh = pos < 1 * l ? 0 :
815  pos < 2 * l ? pos - l :
816  pos < 3 * l ? l :
817  cycle - pos;
818  xh -= l >> 1;
819  yh -= l >> 1;
820  for (i = 1; i <= steps; i++) {
821  int x = av_rescale(xh, i, steps) + xc;
822  int y = av_rescale(yh, i, steps) + yc;
823  x = ff_draw_round_to_sub(&s->draw, 0, -1, x);
824  y = ff_draw_round_to_sub(&s->draw, 1, -1, y);
826  x, y, 8, 8);
827  }
828  }
829  }
830 
831  /* bottom left: beating rectangles */
832  if (s->w >= 64 && s->h >= 64) {
833  int l = (FFMIN(s->w, s->h) - 16) >> 2;
834  int cycle = l << 3;
835  int xc = (s->w >> 2);
836  int yc = (s->h >> 2) + (s->h >> 1);
837  int xm1 = ff_draw_round_to_sub(&s->draw, 0, -1, xc - 8);
838  int xm2 = ff_draw_round_to_sub(&s->draw, 0, +1, xc + 8);
839  int ym1 = ff_draw_round_to_sub(&s->draw, 1, -1, yc - 8);
840  int ym2 = ff_draw_round_to_sub(&s->draw, 1, +1, yc + 8);
841  int size, step, x1, x2, y1, y2;
842 
843  size = av_rescale_q(s->pts, s->time_base, av_make_q(4, cycle));
844  step = size / l;
845  size %= l;
846  if (step & 1)
847  size = l - size;
848  step = (step >> 1) & 3;
849  set_color(s, &color, 0xFF808080);
850  x1 = ff_draw_round_to_sub(&s->draw, 0, -1, xc - 4 - size);
851  x2 = ff_draw_round_to_sub(&s->draw, 0, +1, xc + 4 + size);
852  y1 = ff_draw_round_to_sub(&s->draw, 1, -1, yc - 4 - size);
853  y2 = ff_draw_round_to_sub(&s->draw, 1, +1, yc + 4 + size);
854  if (step == 0 || step == 2)
856  x1, ym1, x2 - x1, ym2 - ym1);
857  if (step == 1 || step == 2)
859  xm1, y1, xm2 - xm1, y2 - y1);
860  if (step == 3)
862  x1, y1, x2 - x1, y2 - y1);
863  }
864 
865  /* bottom right: checker with random noise */
866  {
867  unsigned xmin = av_rescale(5, s->w, 8);
868  unsigned xmax = av_rescale(7, s->w, 8);
869  unsigned ymin = av_rescale(5, s->h, 8);
870  unsigned ymax = av_rescale(7, s->h, 8);
871  unsigned x, y, i, r;
872  uint8_t alpha[256];
873 
874  r = s->pts;
875  for (y = ymin; y + 15 < ymax; y += 16) {
876  for (x = xmin; x + 15 < xmax; x += 16) {
877  if ((x ^ y) & 16)
878  continue;
879  for (i = 0; i < 256; i++) {
880  r = r * 1664525 + 1013904223;
881  alpha[i] = r >> 24;
882  }
883  set_color(s, &color, 0xFF00FF80);
885  frame->width, frame->height,
886  alpha, 16, 16, 16, 3, 0, x, y);
887  }
888  }
889  }
890 
891  /* bouncing square */
892  if (s->w >= 16 && s->h >= 16) {
893  unsigned w = s->w - 8;
894  unsigned h = s->h - 8;
895  unsigned x = av_rescale_q(s->pts, s->time_base, av_make_q(233, 55 * w)) % (w << 1);
896  unsigned y = av_rescale_q(s->pts, s->time_base, av_make_q(233, 89 * h)) % (h << 1);
897  if (x > w)
898  x = (w << 1) - x;
899  if (y > h)
900  y = (h << 1) - y;
901  x = ff_draw_round_to_sub(&s->draw, 0, -1, x);
902  y = ff_draw_round_to_sub(&s->draw, 1, -1, y);
903  set_color(s, &color, 0xFF8000FF);
905  x, y, 8, 8);
906  }
907 
908  /* top right: draw frame time and frame number */
909  {
910  char buf[256];
911  unsigned time;
912 
913  time = av_rescale_q(s->pts, s->time_base, av_make_q(1, 1000)) % 86400000;
914  set_color(s, &color, 0xC0000000);
916  frame->width, frame->height,
917  2, 2, 100, 36);
918  set_color(s, &color, 0xFFFF8000);
919  snprintf(buf, sizeof(buf), "%02d:%02d:%02d.%03d\n%12"PRIi64,
920  time / 3600000, (time / 60000) % 60, (time / 1000) % 60,
921  time % 1000, s->pts);
922  draw_text(s, frame, &color, 4, 4, buf);
923  }
924 }
925 static av_cold int test2_init(AVFilterContext *ctx)
926 {
927  TestSourceContext *s = ctx->priv;
928 
929  s->fill_picture_fn = test2_fill_picture;
930  return init(ctx);
931 }
932 
933 static int test2_query_formats(AVFilterContext *ctx)
934 {
936 }
937 
938 static int test2_config_props(AVFilterLink *inlink)
939 {
940  AVFilterContext *ctx = inlink->src;
941  TestSourceContext *s = ctx->priv;
942 
943  av_assert0(ff_draw_init2(&s->draw, inlink->format, inlink->colorspace,
944  inlink->color_range, 0) >= 0);
945  s->w = ff_draw_round_to_sub(&s->draw, 0, -1, s->w);
946  s->h = ff_draw_round_to_sub(&s->draw, 1, -1, s->h);
947  if (av_image_check_size(s->w, s->h, 0, ctx) < 0)
948  return AVERROR(EINVAL);
949  return config_props(inlink);
950 }
951 
952 static const AVFilterPad avfilter_vsrc_testsrc2_outputs[] = {
953  {
954  .name = "default",
955  .type = AVMEDIA_TYPE_VIDEO,
956  .config_props = test2_config_props,
957  },
958 };
959 
960 const AVFilter ff_vsrc_testsrc2 = {
961  .name = "testsrc2",
962  .description = NULL_IF_CONFIG_SMALL("Generate another test pattern."),
963  .priv_size = sizeof(TestSourceContext),
964  .priv_class = &testsrc2_class,
965  .init = test2_init,
966  .uninit = uninit,
967  .activate = activate,
968  .inputs = NULL,
969  FILTER_OUTPUTS(avfilter_vsrc_testsrc2_outputs),
970  FILTER_QUERY_FUNC(test2_query_formats),
971 };
972 
973 #endif /* CONFIG_TESTSRC2_FILTER */
974 
975 #if CONFIG_RGBTESTSRC_FILTER
976 
977 static const AVOption rgbtestsrc_options[] = {
979  { "complement", "set complement colors", OFFSET(complement), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
980  { "co", "set complement colors", OFFSET(complement), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
981  { NULL }
982 };
983 
984 AVFILTER_DEFINE_CLASS(rgbtestsrc);
985 
986 #define R 0
987 #define G 1
988 #define B 2
989 #define A 3
990 
991 static void rgbtest_put_pixel(uint8_t *dstp[4], int dst_linesizep[4],
992  int x, int y, unsigned r, unsigned g, unsigned b, enum AVPixelFormat fmt,
993  uint8_t rgba_map[4])
994 {
995  uint8_t *dst = dstp[0];
996  ptrdiff_t dst_linesize = dst_linesizep[0];
997  uint32_t v;
998  uint8_t *p;
999  uint16_t *p16;
1000 
1001  switch (fmt) {
1002  case AV_PIX_FMT_BGR444: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r >> 4) << 8) | ((g >> 4) << 4) | (b >> 4); break;
1003  case AV_PIX_FMT_RGB444: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b >> 4) << 8) | ((g >> 4) << 4) | (r >> 4); break;
1004  case AV_PIX_FMT_BGR555: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r>>3)<<10) | ((g>>3)<<5) | (b>>3); break;
1005  case AV_PIX_FMT_RGB555: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b>>3)<<10) | ((g>>3)<<5) | (r>>3); break;
1006  case AV_PIX_FMT_BGR565: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r>>3)<<11) | ((g>>2)<<5) | (b>>3); break;
1007  case AV_PIX_FMT_RGB565: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b>>3)<<11) | ((g>>2)<<5) | (r>>3); break;
1008  case AV_PIX_FMT_RGB24:
1009  case AV_PIX_FMT_BGR24:
1010  v = (r << (rgba_map[R]*8)) + (g << (rgba_map[G]*8)) + (b << (rgba_map[B]*8));
1011  p = dst + 3*x + y*dst_linesize;
1012  AV_WL24(p, v);
1013  break;
1014  case AV_PIX_FMT_RGBA:
1015  case AV_PIX_FMT_BGRA:
1016  case AV_PIX_FMT_ARGB:
1017  case AV_PIX_FMT_ABGR:
1018  v = (r << (rgba_map[R]*8)) + (g << (rgba_map[G]*8)) + (b << (rgba_map[B]*8)) + (255U << (rgba_map[A]*8));
1019  p = dst + 4*x + y*dst_linesize;
1020  AV_WL32(p, v);
1021  break;
1022  case AV_PIX_FMT_GBRP:
1023  p = dstp[0] + x + y * dst_linesize;
1024  p[0] = g;
1025  p = dstp[1] + x + y * dst_linesizep[1];
1026  p[0] = b;
1027  p = dstp[2] + x + y * dst_linesizep[2];
1028  p[0] = r;
1029  break;
1030  case AV_PIX_FMT_GBRP9:
1031  case AV_PIX_FMT_GBRP10:
1032  case AV_PIX_FMT_GBRP12:
1033  case AV_PIX_FMT_GBRP14:
1034  case AV_PIX_FMT_GBRP16:
1035  p16 = (uint16_t *)(dstp[0] + x*2 + y * dst_linesizep[0]);
1036  p16[0] = g;
1037  p16 = (uint16_t *)(dstp[1] + x*2 + y * dst_linesizep[1]);
1038  p16[0] = b;
1039  p16 = (uint16_t *)(dstp[2] + x*2 + y * dst_linesizep[2]);
1040  p16[0] = r;
1041  break;
1042  }
1043 }
1044 
1045 static void rgbtest_fill_picture_complement(AVFilterContext *ctx, AVFrame *frame)
1046 {
1047  TestSourceContext *test = ctx->priv;
1048  int x, y, w = frame->width, h = frame->height;
1049 
1050  for (y = 0; y < h; y++) {
1051  for (x = 0; x < w; x++) {
1052  int c = (1 << FFMAX(test->depth, 8))*x/w;
1053  int r = 0, g = 0, b = 0;
1054 
1055  if (6*y < h ) r = c;
1056  else if (6*y < 2*h) g = c, b = c;
1057  else if (6*y < 3*h) g = c;
1058  else if (6*y < 4*h) r = c, b = c;
1059  else if (6*y < 5*h) b = c;
1060  else r = c, g = c;
1061 
1062  rgbtest_put_pixel(frame->data, frame->linesize, x, y, r, g, b,
1063  ctx->outputs[0]->format, test->rgba_map);
1064  }
1065  }
1066 }
1067 
1068 static void rgbtest_fill_picture(AVFilterContext *ctx, AVFrame *frame)
1069 {
1070  TestSourceContext *test = ctx->priv;
1071  int x, y, w = frame->width, h = frame->height;
1072 
1073  for (y = 0; y < h; y++) {
1074  for (x = 0; x < w; x++) {
1075  int c = (1 << FFMAX(test->depth, 8))*x/w;
1076  int r = 0, g = 0, b = 0;
1077 
1078  if (3*y < h ) r = c;
1079  else if (3*y < 2*h) g = c;
1080  else b = c;
1081 
1082  rgbtest_put_pixel(frame->data, frame->linesize, x, y, r, g, b,
1083  ctx->outputs[0]->format, test->rgba_map);
1084  }
1085  }
1086 }
1087 
1088 static av_cold int rgbtest_init(AVFilterContext *ctx)
1089 {
1090  TestSourceContext *test = ctx->priv;
1091 
1092  test->draw_once = 1;
1093  test->fill_picture_fn = test->complement ? rgbtest_fill_picture_complement : rgbtest_fill_picture;
1094  return init(ctx);
1095 }
1096 
1097 static const enum AVPixelFormat rgbtest_pix_fmts[] = {
1106  };
1107 
1108 static int rgbtest_config_props(AVFilterLink *outlink)
1109 {
1110  TestSourceContext *test = outlink->src->priv;
1112 
1113  test->depth = desc->comp[0].depth;
1114  ff_fill_rgba_map(test->rgba_map, outlink->format);
1115  return config_props(outlink);
1116 }
1117 
1118 static const AVFilterPad avfilter_vsrc_rgbtestsrc_outputs[] = {
1119  {
1120  .name = "default",
1121  .type = AVMEDIA_TYPE_VIDEO,
1122  .config_props = rgbtest_config_props,
1123  },
1124 };
1125 
1126 const AVFilter ff_vsrc_rgbtestsrc = {
1127  .name = "rgbtestsrc",
1128  .description = NULL_IF_CONFIG_SMALL("Generate RGB test pattern."),
1129  .priv_size = sizeof(TestSourceContext),
1130  .priv_class = &rgbtestsrc_class,
1131  .init = rgbtest_init,
1132  .uninit = uninit,
1133  .activate = activate,
1134  .inputs = NULL,
1135  FILTER_OUTPUTS(avfilter_vsrc_rgbtestsrc_outputs),
1136  FILTER_PIXFMTS_ARRAY(rgbtest_pix_fmts),
1137 };
1138 
1139 #endif /* CONFIG_RGBTESTSRC_FILTER */
1140 
1141 #if CONFIG_YUVTESTSRC_FILTER
1142 
1143 static void yuvtest_fill_picture8(AVFilterContext *ctx, AVFrame *frame)
1144 {
1145  int x, y, w = frame->width, h = frame->height / 3;
1147  const int factor = 1 << desc->comp[0].depth;
1148  const int mid = 1 << (desc->comp[0].depth - 1);
1149  uint8_t *ydst = frame->data[0];
1150  uint8_t *udst = frame->data[1];
1151  uint8_t *vdst = frame->data[2];
1152  ptrdiff_t ylinesize = frame->linesize[0];
1153  ptrdiff_t ulinesize = frame->linesize[1];
1154  ptrdiff_t vlinesize = frame->linesize[2];
1155 
1156  for (y = 0; y < h; y++) {
1157  for (x = 0; x < w; x++) {
1158  int c = factor * x / w;
1159 
1160  ydst[x] = c;
1161  udst[x] = mid;
1162  vdst[x] = mid;
1163  }
1164 
1165  ydst += ylinesize;
1166  udst += ulinesize;
1167  vdst += vlinesize;
1168  }
1169 
1170  h += h;
1171  for (; y < h; y++) {
1172  for (x = 0; x < w; x++) {
1173  int c = factor * x / w;
1174 
1175  ydst[x] = mid;
1176  udst[x] = c;
1177  vdst[x] = mid;
1178  }
1179 
1180  ydst += ylinesize;
1181  udst += ulinesize;
1182  vdst += vlinesize;
1183  }
1184 
1185  for (; y < frame->height; y++) {
1186  for (x = 0; x < w; x++) {
1187  int c = factor * x / w;
1188 
1189  ydst[x] = mid;
1190  udst[x] = mid;
1191  vdst[x] = c;
1192  }
1193 
1194  ydst += ylinesize;
1195  udst += ulinesize;
1196  vdst += vlinesize;
1197  }
1198 }
1199 
1200 static void yuvtest_fill_picture16(AVFilterContext *ctx, AVFrame *frame)
1201 {
1202  int x, y, w = frame->width, h = frame->height / 3;
1204  const int factor = 1 << desc->comp[0].depth;
1205  const int mid = 1 << (desc->comp[0].depth - 1);
1206  uint16_t *ydst = (uint16_t *)frame->data[0];
1207  uint16_t *udst = (uint16_t *)frame->data[1];
1208  uint16_t *vdst = (uint16_t *)frame->data[2];
1209  ptrdiff_t ylinesize = frame->linesize[0] / 2;
1210  ptrdiff_t ulinesize = frame->linesize[1] / 2;
1211  ptrdiff_t vlinesize = frame->linesize[2] / 2;
1212 
1213  for (y = 0; y < h; y++) {
1214  for (x = 0; x < w; x++) {
1215  int c = factor * x / w;
1216 
1217  ydst[x] = c;
1218  udst[x] = mid;
1219  vdst[x] = mid;
1220  }
1221 
1222  ydst += ylinesize;
1223  udst += ulinesize;
1224  vdst += vlinesize;
1225  }
1226 
1227  h += h;
1228  for (; y < h; y++) {
1229  for (x = 0; x < w; x++) {
1230  int c = factor * x / w;
1231 
1232  ydst[x] = mid;
1233  udst[x] = c;
1234  vdst[x] = mid;
1235  }
1236 
1237  ydst += ylinesize;
1238  udst += ulinesize;
1239  vdst += vlinesize;
1240  }
1241 
1242  for (; y < frame->height; y++) {
1243  for (x = 0; x < w; x++) {
1244  int c = factor * x / w;
1245 
1246  ydst[x] = mid;
1247  udst[x] = mid;
1248  vdst[x] = c;
1249  }
1250 
1251  ydst += ylinesize;
1252  udst += ulinesize;
1253  vdst += vlinesize;
1254  }
1255 }
1256 
1257 static av_cold int yuvtest_init(AVFilterContext *ctx)
1258 {
1259  TestSourceContext *test = ctx->priv;
1260 
1261  test->draw_once = 1;
1262  return init(ctx);
1263 }
1264 
1265 static const enum AVPixelFormat yuvtest_pix_fmts[] = {
1271 };
1272 
1273 static int yuvtest_config_props(AVFilterLink *outlink)
1274 {
1275  TestSourceContext *test = outlink->src->priv;
1277 
1278  test->fill_picture_fn = desc->comp[0].depth > 8 ? yuvtest_fill_picture16 : yuvtest_fill_picture8;
1279  return config_props(outlink);
1280 }
1281 
1282 static const AVFilterPad avfilter_vsrc_yuvtestsrc_outputs[] = {
1283  {
1284  .name = "default",
1285  .type = AVMEDIA_TYPE_VIDEO,
1286  .config_props = yuvtest_config_props,
1287  },
1288 };
1289 
1290 const AVFilter ff_vsrc_yuvtestsrc = {
1291  .name = "yuvtestsrc",
1292  .description = NULL_IF_CONFIG_SMALL("Generate YUV test pattern."),
1293  .priv_size = sizeof(TestSourceContext),
1294  .priv_class = &nullsrc_yuvtestsrc_class,
1295  .init = yuvtest_init,
1296  .uninit = uninit,
1297  .activate = activate,
1298  .inputs = NULL,
1299  FILTER_OUTPUTS(avfilter_vsrc_yuvtestsrc_outputs),
1300  FILTER_PIXFMTS_ARRAY(yuvtest_pix_fmts),
1301 };
1302 
1303 #endif /* CONFIG_YUVTESTSRC_FILTER */
1304 
1305 #if CONFIG_PAL75BARS_FILTER || CONFIG_PAL100BARS_FILTER || CONFIG_SMPTEBARS_FILTER || CONFIG_SMPTEHDBARS_FILTER
1306 
1307 static const uint8_t rainbow[7][4] = {
1308  { 180, 128, 128, 255 }, /* 75% white */
1309  { 162, 44, 142, 255 }, /* 75% yellow */
1310  { 131, 156, 44, 255 }, /* 75% cyan */
1311  { 112, 72, 58, 255 }, /* 75% green */
1312  { 84, 184, 198, 255 }, /* 75% magenta */
1313  { 65, 100, 212, 255 }, /* 75% red */
1314  { 35, 212, 114, 255 }, /* 75% blue */
1315 };
1316 
1317 static const uint8_t rainbow100[7][4] = {
1318  { 235, 128, 128, 255 }, /* 100% white */
1319  { 210, 16, 146, 255 }, /* 100% yellow */
1320  { 170, 166, 16, 255 }, /* 100% cyan */
1321  { 145, 54, 34, 255 }, /* 100% green */
1322  { 106, 202, 222, 255 }, /* 100% magenta */
1323  { 81, 90, 240, 255 }, /* 100% red */
1324  { 41, 240, 110, 255 }, /* 100% blue */
1325 };
1326 
1327 static const uint8_t rainbowhd[7][4] = {
1328  { 180, 128, 128, 255 }, /* 75% white */
1329  { 168, 44, 136, 255 }, /* 75% yellow */
1330  { 145, 147, 44, 255 }, /* 75% cyan */
1331  { 133, 63, 52, 255 }, /* 75% green */
1332  { 63, 193, 204, 255 }, /* 75% magenta */
1333  { 51, 109, 212, 255 }, /* 75% red */
1334  { 28, 212, 120, 255 }, /* 75% blue */
1335 };
1336 
1337 static const uint8_t wobnair[7][4] = {
1338  { 35, 212, 114, 255 }, /* 75% blue */
1339  { 19, 128, 128, 255 }, /* 7.5% intensity black */
1340  { 84, 184, 198, 255 }, /* 75% magenta */
1341  { 19, 128, 128, 255 }, /* 7.5% intensity black */
1342  { 131, 156, 44, 255 }, /* 75% cyan */
1343  { 19, 128, 128, 255 }, /* 7.5% intensity black */
1344  { 180, 128, 128, 255 }, /* 75% white */
1345 };
1346 
1347 static const uint8_t white[4] = { 235, 128, 128, 255 };
1348 
1349 /* pluge pulses */
1350 static const uint8_t neg4ire[4] = { 7, 128, 128, 255 };
1351 static const uint8_t pos4ire[4] = { 24, 128, 128, 255 };
1352 
1353 /* fudged Q/-I */
1354 static const uint8_t i_pixel[4] = { 57, 156, 97, 255 };
1355 static const uint8_t q_pixel[4] = { 44, 171, 147, 255 };
1356 
1357 static const uint8_t gray40[4] = { 104, 128, 128, 255 };
1358 static const uint8_t gray15[4] = { 49, 128, 128, 255 };
1359 static const uint8_t cyan[4] = { 188, 154, 16, 255 };
1360 static const uint8_t yellow[4] = { 219, 16, 138, 255 };
1361 static const uint8_t blue[4] = { 32, 240, 118, 255 };
1362 static const uint8_t red[4] = { 63, 102, 240, 255 };
1363 static const uint8_t black0[4] = { 16, 128, 128, 255 };
1364 static const uint8_t black2[4] = { 20, 128, 128, 255 };
1365 static const uint8_t black4[4] = { 25, 128, 128, 255 };
1366 static const uint8_t neg2[4] = { 12, 128, 128, 255 };
1367 
1368 static void draw_bar(TestSourceContext *test, const uint8_t color[4],
1369  int x, int y, int w, int h,
1370  AVFrame *frame)
1371 {
1373  uint8_t *p, *p0;
1374  int plane;
1375 
1376  x = FFMIN(x, test->w - 1);
1377  y = FFMIN(y, test->h - 1);
1378  w = FFMAX(FFMIN(w, test->w - x), 0);
1379  h = FFMAX(FFMIN(h, test->h - y), 0);
1380 
1381  av_assert0(x + w <= test->w);
1382  av_assert0(y + h <= test->h);
1383 
1384  for (plane = 0; frame->data[plane]; plane++) {
1385  const int c = color[plane];
1386  const ptrdiff_t linesize = frame->linesize[plane];
1387  int i, px, py, pw, ph;
1388 
1389  if (plane == 1 || plane == 2) {
1390  px = x >> desc->log2_chroma_w;
1391  pw = AV_CEIL_RSHIFT(w, desc->log2_chroma_w);
1392  py = y >> desc->log2_chroma_h;
1393  ph = AV_CEIL_RSHIFT(h, desc->log2_chroma_h);
1394  } else {
1395  px = x;
1396  pw = w;
1397  py = y;
1398  ph = h;
1399  }
1400 
1401  p0 = p = frame->data[plane] + py * linesize + px;
1402  memset(p, c, pw);
1403  p += linesize;
1404  for (i = 1; i < ph; i++, p += linesize)
1405  memcpy(p, p0, pw);
1406  }
1407 }
1408 
1409 static const enum AVPixelFormat smptebars_pix_fmts[] = {
1414 };
1415 
1416 static int smptebars_query_formats(AVFilterContext *ctx)
1417 {
1418  enum AVColorSpace csp;
1419  int ret;
1420 
1421  if (!strcmp(ctx->name, "smptehdbars")) {
1422  csp = AVCOL_SPC_BT709;
1423  } else {
1424  csp = AVCOL_SPC_BT470BG;
1425  }
1426 
1428  return ret;
1430  return ret;
1431  return ff_set_common_formats_from_list(ctx, smptebars_pix_fmts);
1432 }
1433 
1434 AVFILTER_DEFINE_CLASS_EXT(palbars, "pal(75|100)bars", options);
1435 
1436 #if CONFIG_PAL75BARS_FILTER
1437 
1438 static void pal75bars_fill_picture(AVFilterContext *ctx, AVFrame *picref)
1439 {
1440  TestSourceContext *test = ctx->priv;
1441  int r_w, i, x = 0;
1442  const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format);
1443 
1444  r_w = FFALIGN((test->w + 7) / 8, 1 << pixdesc->log2_chroma_w);
1445 
1446  draw_bar(test, white, x, 0, r_w, test->h, picref);
1447  x += r_w;
1448  for (i = 1; i < 7; i++) {
1449  draw_bar(test, rainbow[i], x, 0, r_w, test->h, picref);
1450  x += r_w;
1451  }
1452  draw_bar(test, black0, x, 0, r_w, test->h, picref);
1453 }
1454 
1455 static av_cold int pal75bars_init(AVFilterContext *ctx)
1456 {
1457  TestSourceContext *test = ctx->priv;
1458 
1459  test->fill_picture_fn = pal75bars_fill_picture;
1460  test->draw_once = 1;
1461  return init(ctx);
1462 }
1463 
1464 const AVFilter ff_vsrc_pal75bars = {
1465  .name = "pal75bars",
1466  .description = NULL_IF_CONFIG_SMALL("Generate PAL 75% color bars."),
1467  .priv_class = &palbars_class,
1468  .priv_size = sizeof(TestSourceContext),
1469  .init = pal75bars_init,
1470  .uninit = uninit,
1471  .activate = activate,
1472  .inputs = NULL,
1474  FILTER_QUERY_FUNC(smptebars_query_formats),
1475 };
1476 
1477 #endif /* CONFIG_PAL75BARS_FILTER */
1478 
1479 #if CONFIG_PAL100BARS_FILTER
1480 
1481 static void pal100bars_fill_picture(AVFilterContext *ctx, AVFrame *picref)
1482 {
1483  TestSourceContext *test = ctx->priv;
1484  int r_w, i, x = 0;
1485  const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format);
1486 
1487  r_w = FFALIGN((test->w + 7) / 8, 1 << pixdesc->log2_chroma_w);
1488 
1489  for (i = 0; i < 7; i++) {
1490  draw_bar(test, rainbow100[i], x, 0, r_w, test->h, picref);
1491  x += r_w;
1492  }
1493  draw_bar(test, black0, x, 0, r_w, test->h, picref);
1494 }
1495 
1496 static av_cold int pal100bars_init(AVFilterContext *ctx)
1497 {
1498  TestSourceContext *test = ctx->priv;
1499 
1500  test->fill_picture_fn = pal100bars_fill_picture;
1501  test->draw_once = 1;
1502  return init(ctx);
1503 }
1504 
1505 const AVFilter ff_vsrc_pal100bars = {
1506  .name = "pal100bars",
1507  .description = NULL_IF_CONFIG_SMALL("Generate PAL 100% color bars."),
1508  .priv_class = &palbars_class,
1509  .priv_size = sizeof(TestSourceContext),
1510  .init = pal100bars_init,
1511  .uninit = uninit,
1512  .activate = activate,
1513  .inputs = NULL,
1515  FILTER_QUERY_FUNC(smptebars_query_formats),
1516 };
1517 
1518 #endif /* CONFIG_PAL100BARS_FILTER */
1519 
1520 AVFILTER_DEFINE_CLASS_EXT(smptebars, "smpte(hd)bars", options);
1521 
1522 #if CONFIG_SMPTEBARS_FILTER
1523 
1524 static void smptebars_fill_picture(AVFilterContext *ctx, AVFrame *picref)
1525 {
1526  TestSourceContext *test = ctx->priv;
1527  int r_w, r_h, w_h, p_w, p_h, i, tmp, x = 0;
1528  const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format);
1529 
1530  r_w = FFALIGN((test->w + 6) / 7, 1 << pixdesc->log2_chroma_w);
1531  r_h = FFALIGN(test->h * 2 / 3, 1 << pixdesc->log2_chroma_h);
1532  w_h = FFALIGN(test->h * 3 / 4 - r_h, 1 << pixdesc->log2_chroma_h);
1533  p_w = FFALIGN(r_w * 5 / 4, 1 << pixdesc->log2_chroma_w);
1534  p_h = test->h - w_h - r_h;
1535 
1536  for (i = 0; i < 7; i++) {
1537  draw_bar(test, rainbow[i], x, 0, r_w, r_h, picref);
1538  draw_bar(test, wobnair[i], x, r_h, r_w, w_h, picref);
1539  x += r_w;
1540  }
1541  x = 0;
1542  draw_bar(test, i_pixel, x, r_h + w_h, p_w, p_h, picref);
1543  x += p_w;
1544  draw_bar(test, white, x, r_h + w_h, p_w, p_h, picref);
1545  x += p_w;
1546  draw_bar(test, q_pixel, x, r_h + w_h, p_w, p_h, picref);
1547  x += p_w;
1548  tmp = FFALIGN(5 * r_w - x, 1 << pixdesc->log2_chroma_w);
1549  draw_bar(test, black0, x, r_h + w_h, tmp, p_h, picref);
1550  x += tmp;
1551  tmp = FFALIGN(r_w / 3, 1 << pixdesc->log2_chroma_w);
1552  draw_bar(test, neg4ire, x, r_h + w_h, tmp, p_h, picref);
1553  x += tmp;
1554  draw_bar(test, black0, x, r_h + w_h, tmp, p_h, picref);
1555  x += tmp;
1556  draw_bar(test, pos4ire, x, r_h + w_h, tmp, p_h, picref);
1557  x += tmp;
1558  draw_bar(test, black0, x, r_h + w_h, test->w - x, p_h, picref);
1559 }
1560 
1561 static av_cold int smptebars_init(AVFilterContext *ctx)
1562 {
1563  TestSourceContext *test = ctx->priv;
1564 
1565  test->fill_picture_fn = smptebars_fill_picture;
1566  test->draw_once = 1;
1567  return init(ctx);
1568 }
1569 
1570 const AVFilter ff_vsrc_smptebars = {
1571  .name = "smptebars",
1572  .description = NULL_IF_CONFIG_SMALL("Generate SMPTE color bars."),
1573  .priv_size = sizeof(TestSourceContext),
1574  .priv_class = &smptebars_class,
1575  .init = smptebars_init,
1576  .uninit = uninit,
1577  .activate = activate,
1578  .inputs = NULL,
1580  FILTER_QUERY_FUNC(smptebars_query_formats),
1581 };
1582 
1583 #endif /* CONFIG_SMPTEBARS_FILTER */
1584 
1585 #if CONFIG_SMPTEHDBARS_FILTER
1586 
1587 static void smptehdbars_fill_picture(AVFilterContext *ctx, AVFrame *picref)
1588 {
1589  TestSourceContext *test = ctx->priv;
1590  int d_w, r_w, r_h, l_w, i, tmp, x = 0, y = 0;
1591  const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(picref->format);
1592 
1593  d_w = FFALIGN(test->w / 8, 1 << pixdesc->log2_chroma_w);
1594  r_h = FFALIGN(test->h * 7 / 12, 1 << pixdesc->log2_chroma_h);
1595  draw_bar(test, gray40, x, 0, d_w, r_h, picref);
1596  x += d_w;
1597 
1598  r_w = FFALIGN((((test->w + 3) / 4) * 3) / 7, 1 << pixdesc->log2_chroma_w);
1599  for (i = 0; i < 7; i++) {
1600  draw_bar(test, rainbowhd[i], x, 0, r_w, r_h, picref);
1601  x += r_w;
1602  }
1603  draw_bar(test, gray40, x, 0, test->w - x, r_h, picref);
1604  y = r_h;
1605  r_h = FFALIGN(test->h / 12, 1 << pixdesc->log2_chroma_h);
1606  draw_bar(test, cyan, 0, y, d_w, r_h, picref);
1607  x = d_w;
1608  draw_bar(test, i_pixel, x, y, r_w, r_h, picref);
1609  x += r_w;
1610  tmp = r_w * 6;
1611  draw_bar(test, rainbowhd[0], x, y, tmp, r_h, picref);
1612  x += tmp;
1613  l_w = x;
1614  draw_bar(test, blue, x, y, test->w - x, r_h, picref);
1615  y += r_h;
1616  draw_bar(test, yellow, 0, y, d_w, r_h, picref);
1617  x = d_w;
1618  draw_bar(test, q_pixel, x, y, r_w, r_h, picref);
1619  x += r_w;
1620 
1621  for (i = 0; i < tmp; i += 1 << pixdesc->log2_chroma_w) {
1622  uint8_t yramp[4] = {0};
1623 
1624  yramp[0] = i * 255 / tmp;
1625  yramp[1] = 128;
1626  yramp[2] = 128;
1627  yramp[3] = 255;
1628 
1629  draw_bar(test, yramp, x, y, 1 << pixdesc->log2_chroma_w, r_h, picref);
1630  x += 1 << pixdesc->log2_chroma_w;
1631  }
1632  draw_bar(test, red, x, y, test->w - x, r_h, picref);
1633  y += r_h;
1634  draw_bar(test, gray15, 0, y, d_w, test->h - y, picref);
1635  x = d_w;
1636  tmp = FFALIGN(r_w * 3 / 2, 1 << pixdesc->log2_chroma_w);
1637  draw_bar(test, black0, x, y, tmp, test->h - y, picref);
1638  x += tmp;
1639  tmp = FFALIGN(r_w * 2, 1 << pixdesc->log2_chroma_w);
1640  draw_bar(test, white, x, y, tmp, test->h - y, picref);
1641  x += tmp;
1642  tmp = FFALIGN(r_w * 5 / 6, 1 << pixdesc->log2_chroma_w);
1643  draw_bar(test, black0, x, y, tmp, test->h - y, picref);
1644  x += tmp;
1645  tmp = FFALIGN(r_w / 3, 1 << pixdesc->log2_chroma_w);
1646  draw_bar(test, neg2, x, y, tmp, test->h - y, picref);
1647  x += tmp;
1648  draw_bar(test, black0, x, y, tmp, test->h - y, picref);
1649  x += tmp;
1650  draw_bar(test, black2, x, y, tmp, test->h - y, picref);
1651  x += tmp;
1652  draw_bar(test, black0, x, y, tmp, test->h - y, picref);
1653  x += tmp;
1654  draw_bar(test, black4, x, y, tmp, test->h - y, picref);
1655  x += tmp;
1656  r_w = l_w - x;
1657  draw_bar(test, black0, x, y, r_w, test->h - y, picref);
1658  x += r_w;
1659  draw_bar(test, gray15, x, y, test->w - x, test->h - y, picref);
1660 }
1661 
1662 static av_cold int smptehdbars_init(AVFilterContext *ctx)
1663 {
1664  TestSourceContext *test = ctx->priv;
1665 
1666  test->fill_picture_fn = smptehdbars_fill_picture;
1667  test->draw_once = 1;
1668  return init(ctx);
1669 }
1670 
1671 const AVFilter ff_vsrc_smptehdbars = {
1672  .name = "smptehdbars",
1673  .description = NULL_IF_CONFIG_SMALL("Generate SMPTE HD color bars."),
1674  .priv_class = &smptebars_class,
1675  .priv_size = sizeof(TestSourceContext),
1676  .init = smptehdbars_init,
1677  .uninit = uninit,
1678  .activate = activate,
1679  .inputs = NULL,
1681  FILTER_QUERY_FUNC(smptebars_query_formats),
1682 };
1683 
1684 #endif /* CONFIG_SMPTEHDBARS_FILTER */
1685 #endif /* CONFIG_SMPTEBARS_FILTER || CONFIG_SMPTEHDBARS_FILTER */
1686 
1687 AVFILTER_DEFINE_CLASS_EXT(allyuv_allrgb, "allyuv/allrgb",
1689 
1690 #if CONFIG_ALLYUV_FILTER
1691 
1692 static void allyuv_fill_picture(AVFilterContext *ctx, AVFrame *frame)
1693 {
1694  const ptrdiff_t ys = frame->linesize[0];
1695  const ptrdiff_t us = frame->linesize[1];
1696  const ptrdiff_t vs = frame->linesize[2];
1697  int x, y, j;
1698 
1699  for (y = 0; y < 4096; y++) {
1700  for (x = 0; x < 2048; x++) {
1701  frame->data[0][y * ys + x] = ((x / 8) % 256);
1702  frame->data[0][y * ys + 4095 - x] = ((x / 8) % 256);
1703  }
1704 
1705  for (x = 0; x < 2048; x+=8) {
1706  for (j = 0; j < 8; j++) {
1707  frame->data[1][vs * y + x + j] = (y%16 + (j % 8) * 16);
1708  frame->data[1][vs * y + 4095 - x - j] = (128 + y%16 + (j % 8) * 16);
1709  }
1710  }
1711 
1712  for (x = 0; x < 4096; x++)
1713  frame->data[2][y * us + x] = 256 * y / 4096;
1714  }
1715 }
1716 
1717 static av_cold int allyuv_init(AVFilterContext *ctx)
1718 {
1719  TestSourceContext *test = ctx->priv;
1720 
1721  test->w = test->h = 4096;
1722  test->draw_once = 1;
1723  test->fill_picture_fn = allyuv_fill_picture;
1724  return init(ctx);
1725 }
1726 
1727 const AVFilter ff_vsrc_allyuv = {
1728  .name = "allyuv",
1729  .description = NULL_IF_CONFIG_SMALL("Generate all yuv colors."),
1730  .priv_size = sizeof(TestSourceContext),
1731  .priv_class = &allyuv_allrgb_class,
1732  .init = allyuv_init,
1733  .uninit = uninit,
1734  .activate = activate,
1735  .inputs = NULL,
1738 };
1739 
1740 #endif /* CONFIG_ALLYUV_FILTER */
1741 
1742 #if CONFIG_ALLRGB_FILTER
1743 
1744 static void allrgb_fill_picture(AVFilterContext *ctx, AVFrame *frame)
1745 {
1746  unsigned x, y;
1747  const ptrdiff_t linesize = frame->linesize[0];
1748  uint8_t *line = frame->data[0];
1749 
1750  for (y = 0; y < 4096; y++) {
1751  uint8_t *dst = line;
1752 
1753  for (x = 0; x < 4096; x++) {
1754  *dst++ = x;
1755  *dst++ = y;
1756  *dst++ = (x >> 8) | ((y >> 8) << 4);
1757  }
1758  line += linesize;
1759  }
1760 }
1761 
1762 static av_cold int allrgb_init(AVFilterContext *ctx)
1763 {
1764  TestSourceContext *test = ctx->priv;
1765 
1766  test->w = test->h = 4096;
1767  test->draw_once = 1;
1768  test->fill_picture_fn = allrgb_fill_picture;
1769  return init(ctx);
1770 }
1771 
1772 static int allrgb_config_props(AVFilterLink *outlink)
1773 {
1774  TestSourceContext *test = outlink->src->priv;
1775 
1776  ff_fill_rgba_map(test->rgba_map, outlink->format);
1777  return config_props(outlink);
1778 }
1779 
1780 static const AVFilterPad avfilter_vsrc_allrgb_outputs[] = {
1781  {
1782  .name = "default",
1783  .type = AVMEDIA_TYPE_VIDEO,
1784  .config_props = allrgb_config_props,
1785  },
1786 };
1787 
1788 const AVFilter ff_vsrc_allrgb = {
1789  .name = "allrgb",
1790  .description = NULL_IF_CONFIG_SMALL("Generate all RGB colors."),
1791  .priv_size = sizeof(TestSourceContext),
1792  .priv_class = &allyuv_allrgb_class,
1793  .init = allrgb_init,
1794  .uninit = uninit,
1795  .activate = activate,
1796  .inputs = NULL,
1797  FILTER_OUTPUTS(avfilter_vsrc_allrgb_outputs),
1799 };
1800 
1801 #endif /* CONFIG_ALLRGB_FILTER */
1802 
1803 #if CONFIG_COLORSPECTRUM_FILTER
1804 
1805 static const AVOption colorspectrum_options[] = {
1807  { "type", "set the color spectrum type", OFFSET(type), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, FLAGS, .unit = "type" },
1808  { "black","fade to black", 0, AV_OPT_TYPE_CONST,{.i64=0},0, 0, FLAGS, .unit = "type" },
1809  { "white","fade to white", 0, AV_OPT_TYPE_CONST,{.i64=1},0, 0, FLAGS, .unit = "type" },
1810  { "all", "white to black", 0, AV_OPT_TYPE_CONST,{.i64=2},0, 0, FLAGS, .unit = "type" },
1811  { NULL }
1812 };
1813 
1814 AVFILTER_DEFINE_CLASS(colorspectrum);
1815 
1816 static inline float mix(float a, float b, float mix)
1817 {
1818  return a * mix + b * (1.f - mix);
1819 }
1820 
1821 static void hsb2rgb(const float *c, float *rgb)
1822 {
1823  rgb[0] = av_clipf(fabsf(fmodf(c[0] * 6.f + 0.f, 6.f) - 3.f) - 1.f, 0.f, 1.f);
1824  rgb[1] = av_clipf(fabsf(fmodf(c[0] * 6.f + 4.f, 6.f) - 3.f) - 1.f, 0.f, 1.f);
1825  rgb[2] = av_clipf(fabsf(fmodf(c[0] * 6.f + 2.f, 6.f) - 3.f) - 1.f, 0.f, 1.f);
1826  rgb[0] = mix(c[3], (rgb[0] * rgb[0] * (3.f - 2.f * rgb[0])), c[1]) * c[2];
1827  rgb[1] = mix(c[3], (rgb[1] * rgb[1] * (3.f - 2.f * rgb[1])), c[1]) * c[2];
1828  rgb[2] = mix(c[3], (rgb[2] * rgb[2] * (3.f - 2.f * rgb[2])), c[1]) * c[2];
1829 }
1830 
1831 static void colorspectrum_fill_picture(AVFilterContext *ctx, AVFrame *frame)
1832 {
1833  TestSourceContext *test = ctx->priv;
1834  const float w = frame->width - 1.f;
1835  const float h = frame->height - 1.f;
1836  float c[4];
1837 
1838  for (int y = 0; y < frame->height; y++) {
1839  float *r = (float *)(frame->data[2] + y * frame->linesize[2]);
1840  float *g = (float *)(frame->data[0] + y * frame->linesize[0]);
1841  float *b = (float *)(frame->data[1] + y * frame->linesize[1]);
1842  const float yh = y / h;
1843 
1844  c[1] = test->type == 2 ? yh > 0.5f ? 2.f * (yh - 0.5f) : 1.f - 2.f * yh : test->type == 1 ? 1.f - yh : yh;
1845  c[2] = 1.f;
1846  c[3] = test->type == 1 ? 1.f : test->type == 2 ? (yh > 0.5f ? 0.f : 1.f): 0.f;
1847  for (int x = 0; x < frame->width; x++) {
1848  float rgb[3];
1849 
1850  c[0] = x / w;
1851  hsb2rgb(c, rgb);
1852 
1853  r[x] = rgb[0];
1854  g[x] = rgb[1];
1855  b[x] = rgb[2];
1856  }
1857  }
1858 }
1859 
1860 static av_cold int colorspectrum_init(AVFilterContext *ctx)
1861 {
1862  TestSourceContext *test = ctx->priv;
1863 
1864  test->draw_once = 1;
1865  test->fill_picture_fn = colorspectrum_fill_picture;
1866  return init(ctx);
1867 }
1868 
1870  .name = "colorspectrum",
1871  .description = NULL_IF_CONFIG_SMALL("Generate colors spectrum."),
1872  .priv_size = sizeof(TestSourceContext),
1873  .priv_class = &colorspectrum_class,
1874  .init = colorspectrum_init,
1875  .uninit = uninit,
1876  .activate = activate,
1877  .inputs = NULL,
1880 };
1881 
1882 #endif /* CONFIG_COLORSPECTRUM_FILTER */
1883 
1884 #if CONFIG_COLORCHART_FILTER
1885 
1886 static const AVOption colorchart_options[] = {
1888  { "patch_size", "set the single patch size", OFFSET(pw), AV_OPT_TYPE_IMAGE_SIZE, {.str="64x64"}, 0, 0, FLAGS },
1889  { "preset", "set the color checker chart preset", OFFSET(type), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, .unit = "preset" },
1890  { "reference", "reference", 0, AV_OPT_TYPE_CONST,{.i64=0}, 0, 0, FLAGS, .unit = "preset" },
1891  { "skintones", "skintones", 0, AV_OPT_TYPE_CONST,{.i64=1}, 0, 0, FLAGS, .unit = "preset" },
1892  { NULL }
1893 };
1894 
1895 AVFILTER_DEFINE_CLASS(colorchart);
1896 
1897 static const uint8_t reference_colors[][3] = {
1898  { 115, 82, 68 }, // dark skin
1899  { 194, 150, 130 }, // light skin
1900  { 98, 122, 157 }, // blue sky
1901  { 87, 108, 67 }, // foliage
1902  { 133, 128, 177 }, // blue flower
1903  { 103, 189, 170 }, // bluish green
1904 
1905  { 214, 126, 44 }, // orange
1906  { 80, 91, 166 }, // purple red
1907  { 193, 90, 99 }, // moderate red
1908  { 94, 60, 108 }, // purple
1909  { 157, 188, 64 }, // yellow green
1910  { 224, 163, 46 }, // orange yellow
1911 
1912  { 56, 61, 150 }, // blue
1913  { 70, 148, 73 }, // green
1914  { 175, 54, 60 }, // red
1915  { 231, 199, 31 }, // yellow
1916  { 187, 86, 149 }, // magenta
1917  { 8, 133, 161 }, // cyan
1918 
1919  { 243, 243, 242 }, // white
1920  { 200, 200, 200 }, // neutral 8
1921  { 160, 160, 160 }, // neutral 65
1922  { 122, 122, 121 }, // neutral 5
1923  { 85, 85, 85 }, // neutral 35
1924  { 52, 52, 52 }, // black
1925 };
1926 
1927 static const uint8_t skintones_colors[][3] = {
1928  { 54, 38, 43 },
1929  { 105, 43, 42 },
1930  { 147, 43, 43 },
1931  { 77, 41, 42 },
1932  { 134, 43, 41 },
1933  { 201, 134, 118 },
1934 
1935  { 59, 41, 41 },
1936  { 192, 103, 76 },
1937  { 208, 156, 141 },
1938  { 152, 82, 61 },
1939  { 162, 132, 118 },
1940  { 212, 171, 150 },
1941 
1942  { 205, 91, 31 },
1943  { 164, 100, 55 },
1944  { 204, 136, 95 },
1945  { 178, 142, 116 },
1946  { 210, 152, 108 },
1947  { 217, 167, 131 },
1948 
1949  { 206, 166, 126 },
1950  { 208, 163, 97 },
1951  { 245, 180, 0 },
1952  { 212, 184, 125 },
1953  { 179, 165, 150 },
1954  { 196, 184, 105 },
1955 };
1956 
1957 typedef struct ColorChartPreset {
1958  int w, h;
1959  const uint8_t (*colors)[3];
1960 } ColorChartPreset;
1961 
1962 static const ColorChartPreset colorchart_presets[] = {
1963  { 6, 4, reference_colors, },
1964  { 6, 4, skintones_colors, },
1965 };
1966 
1967 static int colorchart_config_props(AVFilterLink *inlink)
1968 {
1969  AVFilterContext *ctx = inlink->src;
1970  TestSourceContext *s = ctx->priv;
1971 
1972  av_assert0(ff_draw_init2(&s->draw, inlink->format, inlink->colorspace,
1973  inlink->color_range, 0) >= 0);
1974  if (av_image_check_size(s->w, s->h, 0, ctx) < 0)
1975  return AVERROR(EINVAL);
1976  return config_props(inlink);
1977 }
1978 
1979 static void colorchart_fill_picture(AVFilterContext *ctx, AVFrame *frame)
1980 {
1981  TestSourceContext *test = ctx->priv;
1982  const int preset = test->type;
1983  const int w = colorchart_presets[preset].w;
1984  const int h = colorchart_presets[preset].h;
1985  const int pw = test->pw;
1986  const int ph = test->ph;
1987 
1988  for (int y = 0; y < h; y++) {
1989  for (int x = 0; x < w; x++) {
1990  uint32_t pc = AV_RB24(colorchart_presets[preset].colors[y * w + x]);
1992 
1993  set_color(test, &color, pc);
1995  x * pw, y * ph, pw, ph);
1996  }
1997  }
1998 }
1999 
2000 static av_cold int colorchart_init(AVFilterContext *ctx)
2001 {
2002  TestSourceContext *test = ctx->priv;
2003  const int preset = test->type;
2004  const int w = colorchart_presets[preset].w;
2005  const int h = colorchart_presets[preset].h;
2006 
2007  test->w = w * test->pw;
2008  test->h = h * test->ph;
2009  test->draw_once = 1;
2010  test->fill_picture_fn = colorchart_fill_picture;
2011  return init(ctx);
2012 }
2013 
2014 static const AVFilterPad avfilter_vsrc_colorchart_outputs[] = {
2015  {
2016  .name = "default",
2017  .type = AVMEDIA_TYPE_VIDEO,
2018  .config_props = colorchart_config_props,
2019  },
2020 };
2021 
2022 const AVFilter ff_vsrc_colorchart = {
2023  .name = "colorchart",
2024  .description = NULL_IF_CONFIG_SMALL("Generate color checker chart."),
2025  .priv_size = sizeof(TestSourceContext),
2026  .priv_class = &colorchart_class,
2027  .init = colorchart_init,
2028  .uninit = uninit,
2029  .activate = activate,
2030  .inputs = NULL,
2031  FILTER_OUTPUTS(avfilter_vsrc_colorchart_outputs),
2033 };
2034 
2035 #endif /* CONFIG_COLORCHART_FILTER */
2036 
2037 #if CONFIG_ZONEPLATE_FILTER
2038 
2039 static const AVOption zoneplate_options[] = {
2041  { "precision", "set LUT precision", OFFSET(lut_precision), AV_OPT_TYPE_INT, {.i64=10}, 4, 16, FLAGS },
2042  { "xo", "set X-axis offset", OFFSET(xo), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2043  { "yo", "set Y-axis offset", OFFSET(yo), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2044  { "to", "set T-axis offset", OFFSET(to), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2045  { "k0", "set 0-order phase", OFFSET(k0), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2046  { "kx", "set 1-order X-axis phase", OFFSET(kx), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2047  { "ky", "set 1-order Y-axis phase", OFFSET(ky), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2048  { "kt", "set 1-order T-axis phase", OFFSET(kt), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2049  { "kxt", "set X-axis*T-axis product phase", OFFSET(kxt), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2050  { "kyt", "set Y-axis*T-axis product phase", OFFSET(kyt), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2051  { "kxy", "set X-axis*Y-axis product phase", OFFSET(kxy), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2052  { "kx2", "set 2-order X-axis phase", OFFSET(kx2), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2053  { "ky2", "set 2-order Y-axis phase", OFFSET(ky2), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2054  { "kt2", "set 2-order T-axis phase", OFFSET(kt2), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2055  { "ku", "set 0-order U-color phase", OFFSET(kU), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2056  { "kv", "set 0-order V-color phase", OFFSET(kV), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, FLAGSR },
2057  { NULL }
2058 };
2059 
2060 AVFILTER_DEFINE_CLASS(zoneplate);
2061 
2062 #define ZONEPLATE_SLICE(name, type) \
2063 static int zoneplate_fill_slice_##name(AVFilterContext *ctx, \
2064  void *arg, int job, \
2065  int nb_jobs) \
2066 { \
2067  TestSourceContext *test = ctx->priv; \
2068  AVFrame *frame = arg; \
2069  const int w = frame->width; \
2070  const int h = frame->height; \
2071  const int kxt = test->kxt, kyt = test->kyt, kx2 = test->kx2; \
2072  const int t = test->pts + test->to, k0 = test->k0; \
2073  const int kt = test->kt, kt2 = test->kt2, ky2 = test->ky2; \
2074  const int ky = test->ky, kx = test->kx, kxy = test->kxy; \
2075  const int lut_mask = (1 << test->lut_precision) - 1; \
2076  const int nkt2t = kt2 * t * t, nktt = kt * t; \
2077  const int start = (h * job ) / nb_jobs; \
2078  const int end = (h * (job+1)) / nb_jobs; \
2079  const ptrdiff_t ylinesize = frame->linesize[0] / sizeof(type); \
2080  const ptrdiff_t ulinesize = frame->linesize[1] / sizeof(type); \
2081  const ptrdiff_t vlinesize = frame->linesize[2] / sizeof(type); \
2082  const int xreset = -(w / 2) - test->xo; \
2083  const int yreset = -(h / 2) - test->yo + start; \
2084  const int kU = test->kU, kV = test->kV; \
2085  const int skxy = 0xffff / (w / 2); \
2086  const int skx2 = 0xffff / w; \
2087  const int dkxt = kxt * t; \
2088  type *ydst = ((type *)frame->data[0]) + start * ylinesize; \
2089  type *udst = ((type *)frame->data[1]) + start * ulinesize; \
2090  type *vdst = ((type *)frame->data[2]) + start * vlinesize; \
2091  const type *lut = (const type *)test->lut; \
2092  int akx, akxt, aky, akyt; \
2093  \
2094  aky = start * ky; \
2095  akyt = start * kyt * t; \
2096  \
2097  for (int j = start, y = yreset; j < end; j++, y++) { \
2098  const int dkxy = kxy * y * skxy; \
2099  const int nky2kt2 = (ky2 * y * y) / h + (nkt2t >> 1); \
2100  int akxy = dkxy * xreset; \
2101  \
2102  akx = 0; \
2103  akxt = 0; \
2104  aky += ky; \
2105  akyt += kyt * t; \
2106  \
2107  for (int i = 0, x = xreset; i < w; i++, x++) { \
2108  int phase = k0, uphase = kU, vphase = kV; \
2109  \
2110  akx += kx; \
2111  phase += akx + aky + nktt; \
2112  \
2113  akxt += dkxt; \
2114  akxy += dkxy; \
2115  phase += akxt + akyt; \
2116  phase += akxy >> 16; \
2117  phase += ((kx2 * x * x * skx2) >> 16) + nky2kt2; \
2118  uphase += phase; \
2119  vphase += phase; \
2120  \
2121  ydst[i] = lut[phase & lut_mask]; \
2122  udst[i] = lut[uphase & lut_mask]; \
2123  vdst[i] = lut[vphase & lut_mask]; \
2124  } \
2125  \
2126  ydst += ylinesize; \
2127  udst += ulinesize; \
2128  vdst += vlinesize; \
2129  } \
2130  \
2131  return 0; \
2132 }
2133 
2134 ZONEPLATE_SLICE( 8, uint8_t)
2135 ZONEPLATE_SLICE( 9, uint16_t)
2136 ZONEPLATE_SLICE(10, uint16_t)
2137 ZONEPLATE_SLICE(12, uint16_t)
2138 ZONEPLATE_SLICE(14, uint16_t)
2139 ZONEPLATE_SLICE(16, uint16_t)
2140 
2141 static void zoneplate_fill_picture(AVFilterContext *ctx, AVFrame *frame)
2142 {
2143  TestSourceContext *test = ctx->priv;
2144  ff_filter_execute(ctx, test->fill_slice_fn, frame, NULL,
2146 }
2147 
2148 static int zoneplate_config_props(AVFilterLink *outlink)
2149 {
2150  AVFilterContext *ctx = outlink->src;
2151  TestSourceContext *test = ctx->priv;
2153  const int lut_size = 1 << test->lut_precision;
2154  const int depth = desc->comp[0].depth;
2155  uint16_t *lut16;
2156  uint8_t *lut8;
2157 
2158  if (av_image_check_size(test->w, test->h, 0, ctx) < 0)
2159  return AVERROR(EINVAL);
2160 
2161  test->lut = av_calloc(lut_size, sizeof(*test->lut) * ((depth + 7) / 8));
2162  if (!test->lut)
2163  return AVERROR(ENOMEM);
2164 
2165  lut8 = test->lut;
2166  lut16 = (uint16_t *)test->lut;
2167  switch (depth) {
2168  case 8:
2169  for (int i = 0; i < lut_size; i++)
2170  lut8[i] = lrintf(255.f * (0.5f + 0.5f * sinf((2.f * M_PI * i) / lut_size)));
2171  break;
2172  default:
2173  for (int i = 0; i < lut_size; i++)
2174  lut16[i] = lrintf(((1 << depth) - 1) * (0.5f + 0.5f * sinf((2.f * M_PI * i) / lut_size)));
2175  break;
2176  }
2177 
2178  test->draw_once = 0;
2179  test->fill_picture_fn = zoneplate_fill_picture;
2180 
2181  switch (depth) {
2182  case 8: test->fill_slice_fn = zoneplate_fill_slice_8; break;
2183  case 9: test->fill_slice_fn = zoneplate_fill_slice_9; break;
2184  case 10: test->fill_slice_fn = zoneplate_fill_slice_10; break;
2185  case 12: test->fill_slice_fn = zoneplate_fill_slice_12; break;
2186  case 14: test->fill_slice_fn = zoneplate_fill_slice_14; break;
2187  case 16: test->fill_slice_fn = zoneplate_fill_slice_16; break;
2188  }
2189  return config_props(outlink);
2190 }
2191 
2192 static const enum AVPixelFormat zoneplate_pix_fmts[] = {
2197 };
2198 
2199 static int zoneplate_query_formats(AVFilterContext *ctx)
2200 {
2201  int ret;
2203  return ret;
2204  return ff_set_common_formats_from_list(ctx, zoneplate_pix_fmts);
2205 }
2206 
2207 static const AVFilterPad avfilter_vsrc_zoneplate_outputs[] = {
2208  {
2209  .name = "default",
2210  .type = AVMEDIA_TYPE_VIDEO,
2211  .config_props = zoneplate_config_props,
2212  },
2213 };
2214 
2215 const AVFilter ff_vsrc_zoneplate = {
2216  .name = "zoneplate",
2217  .description = NULL_IF_CONFIG_SMALL("Generate zone-plate."),
2218  .priv_size = sizeof(TestSourceContext),
2219  .priv_class = &zoneplate_class,
2220  .init = init,
2221  .uninit = uninit,
2222  .activate = activate,
2223  .inputs = NULL,
2224  FILTER_OUTPUTS(avfilter_vsrc_zoneplate_outputs),
2225  FILTER_QUERY_FUNC(zoneplate_query_formats),
2226  .flags = AVFILTER_FLAG_SLICE_THREADS,
2227  .process_command = ff_filter_process_command,
2228 };
2229 
2230 #endif /* CONFIG_ZONEPLATE_FILTER */
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:112
A
#define A(x)
Definition: vpx_arith.h:28
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:501
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
FFDrawColor
Definition: drawutils.h:50
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
ff_exp10
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
level
uint8_t level
Definition: svq3.c:204
mix
static int mix(int c0, int c1)
Definition: 4xm.c:715
r
const char * r
Definition: vf_curves.c:126
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
color
Definition: vf_paletteuse.c:511
TestSourceContext::kV
int kV
Definition: vsrc_testsrc.c:96
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1018
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:746
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2962
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vsrc_testsrc.c:142
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition: internal.h:162
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
TestSourceContext::kxt
int kxt
Definition: vsrc_testsrc.c:94
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
TestSourceContext::k0
int k0
Definition: vsrc_testsrc.c:93
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:88
ph
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
Definition: cbs_h266_syntax_template.c:2998
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
ff_vsrc_color
const AVFilter ff_vsrc_color
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
AVFrame::width
int width
Definition: frame.h:412
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:683
AVOption
AVOption.
Definition: opt.h:346
b
#define b
Definition: input.c:41
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:159
data
const char data[16]
Definition: mxf.c:148
R
#define R
Definition: huffyuv.h:44
test
Definition: idctdsp.c:35
ff_vsrc_pal75bars
const AVFilter ff_vsrc_pal75bars
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
float.h
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:106
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:612
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
init
static av_cold int init(AVFilterContext *ctx)
Definition: vsrc_testsrc.c:127
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
video.h
ff_make_formats_list_singleton
AVFilterFormats * ff_make_formats_list_singleton(int fmt)
Equivalent to ff_make_format_list({const int[]}{ fmt, -1 })
Definition: formats.c:529
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
formats.h
ff_vsrc_haldclutsrc
const AVFilter ff_vsrc_haldclutsrc
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3002
AVCOL_SPC_BT470BG
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
Definition: pixfmt.h:615
rgb
Definition: rpzaenc.c:60
ff_vsrc_yuvtestsrc
const AVFilter ff_vsrc_yuvtestsrc
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:496
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:422
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:494
TestSourceContext::kyt
int kyt
Definition: vsrc_testsrc.c:94
draw_rectangle
static void draw_rectangle(AVFormatContext *s)
Definition: xcbgrab.c:648
val
static double val(void *priv, double ch)
Definition: aeval.c:78
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
TestSourceContext::kxy
int kxy
Definition: vsrc_testsrc.c:94
TestSourceContext::xo
int xo
Definition: vsrc_testsrc.c:96
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:262
ff_vsrc_allrgb
const AVFilter ff_vsrc_allrgb
ff_blend_mask
void ff_blend_mask(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_w, int dst_h, const uint8_t *mask, int mask_linesize, int mask_w, int mask_h, int l2depth, unsigned endianness, int x0, int y0)
Blend an alpha mask with an uniform color.
Definition: drawutils.c:534
fabsf
static __device__ float fabsf(float a)
Definition: cuda_runtime.h:181
planar
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1<< 16)) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out->ch+ch,(const uint8_t **) in->ch+ch, off *(out-> planar
Definition: audioconvert.c:56
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
TestSourceContext::rgba_map
uint8_t rgba_map[4]
Definition: vsrc_testsrc.c:85
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
preset
preset
Definition: vf_curves.c:46
AVFrame::interlaced_frame
attribute_deprecated int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:517
avassert.h
ff_vsrc_pal100bars
const AVFilter ff_vsrc_pal100bars
TestSourceContext::duration
int64_t duration
duration expressed in microseconds
Definition: vsrc_testsrc.c:62
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
ff_set_common_formats
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:867
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:591
mask
static const uint16_t mask[17]
Definition: lzw.c:38
TestSourceContext::type
int type
Definition: vsrc_testsrc.c:77
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:498
float
float
Definition: af_crystalizer.c:121
ff_outlink_set_status
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: filters.h:189
TestSourceContext::kt
int kt
Definition: vsrc_testsrc.c:93
width
#define width
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:499
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:491
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
g
const char * g
Definition: vf_curves.c:127
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
TestSourceContext::ph
int ph
Definition: vsrc_testsrc.c:58
TestSourceContext::time_base
AVRational time_base
Definition: vsrc_testsrc.c:60
to
const char * to
Definition: webvttdec.c:35
ff_set_common_formats_from_list
int ff_set_common_formats_from_list(AVFilterContext *ctx, const int *fmts)
Equivalent to ff_set_common_formats(ctx, ff_make_format_list(fmts))
Definition: formats.c:873
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
filters.h
B
#define B
Definition: huffyuv.h:42
ctx
AVFormatContext * ctx
Definition: movenc.c:48
FLAGSR
#define FLAGSR
Definition: vsrc_testsrc.c:104
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:521
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
TestSourceContext::color_rgba
uint8_t color_rgba[4]
Definition: vsrc_testsrc.c:82
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
ff_vsrc_testsrc2
const AVFilter ff_vsrc_testsrc2
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:87
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
frame
static AVFrame * frame
Definition: demux_decode.c:54
arg
const char * arg
Definition: jacosubdec.c:67
TestSourceContext::kt2
int kt2
Definition: vsrc_testsrc.c:95
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:497
TestSourceContext::sar
AVRational sar
sample aspect ratio
Definition: vsrc_testsrc.c:63
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:468
FLAGS
#define FLAGS
Definition: vsrc_testsrc.c:103
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:469
NULL
#define NULL
Definition: coverity.c:32
ff_vsrc_colorspectrum
const AVFilter ff_vsrc_colorspectrum
TestSourceContext::lut_precision
int lut_precision
Definition: vsrc_testsrc.c:97
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
TestSourceContext::color
FFDrawColor color
Definition: vsrc_testsrc.c:81
AV_OPT_TYPE_COLOR
@ AV_OPT_TYPE_COLOR
Definition: opt.h:250
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:245
AV_WL24
#define AV_WL24(p, d)
Definition: intreadwrite.h:462
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
parseutils.h
NOSIZE_OPTIONS_OFFSET
#define NOSIZE_OPTIONS_OFFSET
Definition: vsrc_testsrc.c:119
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:265
sinf
#define sinf(x)
Definition: libm.h:419
av_clipf
av_clipf
Definition: af_crystalizer.c:121
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:493
ff_vsrc_colorchart
const AVFilter ff_vsrc_colorchart
ff_vsrc_allyuv
const AVFilter ff_vsrc_allyuv
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
index
int index
Definition: gxfenc.c:89
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
TestSourceContext::picref
AVFrame * picref
cached reference containing the painted picture
Definition: vsrc_testsrc.c:66
av_rescale_rnd
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
f
f
Definition: af_crystalizer.c:121
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:442
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: vvc_intra.c:291
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
config_props
static int config_props(AVFilterLink *outlink)
Definition: vsrc_testsrc.c:150
ff_vsrc_smptehdbars
const AVFilter ff_vsrc_smptehdbars
av_get_padded_bits_per_pixel
int av_get_padded_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel for the pixel format described by pixdesc, including any padding ...
Definition: pixdesc.c:2927
FILTER_PIXFMTS
#define FILTER_PIXFMTS(...)
Definition: internal.h:168
ff_blend_rectangle
void ff_blend_rectangle(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_w, int dst_h, int x0, int y0, int w, int h)
Blend a rectangle with an uniform color.
Definition: drawutils.c:353
AV_ROUND_ZERO
@ AV_ROUND_ZERO
Round toward zero.
Definition: mathematics.h:131
ff_draw_init2
int ff_draw_init2(FFDrawContext *draw, enum AVPixelFormat format, enum AVColorSpace csp, enum AVColorRange range, unsigned flags)
Init a draw context.
Definition: drawutils.c:80
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
TestSourceContext::frame_rate
AVRational frame_rate
Definition: vsrc_testsrc.c:60
AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:508
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:464
size
int size
Definition: twinvq_data.h:10344
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:94
COMMON_OPTIONS
#define COMMON_OPTIONS
Definition: vsrc_testsrc.c:117
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:471
ff_fill_rectangle
void ff_fill_rectangle(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_x, int dst_y, int w, int h)
Fill a rectangle with an uniform color.
Definition: drawutils.c:231
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:485
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:427
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:890
height
#define height
TestSourceContext::level
int level
Definition: vsrc_testsrc.c:90
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
TestSourceContext::nb_decimals
int nb_decimals
Definition: vsrc_testsrc.c:71
TestSourceContext::lut
uint8_t * lut
Definition: vsrc_testsrc.c:98
draw_bar
static void draw_bar(ShowCWTContext *s, int y, float Y, float U, float V)
Definition: avf_showcwt.c:390
line
Definition: graph2dot.c:48
AV_PIX_FMT_RGB0
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:263
xga_font_data.h
M_PI
#define M_PI
Definition: mathematics.h:67
TestSourceContext
Definition: vsrc_testsrc.c:55
internal.h
AVFILTER_DEFINE_CLASS
#define AVFILTER_DEFINE_CLASS(fname)
Definition: internal.h:323
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:99
TestSourceContext::nb_frame
unsigned int nb_frame
Definition: vsrc_testsrc.c:59
FILTER_SINGLE_PIXFMT
#define FILTER_SINGLE_PIXFMT(pix_fmt_)
Definition: internal.h:172
ff_set_common_color_ranges
int ff_set_common_color_ranges(AVFilterContext *ctx, AVFilterFormats *color_ranges)
Definition: formats.c:844
TestSourceContext::draw_once
int draw_once
draw only the first frame, always put out the same picture
Definition: vsrc_testsrc.c:64
AV_PIX_FMT_BGRA64
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:473
TestSourceContext::h
int h
Definition: vsrc_testsrc.c:57
avpriv_vga16_font
const uint8_t avpriv_vga16_font[4096]
Definition: xga_font_data.c:160
lrintf
#define lrintf(x)
Definition: libm_mips.h:72
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
ff_vsrc_nullsrc
const AVFilter ff_vsrc_nullsrc
TestSourceContext::complement
int complement
Definition: vsrc_testsrc.c:86
ff_draw_supported_pixel_formats
AVFilterFormats * ff_draw_supported_pixel_formats(unsigned flags)
Return the list of pixel formats supported by the draw functions.
Definition: drawutils.c:647
ff_vsrc_zoneplate
const AVFilter ff_vsrc_zoneplate
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:495
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:609
AV_PIX_FMT_BGR444
#define AV_PIX_FMT_BGR444
Definition: pixfmt.h:472
common.h
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:825
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:466
ff_draw_round_to_sub
int ff_draw_round_to_sub(FFDrawContext *draw, int sub_dir, int round_dir, int value)
Round a dimension according to subsampling.
Definition: drawutils.c:635
TestSourceContext::ky
int ky
Definition: vsrc_testsrc.c:93
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_vsrc_smptebars
const AVFilter ff_vsrc_smptebars
FFDrawContext
Definition: drawutils.h:35
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
AV_PIX_FMT_BGR565
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:470
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:599
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:666
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:477
OFFSET
#define OFFSET(x)
Definition: vsrc_testsrc.c:102
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:465
ff_draw_color
void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4])
Prepare a color.
Definition: drawutils.c:156
AVFilter
Filter definition.
Definition: avfilter.h:166
ret
ret
Definition: filter_design.txt:187
AV_PIX_FMT_0BGR
@ AV_PIX_FMT_0BGR
packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined
Definition: pixfmt.h:264
TestSourceContext::kU
int kU
Definition: vsrc_testsrc.c:96
ff_set_common_color_spaces
int ff_set_common_color_spaces(AVFilterContext *ctx, AVFilterFormats *color_spaces)
Definition: formats.c:826
planes
static const struct @383 planes[]
pos
unsigned int pos
Definition: spdifenc.c:413
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:447
U
#define U(x)
Definition: vpx_arith.h:37
outputs
static const AVFilterPad outputs[]
Definition: vsrc_testsrc.c:163
draw_text
static void draw_text(FFDrawContext *draw, AVFrame *out, FFDrawColor *color, int x0, int y0, const uint8_t *text)
Definition: src_avsynctest.c:247
steps
static const int16_t steps[16]
Definition: misc4.c:30
ff_vsrc_rgbtestsrc
const AVFilter ff_vsrc_rgbtestsrc
AVFrame::height
int height
Definition: frame.h:412
TestSourceContext::to
int to
Definition: vsrc_testsrc.c:96
TestSourceContext::alpha
int alpha
Definition: vsrc_testsrc.c:74
activate
static int activate(AVFilterContext *ctx)
Definition: vsrc_testsrc.c:171
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
TestSourceContext::yo
int yo
Definition: vsrc_testsrc.c:96
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
avfilter.h
TestSourceContext::ky2
int ky2
Definition: vsrc_testsrc.c:95
AVFILTER_DEFINE_CLASS_EXT
AVFILTER_DEFINE_CLASS_EXT(nullsrc_yuvtestsrc, "nullsrc/yuvtestsrc", options)
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:132
ffmath.h
G
#define G
Definition: huffyuv.h:43
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
factor
static const int factor[16]
Definition: vf_pp7.c:78
TestSourceContext::pts
int64_t pts
Definition: vsrc_testsrc.c:61
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
desc
const char * desc
Definition: libsvtav1.c:73
TestSourceContext::fill_slice_fn
int(* fill_slice_fn)(AVFilterContext *ctx, void *arg, int job, int nb_jobs)
Definition: vsrc_testsrc.c:99
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
ff_vsrc_testsrc
const AVFilter ff_vsrc_testsrc
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
TestSourceContext::kx
int kx
Definition: vsrc_testsrc.c:93
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:251
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:80
ff_fill_rgba_map
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
Definition: drawutils.c:35
TestSourceContext::draw_once_reset
int draw_once_reset
draw only the first frame or in case of reset
Definition: vsrc_testsrc.c:65
TestSourceContext::kx2
int kx2
Definition: vsrc_testsrc.c:95
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
AV_PIX_FMT_0RGB
@ AV_PIX_FMT_0RGB
packed RGB 8:8:8, 32bpp, XRGBXRGB... X=unused/undefined
Definition: pixfmt.h:262
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
TestSourceContext::w
int w
Definition: vsrc_testsrc.c:57
h
h
Definition: vp9dsp_template.c:2038
ff_outlink_frame_wanted
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function. If this function returns true
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:488
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
TestSourceContext::draw
FFDrawContext draw
Definition: vsrc_testsrc.c:80
drawutils.h
ff_filter_execute
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
Definition: internal.h:134
AV_RB24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:97
AVCOL_SPC_BT709
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
Definition: pixfmt.h:611
int
int
Definition: ffmpeg_filter.c:425
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
snprintf
#define snprintf
Definition: snprintf.h:34
TestSourceContext::fill_picture_fn
void(* fill_picture_fn)(AVFilterContext *ctx, AVFrame *frame)
Definition: vsrc_testsrc.c:68
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
line
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted line
Definition: swscale.txt:40
TestSourceContext::pw
int pw
Definition: vsrc_testsrc.c:58
TestSourceContext::depth
int depth
Definition: vsrc_testsrc.c:87
COMMON_OPTIONS_NOSIZE
#define COMMON_OPTIONS_NOSIZE
Definition: vsrc_testsrc.c:110
options
static const AVOption options[]
Definition: vsrc_testsrc.c:122
AV_PIX_FMT_RGB444
#define AV_PIX_FMT_RGB444
Definition: pixfmt.h:467