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