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  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
33 #include <float.h>
34 
35 #include "libavutil/common.h"
36 #include "libavutil/mathematics.h"
37 #include "libavutil/opt.h"
38 #include "libavutil/intreadwrite.h"
39 #include "libavutil/parseutils.h"
40 #include "avfilter.h"
41 #include "formats.h"
42 #include "internal.h"
43 #include "video.h"
44 
45 typedef struct {
46  const AVClass *class;
47  int h, w;
48  unsigned int nb_frame;
50  int64_t pts, max_pts;
51  char *size;
52  char *rate;
53  char *duration;
55 
56  void (* fill_picture_fn)(AVFilterContext *ctx, AVFilterBufferRef *picref);
57 
58  /* only used by rgbtest */
59  int rgba_map[4];
61 
62 #define OFFSET(x) offsetof(TestSourceContext, x)
63 
64 static const AVOption testsrc_options[] = {
65  { "size", "set video size", OFFSET(size), AV_OPT_TYPE_STRING, {.str = "320x240"}},
66  { "s", "set video size", OFFSET(size), AV_OPT_TYPE_STRING, {.str = "320x240"}},
67  { "rate", "set video rate", OFFSET(rate), AV_OPT_TYPE_STRING, {.str = "25"}, },
68  { "r", "set video rate", OFFSET(rate), AV_OPT_TYPE_STRING, {.str = "25"}, },
69  { "duration", "set video duration", OFFSET(duration), AV_OPT_TYPE_STRING, {.str = NULL}, },
70  { "sar", "set video sample aspect ratio", OFFSET(sar), AV_OPT_TYPE_RATIONAL, {.dbl = 1}, 0, INT_MAX },
71  { NULL },
72 };
73 
74 static av_cold int init_common(AVFilterContext *ctx, const char *args)
75 {
76  TestSourceContext *test = ctx->priv;
77  AVRational frame_rate_q;
78  int64_t duration = -1;
79  int ret = 0;
80 
81  av_opt_set_defaults(test);
82 
83  if ((ret = (av_set_options_string(test, args, "=", ":"))) < 0) {
84  av_log(ctx, AV_LOG_ERROR, "Error parsing options string: '%s'\n", args);
85  return ret;
86  }
87 
88  if ((ret = av_parse_video_size(&test->w, &test->h, test->size)) < 0) {
89  av_log(ctx, AV_LOG_ERROR, "Invalid frame size: '%s'\n", test->size);
90  return ret;
91  }
92 
93  if ((ret = av_parse_video_rate(&frame_rate_q, test->rate)) < 0 ||
94  frame_rate_q.den <= 0 || frame_rate_q.num <= 0) {
95  av_log(ctx, AV_LOG_ERROR, "Invalid frame rate: '%s'\n", test->rate);
96  return ret;
97  }
98 
99  if ((test->duration) && (ret = av_parse_time(&duration, test->duration, 1)) < 0) {
100  av_log(ctx, AV_LOG_ERROR, "Invalid duration: '%s'\n", test->duration);
101  return ret;
102  }
103 
104  test->time_base.num = frame_rate_q.den;
105  test->time_base.den = frame_rate_q.num;
106  test->max_pts = duration >= 0 ?
107  av_rescale_q(duration, AV_TIME_BASE_Q, test->time_base) : -1;
108  test->nb_frame = 0;
109  test->pts = 0;
110 
111  av_log(ctx, AV_LOG_DEBUG, "size:%dx%d rate:%d/%d duration:%f sar:%d/%d\n",
112  test->w, test->h, frame_rate_q.num, frame_rate_q.den,
113  duration < 0 ? -1 : test->max_pts * av_q2d(test->time_base),
114  test->sar.num, test->sar.den);
115  return 0;
116 }
117 
118 static int config_props(AVFilterLink *outlink)
119 {
120  TestSourceContext *test = outlink->src->priv;
121 
122  outlink->w = test->w;
123  outlink->h = test->h;
124  outlink->sample_aspect_ratio = test->sar;
125  outlink->time_base = test->time_base;
126 
127  return 0;
128 }
129 
130 static int request_frame(AVFilterLink *outlink)
131 {
132  TestSourceContext *test = outlink->src->priv;
133  AVFilterBufferRef *picref;
134 
135  if (test->max_pts >= 0 && test->pts > test->max_pts)
136  return AVERROR_EOF;
137  picref = ff_get_video_buffer(outlink, AV_PERM_WRITE, test->w, test->h);
138  if (!picref)
139  return AVERROR(ENOMEM);
140 
141  picref->pts = test->pts++;
142  picref->pos = -1;
143  picref->video->key_frame = 1;
144  picref->video->interlaced = 0;
145  picref->video->pict_type = AV_PICTURE_TYPE_I;
146  picref->video->pixel_aspect = test->sar;
147  test->nb_frame++;
148  test->fill_picture_fn(outlink->src, picref);
149 
150  return ff_filter_frame(outlink, picref);
151 }
152 
153 #if CONFIG_TESTSRC_FILTER
154 
155 static const char *testsrc_get_name(void *ctx)
156 {
157  return "testsrc";
158 }
159 
160 static const AVClass testsrc_class = {
161  .class_name = "TestSourceContext",
162  .item_name = testsrc_get_name,
163  .option = testsrc_options,
164 };
165 
178 static void draw_rectangle(unsigned val, uint8_t *dst, int dst_linesize, unsigned segment_width,
179  unsigned x, unsigned y, unsigned w, unsigned h)
180 {
181  int i;
182  int step = 3;
183 
184  dst += segment_width * (step * x + y * dst_linesize);
185  w *= segment_width * step;
186  h *= segment_width;
187  for (i = 0; i < h; i++) {
188  memset(dst, val, w);
189  dst += dst_linesize;
190  }
191 }
192 
193 static void draw_digit(int digit, uint8_t *dst, unsigned dst_linesize,
194  unsigned segment_width)
195 {
196 #define TOP_HBAR 1
197 #define MID_HBAR 2
198 #define BOT_HBAR 4
199 #define LEFT_TOP_VBAR 8
200 #define LEFT_BOT_VBAR 16
201 #define RIGHT_TOP_VBAR 32
202 #define RIGHT_BOT_VBAR 64
203  struct {
204  int x, y, w, h;
205  } segments[] = {
206  { 1, 0, 5, 1 }, /* TOP_HBAR */
207  { 1, 6, 5, 1 }, /* MID_HBAR */
208  { 1, 12, 5, 1 }, /* BOT_HBAR */
209  { 0, 1, 1, 5 }, /* LEFT_TOP_VBAR */
210  { 0, 7, 1, 5 }, /* LEFT_BOT_VBAR */
211  { 6, 1, 1, 5 }, /* RIGHT_TOP_VBAR */
212  { 6, 7, 1, 5 } /* RIGHT_BOT_VBAR */
213  };
214  static const unsigned char masks[10] = {
215  /* 0 */ TOP_HBAR |BOT_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
216  /* 1 */ RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
217  /* 2 */ TOP_HBAR|MID_HBAR|BOT_HBAR|LEFT_BOT_VBAR |RIGHT_TOP_VBAR,
218  /* 3 */ TOP_HBAR|MID_HBAR|BOT_HBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
219  /* 4 */ MID_HBAR |LEFT_TOP_VBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
220  /* 5 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR |RIGHT_BOT_VBAR,
221  /* 6 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR |RIGHT_BOT_VBAR,
222  /* 7 */ TOP_HBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
223  /* 8 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR|LEFT_BOT_VBAR|RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
224  /* 9 */ TOP_HBAR|BOT_HBAR|MID_HBAR|LEFT_TOP_VBAR |RIGHT_TOP_VBAR|RIGHT_BOT_VBAR,
225  };
226  unsigned mask = masks[digit];
227  int i;
228 
229  draw_rectangle(0, dst, dst_linesize, segment_width, 0, 0, 8, 13);
230  for (i = 0; i < FF_ARRAY_ELEMS(segments); i++)
231  if (mask & (1<<i))
232  draw_rectangle(255, dst, dst_linesize, segment_width,
233  segments[i].x, segments[i].y, segments[i].w, segments[i].h);
234 }
235 
236 #define GRADIENT_SIZE (6 * 256)
237 
238 static void test_fill_picture(AVFilterContext *ctx, AVFilterBufferRef *picref)
239 {
240  TestSourceContext *test = ctx->priv;
241  uint8_t *p, *p0;
242  int x, y;
243  int color, color_rest;
244  int icolor;
245  int radius;
246  int quad0, quad;
247  int dquad_x, dquad_y;
248  int grad, dgrad, rgrad, drgrad;
249  int seg_size;
250  int second;
251  int i;
252  uint8_t *data = picref->data[0];
253  int width = picref->video->w;
254  int height = picref->video->h;
255 
256  /* draw colored bars and circle */
257  radius = (width + height) / 4;
258  quad0 = width * width / 4 + height * height / 4 - radius * radius;
259  dquad_y = 1 - height;
260  p0 = data;
261  for (y = 0; y < height; y++) {
262  p = p0;
263  color = 0;
264  color_rest = 0;
265  quad = quad0;
266  dquad_x = 1 - width;
267  for (x = 0; x < width; x++) {
268  icolor = color;
269  if (quad < 0)
270  icolor ^= 7;
271  quad += dquad_x;
272  dquad_x += 2;
273  *(p++) = icolor & 1 ? 255 : 0;
274  *(p++) = icolor & 2 ? 255 : 0;
275  *(p++) = icolor & 4 ? 255 : 0;
276  color_rest += 8;
277  if (color_rest >= width) {
278  color_rest -= width;
279  color++;
280  }
281  }
282  quad0 += dquad_y;
283  dquad_y += 2;
284  p0 += picref->linesize[0];
285  }
286 
287  /* draw sliding color line */
288  p = data + picref->linesize[0] * height * 3/4;
289  grad = (256 * test->nb_frame * test->time_base.num / test->time_base.den) %
290  GRADIENT_SIZE;
291  rgrad = 0;
292  dgrad = GRADIENT_SIZE / width;
293  drgrad = GRADIENT_SIZE % width;
294  for (x = 0; x < width; x++) {
295  *(p++) =
296  grad < 256 || grad >= 5 * 256 ? 255 :
297  grad >= 2 * 256 && grad < 4 * 256 ? 0 :
298  grad < 2 * 256 ? 2 * 256 - 1 - grad : grad - 4 * 256;
299  *(p++) =
300  grad >= 4 * 256 ? 0 :
301  grad >= 1 * 256 && grad < 3 * 256 ? 255 :
302  grad < 1 * 256 ? grad : 4 * 256 - 1 - grad;
303  *(p++) =
304  grad < 2 * 256 ? 0 :
305  grad >= 3 * 256 && grad < 5 * 256 ? 255 :
306  grad < 3 * 256 ? grad - 2 * 256 : 6 * 256 - 1 - grad;
307  grad += dgrad;
308  rgrad += drgrad;
309  if (rgrad >= GRADIENT_SIZE) {
310  grad++;
311  rgrad -= GRADIENT_SIZE;
312  }
313  if (grad >= GRADIENT_SIZE)
314  grad -= GRADIENT_SIZE;
315  }
316  for (y = height / 8; y > 0; y--) {
317  memcpy(p, p - picref->linesize[0], 3 * width);
318  p += picref->linesize[0];
319  }
320 
321  /* draw digits */
322  seg_size = width / 80;
323  if (seg_size >= 1 && height >= 13 * seg_size) {
324  second = test->nb_frame * test->time_base.num / test->time_base.den;
325  x = width - (width - seg_size * 64) / 2;
326  y = (height - seg_size * 13) / 2;
327  p = data + (x*3 + y * picref->linesize[0]);
328  for (i = 0; i < 8; i++) {
329  p -= 3 * 8 * seg_size;
330  draw_digit(second % 10, p, picref->linesize[0], seg_size);
331  second /= 10;
332  if (second == 0)
333  break;
334  }
335  }
336 }
337 
338 static av_cold int test_init(AVFilterContext *ctx, const char *args)
339 {
340  TestSourceContext *test = ctx->priv;
341 
342  test->class = &testsrc_class;
343  test->fill_picture_fn = test_fill_picture;
344  return init_common(ctx, args);
345 }
346 
347 static int test_query_formats(AVFilterContext *ctx)
348 {
349  static const enum AVPixelFormat pix_fmts[] = {
351  };
353  return 0;
354 }
355 
356 static const AVFilterPad avfilter_vsrc_testsrc_outputs[] = {
357  {
358  .name = "default",
359  .type = AVMEDIA_TYPE_VIDEO,
360  .request_frame = request_frame,
361  .config_props = config_props,
362  },
363  { NULL }
364 };
365 
366 AVFilter avfilter_vsrc_testsrc = {
367  .name = "testsrc",
368  .description = NULL_IF_CONFIG_SMALL("Generate test pattern."),
369  .priv_size = sizeof(TestSourceContext),
370  .init = test_init,
371 
372  .query_formats = test_query_formats,
373 
374  .inputs = NULL,
375 
376  .outputs = avfilter_vsrc_testsrc_outputs,
377 };
378 
379 #endif /* CONFIG_TESTSRC_FILTER */
380 
381 #if CONFIG_RGBTESTSRC_FILTER
382 
383 static const char *rgbtestsrc_get_name(void *ctx)
384 {
385  return "rgbtestsrc";
386 }
387 
388 static const AVClass rgbtestsrc_class = {
389  .class_name = "RGBTestSourceContext",
390  .item_name = rgbtestsrc_get_name,
391  .option = testsrc_options,
392 };
393 
394 #define R 0
395 #define G 1
396 #define B 2
397 #define A 3
398 
399 static void rgbtest_put_pixel(uint8_t *dst, int dst_linesize,
400  int x, int y, int r, int g, int b, enum AVPixelFormat fmt,
401  int rgba_map[4])
402 {
403  int32_t v;
404  uint8_t *p;
405 
406  switch (fmt) {
407  case AV_PIX_FMT_BGR444: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r >> 4) << 8) | ((g >> 4) << 4) | (b >> 4); break;
408  case AV_PIX_FMT_RGB444: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b >> 4) << 8) | ((g >> 4) << 4) | (r >> 4); break;
409  case AV_PIX_FMT_BGR555: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r>>3)<<10) | ((g>>3)<<5) | (b>>3); break;
410  case AV_PIX_FMT_RGB555: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b>>3)<<10) | ((g>>3)<<5) | (r>>3); break;
411  case AV_PIX_FMT_BGR565: ((uint16_t*)(dst + y*dst_linesize))[x] = ((r>>3)<<11) | ((g>>2)<<5) | (b>>3); break;
412  case AV_PIX_FMT_RGB565: ((uint16_t*)(dst + y*dst_linesize))[x] = ((b>>3)<<11) | ((g>>2)<<5) | (r>>3); break;
413  case AV_PIX_FMT_RGB24:
414  case AV_PIX_FMT_BGR24:
415  v = (r << (rgba_map[R]*8)) + (g << (rgba_map[G]*8)) + (b << (rgba_map[B]*8));
416  p = dst + 3*x + y*dst_linesize;
417  AV_WL24(p, v);
418  break;
419  case AV_PIX_FMT_RGBA:
420  case AV_PIX_FMT_BGRA:
421  case AV_PIX_FMT_ARGB:
422  case AV_PIX_FMT_ABGR:
423  v = (r << (rgba_map[R]*8)) + (g << (rgba_map[G]*8)) + (b << (rgba_map[B]*8));
424  p = dst + 4*x + y*dst_linesize;
425  AV_WL32(p, v);
426  break;
427  }
428 }
429 
430 static void rgbtest_fill_picture(AVFilterContext *ctx, AVFilterBufferRef *picref)
431 {
432  TestSourceContext *test = ctx->priv;
433  int x, y, w = picref->video->w, h = picref->video->h;
434 
435  for (y = 0; y < h; y++) {
436  for (x = 0; x < picref->video->w; x++) {
437  int c = 256*x/w;
438  int r = 0, g = 0, b = 0;
439 
440  if (3*y < h ) r = c;
441  else if (3*y < 2*h) g = c;
442  else b = c;
443 
444  rgbtest_put_pixel(picref->data[0], picref->linesize[0], x, y, r, g, b,
445  ctx->outputs[0]->format, test->rgba_map);
446  }
447  }
448 }
449 
450 static av_cold int rgbtest_init(AVFilterContext *ctx, const char *args)
451 {
452  TestSourceContext *test = ctx->priv;
453 
454  test->class = &rgbtestsrc_class;
455  test->fill_picture_fn = rgbtest_fill_picture;
456  return init_common(ctx, args);
457 }
458 
459 static int rgbtest_query_formats(AVFilterContext *ctx)
460 {
461  static const enum AVPixelFormat pix_fmts[] = {
468  };
470  return 0;
471 }
472 
473 static int rgbtest_config_props(AVFilterLink *outlink)
474 {
475  TestSourceContext *test = outlink->src->priv;
476 
477  switch (outlink->format) {
478  case AV_PIX_FMT_ARGB: test->rgba_map[A] = 0; test->rgba_map[R] = 1; test->rgba_map[G] = 2; test->rgba_map[B] = 3; break;
479  case AV_PIX_FMT_ABGR: test->rgba_map[A] = 0; test->rgba_map[B] = 1; test->rgba_map[G] = 2; test->rgba_map[R] = 3; break;
480  case AV_PIX_FMT_RGBA:
481  case AV_PIX_FMT_RGB24: test->rgba_map[R] = 0; test->rgba_map[G] = 1; test->rgba_map[B] = 2; test->rgba_map[A] = 3; break;
482  case AV_PIX_FMT_BGRA:
483  case AV_PIX_FMT_BGR24: test->rgba_map[B] = 0; test->rgba_map[G] = 1; test->rgba_map[R] = 2; test->rgba_map[A] = 3; break;
484  }
485 
486  return config_props(outlink);
487 }
488 
489 static const AVFilterPad avfilter_vsrc_rgbtestsrc_outputs[] = {
490  {
491  .name = "default",
492  .type = AVMEDIA_TYPE_VIDEO,
493  .request_frame = request_frame,
494  .config_props = rgbtest_config_props,
495  },
496  { NULL }
497 };
498 
499 AVFilter avfilter_vsrc_rgbtestsrc = {
500  .name = "rgbtestsrc",
501  .description = NULL_IF_CONFIG_SMALL("Generate RGB test pattern."),
502  .priv_size = sizeof(TestSourceContext),
503  .init = rgbtest_init,
504 
505  .query_formats = rgbtest_query_formats,
506 
507  .inputs = NULL,
508 
509  .outputs = avfilter_vsrc_rgbtestsrc_outputs,
510 };
511 
512 #endif /* CONFIG_RGBTESTSRC_FILTER */
int size
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:122
AVOption.
Definition: opt.h:233
AVFilterBufferRefVideoProps * video
video buffer specific properties
Definition: avfilter.h:159
int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str)
Parse str and put in width_ptr and height_ptr the detected values.
Definition: parseutils.c:95
int linesize[8]
number of bytes per line
Definition: avfilter.h:157
#define B
Definition: dsputil.c:1897
static const AVFilterPad outputs[]
Definition: af_ashowinfo.c:122
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:67
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:482
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:505
int ff_filter_frame(AVFilterLink *link, AVFilterBufferRef *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:459
int num
numerator
Definition: rational.h:44
int av_set_options_string(void *ctx, const char *opts, const char *key_val_sep, const char *pairs_sep)
Parse the key/value pairs list in opts.
Definition: opt.c:587
static int query_formats(AVFilterContext *ctx)
Definition: af_aformat.c:121
void(* fill_picture_fn)(AVFilterContext *ctx, AVFilterBufferRef *picref)
Definition: vsrc_testsrc.c:56
static int64_t duration
Definition: avplay.c:249
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:165
const char * name
Pad name.
Definition: internal.h:39
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:38
#define AV_WL24(p, d)
Definition: intreadwrite.h:426
uint8_t
AVOptions.
#define b
Definition: input.c:52
#define AV_WL32(p, d)
Definition: intreadwrite.h:255
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:95
const char data[16]
Definition: mxf.c:66
static double av_q2d(AVRational a)
Convert rational to double.
Definition: rational.h:69
#define R
Definition: dsputil.c:1899
int key_frame
1 -> keyframe, 0-> not
Definition: avfilter.h:128
static int request_frame(AVFilterLink *outlink)
Definition: vsrc_testsrc.c:130
static const AVOption testsrc_options[]
Definition: vsrc_testsrc.c:64
void ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:375
AVRational pixel_aspect
pixel aspect ratio
Definition: avfilter.h:124
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
#define r
Definition: input.c:51
int64_t pts
presentation timestamp.
Definition: avfilter.h:167
A filter pad used for either input or output.
Definition: internal.h:33
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:122
AVFilterBufferRef * ff_get_video_buffer(AVFilterLink *link, int perms, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:145
int h
image height
Definition: avfilter.h:123
static const uint16_t mask[17]
Definition: lzw.c:38
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:96
g
Definition: yuv2rgb.c:540
void * priv
private data for use by the filter
Definition: avfilter.h:439
const AVClass * class
Definition: vsrc_testsrc.c:46
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:93
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:94
AVRational sar
sample aspect ratio
Definition: vsrc_testsrc.c:54
static int config_props(AVFilterLink *outlink)
Definition: vsrc_testsrc.c:118
int32_t
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:68
static av_cold int init_common(AVFilterContext *ctx, const char *args)
Definition: vsrc_testsrc.c:74
char * rate
video frame rate
Definition: vsrc_testsrc.c:52
A reference to an AVFilterBuffer.
Definition: avfilter.h:139
NULL
Definition: eval.c:52
static int width
Definition: utils.c:156
static void test(const char *base, const char *rel)
Definition: url-test.c:23
static void(WINAPI *cond_broadcast)(pthread_cond_t *cond)
enum AVPictureType pict_type
picture type of the frame
Definition: avfilter.h:127
Describe the class of an AVClass context structure.
Definition: log.h:33
Filter definition.
Definition: avfilter.h:371
static const AVFilterPad inputs[]
Definition: af_ashowinfo.c:110
rational number numerator/denominator
Definition: rational.h:43
const char * name
filter name
Definition: avfilter.h:372
static int step
Definition: avplay.c:252
char * duration
total duration of the generated video
Definition: vsrc_testsrc.c:53
misc parsing utilities
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:433
AVRational time_base
Definition: vsrc_testsrc.c:49
int height
Definition: gxfenc.c:72
int interlaced
is frame interlaced
Definition: avfilter.h:125
common internal and external API header
unsigned int nb_frame
Definition: vsrc_testsrc.c:48
char * size
video frame size
Definition: vsrc_testsrc.c:51
int den
denominator
Definition: rational.h:45
static const uint8_t color[]
Definition: log.c:52
#define AV_PERM_WRITE
can write to the buffer
Definition: avfilter.h:98
int64_t pos
byte position in stream, -1 if unknown
Definition: avfilter.h:168
uint8_t * data[8]
picture/audio data for each plane
Definition: avfilter.h:141
#define G
Definition: dsputil.c:1898
#define OFFSET(x)
Definition: vsrc_testsrc.c:62
An instance of a filter.
Definition: avfilter.h:418
Definition: vf_drawbox.c:36
internal API functions
AVPixelFormat
Pixel format.
Definition: pixfmt.h:63