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