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