FFmpeg
src_avsynctest.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017-2022 Paul B Mahol
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "libavutil/avassert.h"
22 #include "libavutil/common.h"
23 #include "libavutil/channel_layout.h"
24 #include "libavutil/ffmath.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/imgutils.h"
27 #include "libavutil/intreadwrite.h"
28 #include "libavutil/parseutils.h"
29 #include "libavutil/timestamp.h"
30 #include "libavutil/xga_font_data.h"
31 #include "avfilter.h"
32 #include "drawutils.h"
33 #include "filters.h"
34 #include "formats.h"
35 #include "audio.h"
36 #include "video.h"
37 
38 typedef struct AVSyncTestContext {
39  const AVClass *class;
40 
41  int w, h;
42  AVRational frame_rate;
43  int sample_rate;
44  int64_t duration;
45  int64_t apts, vpts;
46  float amplitude;
47  int period;
48  int delay;
49  int cycle;
50 
51  int beep;
52  int beep_duration;
53  int flash;
54  int dir;
55  AVRational vdelay, delay_max, delay_min;
56  AVRational delay_range;
57  int64_t prev_intpart;
58 
59  uint8_t rgba[3][4];
60  FFDrawContext draw;
61  FFDrawColor fg;
62  FFDrawColor bg;
63  FFDrawColor ag;
64 } AVSyncTestContext;
65 
66 #define OFFSET(x) offsetof(AVSyncTestContext, x)
67 #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
68 #define V AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
69 #define R AV_OPT_FLAG_RUNTIME_PARAM
70 
71 static const AVOption avsynctest_options[] = {
72  {"size", "set frame size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str="hd720"}, 0, 0, V },
73  {"s", "set frame size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str="hd720"}, 0, 0, V },
74  {"framerate", "set frame rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str="30"}, 0,INT_MAX, V },
75  {"fr", "set frame rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str="30"}, 0,INT_MAX, V },
76  {"samplerate", "set sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64=44100},8000,384000, A },
77  {"sr", "set sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64=44100},8000,384000, A },
78  {"amplitude", "set beep amplitude", OFFSET(amplitude), AV_OPT_TYPE_FLOAT, {.dbl=.7}, 0., 1., A|R },
79  {"a", "set beep amplitude", OFFSET(amplitude), AV_OPT_TYPE_FLOAT, {.dbl=.7}, 0., 1., A|R },
80  {"period", "set beep period", OFFSET(period), AV_OPT_TYPE_INT, {.i64=3}, 1, 99., A },
81  {"p", "set beep period", OFFSET(period), AV_OPT_TYPE_INT, {.i64=3}, 1, 99., A },
82  {"delay", "set flash delay", OFFSET(delay), AV_OPT_TYPE_INT, {.i64=0}, -30, 30, V|R },
83  {"dl", "set flash delay", OFFSET(delay), AV_OPT_TYPE_INT, {.i64=0}, -30, 30, V|R },
84  {"cycle", "set delay cycle", OFFSET(cycle), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, V|R },
85  {"c", "set delay cycle", OFFSET(cycle), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, V|R },
86  {"duration", "set duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64=0}, 0, INT64_MAX, V|A },
87  {"d", "set duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64=0}, 0, INT64_MAX, V|A },
88  {"fg", "set foreground color", OFFSET(rgba[0]), AV_OPT_TYPE_COLOR, {.str="white"}, 0, 0, V },
89  {"bg", "set background color", OFFSET(rgba[1]), AV_OPT_TYPE_COLOR, {.str="black"}, 0, 0, V },
90  {"ag", "set additional color", OFFSET(rgba[2]), AV_OPT_TYPE_COLOR, {.str="gray"}, 0, 0, V },
91  {NULL},
92 };
93 
94 AVFILTER_DEFINE_CLASS(avsynctest);
95 
96 static av_cold int query_formats(const AVFilterContext *ctx,
97  AVFilterFormatsConfig **cfg_in,
98  AVFilterFormatsConfig **cfg_out)
99 {
100  const AVSyncTestContext *s = ctx->priv;
101  int sample_rates[] = { s->sample_rate, -1 };
102  static const enum AVSampleFormat sample_fmts[] = {
103  AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_NONE
104  };
105  static const AVChannelLayout layouts[] = {
106  AV_CHANNEL_LAYOUT_MONO,
107  { .nb_channels = 0 },
108  };
109  AVFilterFormats *formats;
110  int ret;
111 
112  formats = ff_make_format_list(sample_fmts);
113  if (!formats)
114  return AVERROR(ENOMEM);
115  if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
116  return ret;
117 
118  formats = ff_draw_supported_pixel_formats(0);
119  if (!formats)
120  return AVERROR(ENOMEM);
121  if ((ret = ff_formats_ref(formats, &cfg_out[1]->formats)) < 0)
122  return ret;
123 
124  ret = ff_set_common_channel_layouts_from_list2(ctx, cfg_in, cfg_out, layouts);
125  if (ret < 0)
126  return ret;
127 
128  return ff_set_common_samplerates_from_list2(ctx, cfg_in, cfg_out, sample_rates);
129 }
130 
131 static av_cold int aconfig_props(AVFilterLink *outlink)
132 {
133  AVFilterContext *ctx = outlink->src;
134  AVSyncTestContext *s = ctx->priv;
135 
136  outlink->sample_rate = s->sample_rate;
137  outlink->time_base = (AVRational){1, s->sample_rate};
138 
139  s->beep_duration = av_rescale(s->sample_rate, s->frame_rate.den, s->frame_rate.num);
140  s->duration = av_rescale(s->duration, s->sample_rate, AV_TIME_BASE);
141 
142  return 0;
143 }
144 
145 static av_cold int config_props(AVFilterLink *outlink)
146 {
147  FilterLink *l = ff_filter_link(outlink);
148  AVFilterContext *ctx = outlink->src;
149  AVSyncTestContext *s = ctx->priv;
150  int ret;
151 
152  outlink->w = s->w;
153  outlink->h = s->h;
154  outlink->time_base = av_inv_q(s->frame_rate);
155  l->frame_rate = s->frame_rate;
156  outlink->sample_aspect_ratio = (AVRational) {1, 1};
157  s->delay_min = av_mul_q(s->frame_rate, av_make_q(-1, 2));
158  s->delay_max = av_mul_q(s->delay_min, av_make_q(-1, 1));
159  s->delay_range = av_sub_q(s->delay_max, s->delay_min);
160  s->vdelay = av_make_q(s->delay, 1);
161  s->dir = 1;
162  s->prev_intpart = INT64_MIN;
163 
164  ret = ff_draw_init2(&s->draw, outlink->format, outlink->colorspace, outlink->color_range, 0);
165  if (ret < 0) {
166  av_log(ctx, AV_LOG_ERROR, "Failed to initialize FFDrawContext\n");
167  return ret;
168  }
169 
170  ff_draw_color(&s->draw, &s->fg, s->rgba[0]);
171  ff_draw_color(&s->draw, &s->bg, s->rgba[1]);
172  ff_draw_color(&s->draw, &s->ag, s->rgba[2] );
173 
174  return 0;
175 }
176 
177 #define FPI 0x8000
178 
179 static int32_t sin32(int32_t x, AVRational scale)
180 {
181  const double pi = M_PI;
182  const int32_t a = ((2.0 * pi) * (1 << 24));
183  const int32_t b = (1 << 7) * (12.0 / pi - 1.0 - pi) * (1 << 24);
184  const int32_t c = (1 << 9) * 3.0 * (2.0 + pi - 16.0 / pi) * (1 << 24);
185  int64_t x2, result;
186  int32_t t1, t2;
187 
188  x &= 2 * FPI - 1;
189 
190  if (x >= (3 * FPI / 2))
191  x = x - 2 * FPI;
192  else if (x > FPI / 2)
193  x = FPI - x;
194 
195  x2 = x * x;
196  t1 = (x2 * c) >> 32;
197  t2 = ((b + t1) * x2) >> 32;
198  x = x << 8;
199 
200  result = a + t2;
201  result *= x;
202  result += (1U << 31);
203  result >>= 17;
204  result = av_rescale(result, scale.num, scale.den);
205 
206  return result;
207 }
208 
209 static int audio_frame(AVFilterLink *outlink)
210 {
211  AVFilterContext *ctx = outlink->src;
212  AVSyncTestContext *s = ctx->priv;
213  const AVRational a = av_d2q(s->amplitude, 32768);
214  int64_t duration[2];
215  int64_t delta;
216  AVFrame *out;
217  int32_t *dst;
218 
219  delta = av_rescale_q(s->vpts, av_make_q(s->sample_rate, 1), s->frame_rate) - s->apts;
220  if (delta < 0)
221  return 1;
222 
223  duration[0] = av_rescale_rnd(s->sample_rate, s->frame_rate.den, s->frame_rate.num, AV_ROUND_DOWN);
224  duration[1] = av_rescale_rnd(s->sample_rate, s->frame_rate.den, s->frame_rate.num, AV_ROUND_UP);
225 
226  delta = duration[delta > 0];
227  out = ff_get_audio_buffer(outlink, delta);
228  if (!out)
229  return AVERROR(ENOMEM);
230 
231  out->pts = s->apts;
232  dst = (int32_t *)out->data[0];
233 
234  for (int i = 0; i < delta; i++) {
235  if (((s->apts + i) % (s->period * s->sample_rate)) == 0)
236  s->beep = 1;
237  if (s->beep) {
238  dst[i] = sin32(av_rescale_q(800LL * 2LL * FPI, outlink->time_base, av_make_q(1, s->apts + i)), a);
239  s->beep++;
240  } else {
241  dst[i] = 0;
242  }
243  if (s->beep >= s->beep_duration) {
244  s->beep = 0;
245  }
246  }
247  s->apts += out->nb_samples;
248 
249  return ff_filter_frame(outlink, out);
250 }
251 
252 static void draw_text(FFDrawContext *draw, AVFrame *out, FFDrawColor *color,
253  int x0, int y0, const uint8_t *text)
254 {
255  int x = x0;
256 
257  for (; *text; text++) {
258  if (*text == '\n') {
259  x = x0;
260  y0 += 8;
261  continue;
262  }
263  ff_blend_mask(draw, color, out->data, out->linesize,
264  out->width, out->height,
265  avpriv_cga_font + *text * 8, 1, 8, 8, 0, 0, x, y0);
266  x += 8;
267  }
268 }
269 
270 static int offset(int x, int num, int den)
271 {
272  return av_rescale_rnd(x, num, den, AV_ROUND_UP);
273 }
274 
275 static int video_frame(AVFilterLink *outlink)
276 {
277  AVFilterContext *ctx = outlink->src;
278  AVSyncTestContext *s = ctx->priv;
279  const int w = outlink->w;
280  const int h = outlink->h;
281  const int step = av_rescale_rnd(w, s->delay_range.den, s->delay_range.num, AV_ROUND_DOWN);
282  char text[128];
283  int new_offset;
284  int64_t delta, temp, intpart;
285  AVFrame *out;
286 
287  if (!s->cycle)
288  s->vdelay = av_make_q(s->delay, 1);
289 
290  delta = av_rescale_q(s->apts, s->frame_rate, av_make_q(s->sample_rate, 1)) - s->vpts;
291  if (delta < 0)
292  return 1;
293 
294  out = ff_get_video_buffer(outlink, w, h);
295  if (!out)
296  return AVERROR(ENOMEM);
297 
298  ff_fill_rectangle(&s->draw, &s->bg, out->data, out->linesize, 0, 0, w, h);
299 
300  snprintf(text, sizeof(text), "FRN: %"PRId64"", s->vpts);
301  draw_text(&s->draw, out, &s->fg, offset(w, 1, 10), offset(h, 1, 10), text);
302 
303  snprintf(text, sizeof(text), "SEC: %s", av_ts2timestr(s->vpts, &outlink->time_base));
304  draw_text(&s->draw, out, &s->fg, offset(w, 1, 10), offset(h, 9, 10), text);
305 
306  snprintf(text, sizeof(text), "DLY: %d", s->vdelay.num);
307  draw_text(&s->draw, out, &s->fg, offset(w, 9, 10) - strlen(text) * 8, offset(h, 9, 10), text);
308 
309  snprintf(text, sizeof(text), "FPS: %d/%d", s->frame_rate.num, s->frame_rate.den);
310  draw_text(&s->draw, out, &s->fg, offset(w, 9, 10) - strlen(text) * 8, offset(h, 1, 10), text);
311 
312  snprintf(text, sizeof(text), "P: %d", s->period);
313  draw_text(&s->draw, out, &s->ag, offset(w, 1, 2) - strlen(text) * 4, offset(h, 9, 10), text);
314 
315  snprintf(text, sizeof(text), "SR: %d", s->sample_rate);
316  draw_text(&s->draw, out, &s->ag, offset(w, 1, 2) - strlen(text) * 4, offset(h, 1, 10), text);
317 
318  snprintf(text, sizeof(text), "A: %1.2f", s->amplitude);
319  draw_text(&s->draw, out, &s->ag, offset(w, 1, 10), offset(h, 1, 2), text);
320 
321  snprintf(text, sizeof(text), "WxH: %dx%d", w, h);
322  draw_text(&s->draw, out, &s->ag, offset(w, 9, 10) - strlen(text) * 8, offset(h, 1, 2), text);
323 
324  temp = s->vpts + s->vdelay.num;
325  intpart = av_rescale_rnd(temp, outlink->time_base.num, outlink->time_base.den, AV_ROUND_NEAR_INF);
326  intpart = temp - av_rescale_rnd(intpart, outlink->time_base.den, outlink->time_base.num, AV_ROUND_NEAR_INF);
327 
328  new_offset = offset(w, 1, 2);
329  ff_fill_rectangle(&s->draw, &s->fg, out->data, out->linesize,
330  av_clip(new_offset + step * intpart, 0, w - 2),
331  offset(h, 141, 200), offset(step, 2, 3), offset(h, 1, 25));
332 
333  if (intpart == 0 && s->prev_intpart != intpart) {
334  if (s->flash >= s->period) {
335  int result;
336 
337  if (s->cycle)
338  s->vdelay = av_add_q(s->vdelay, av_make_q(s->dir, 1));
339  result = av_cmp_q(s->vdelay, s->delay_max);
340  if (result >= 0)
341  s->dir = -1;
342  result = av_cmp_q(s->vdelay, s->delay_min);
343  if (result <= 0)
344  s->dir = 1;
345  ff_fill_rectangle(&s->draw, &s->fg, out->data, out->linesize,
346  offset(w, 1, 3), offset(h, 1, 3), offset(w, 1, 3), offset(h, 1, 4));
347  s->flash = 0;
348  }
349  s->flash++;
350  }
351  s->prev_intpart = intpart;
352 
353  for (int i = av_rescale(s->delay_min.num, 1, s->delay_min.den);
354  i < av_rescale(s->delay_max.num, 1, s->delay_max.den); i++) {
355  ff_fill_rectangle(&s->draw, &s->fg, out->data, out->linesize,
356  av_clip(new_offset + step * i, 0, w - 2),
357  offset(h, 7, 10), 1, offset(h, 1, 20));
358  }
359 
360  out->pts = s->vpts++;
361  out->duration = 1;
362 
363  return ff_filter_frame(outlink, out);
364 }
365 
366 static int activate(AVFilterContext *ctx)
367 {
368  AVSyncTestContext *s = ctx->priv;
369  AVFilterLink *aoutlink = ctx->outputs[0];
370  AVFilterLink *voutlink = ctx->outputs[1];
371  int ret = FFERROR_NOT_READY;
372 
373  if (!ff_outlink_frame_wanted(aoutlink) &&
374  !ff_outlink_frame_wanted(voutlink))
375  return ret;
376 
377  if (s->duration > 0 && s->apts >= s->duration) {
378  ff_outlink_set_status(aoutlink, AVERROR_EOF, s->apts);
379  ff_outlink_set_status(voutlink, AVERROR_EOF, s->vpts);
380  return 0;
381  }
382 
383  ret = audio_frame(aoutlink);
384  if (ret < 0)
385  return ret;
386  ret = video_frame(voutlink);
387 
388  return ret;
389 }
390 
391 static const AVFilterPad avsynctest_outputs[] = {
392  {
393  .name = "audio",
394  .type = AVMEDIA_TYPE_AUDIO,
395  .config_props = aconfig_props,
396  },
397  {
398  .name = "video",
399  .type = AVMEDIA_TYPE_VIDEO,
400  .config_props = config_props,
401  },
402 };
403 
404 const FFFilter ff_avsrc_avsynctest = {
405  .p.name = "avsynctest",
406  .p.description = NULL_IF_CONFIG_SMALL("Generate an Audio Video Sync Test."),
407  .p.priv_class = &avsynctest_class,
408  .priv_size = sizeof(AVSyncTestContext),
409  .activate = activate,
410  FILTER_OUTPUTS(avsynctest_outputs),
411  FILTER_QUERY_FUNC2(query_formats),
412  .process_command = ff_filter_process_command,
413 };
formats
formats
Definition: signature.h:47
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
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:134
ff_get_audio_buffer
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:98
avsynctest_outputs
static const AVFilterPad avsynctest_outputs[]
Definition: src_avsynctest.c:391
FFDrawColor
Definition: drawutils.h:51
AVSyncTestContext::amplitude
float amplitude
Definition: src_avsynctest.c:46
av_clip
#define av_clip
Definition: common.h:100
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
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:435
out
FILE * out
Definition: movenc.c:55
color
Definition: vf_paletteuse.c:513
AVSyncTestContext::fg
FFDrawColor fg
Definition: src_avsynctest.c:61
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1062
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:335
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
AV_OPT_TYPE_VIDEO_RATE
@ AV_OPT_TYPE_VIDEO_RATE
Underlying C type is AVRational.
Definition: opt.h:315
int64_t
long long int64_t
Definition: coverity.c:34
sample_rates
static const int sample_rates[]
Definition: dcaenc.h:34
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:421
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
AVSyncTestContext::apts
int64_t apts
Definition: src_avsynctest.c:45
AVOption
AVOption.
Definition: opt.h:429
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(avsynctest)
b
#define b
Definition: input.c:42
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Underlying C type is int64_t.
Definition: opt.h:319
ff_set_common_channel_layouts_from_list2
int ff_set_common_channel_layouts_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const AVChannelLayout *fmts)
Definition: formats.c:920
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:215
av_sub_q
AVRational av_sub_q(AVRational b, AVRational c)
Subtract one rational from another.
Definition: rational.c:101
AVSyncTestContext::dir
int dir
Definition: src_avsynctest.c:54
video.h
AVSyncTestContext::beep_duration
int beep_duration
Definition: src_avsynctest.c:52
AVSyncTestContext::prev_intpart
int64_t prev_intpart
Definition: src_avsynctest.c:57
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
AVSyncTestContext::period
int period
Definition: src_avsynctest.c:47
formats.h
AVSyncTestContext::cycle
int cycle
Definition: src_avsynctest.c:49
ff_avsrc_avsynctest
const FFFilter ff_avsrc_avsynctest
Definition: src_avsynctest.c:404
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:545
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVSyncTestContext::beep
int beep
Definition: src_avsynctest.c:51
AVSyncTestContext::duration
int64_t duration
Definition: src_avsynctest.c:44
AVSyncTestContext::ag
FFDrawColor ag
Definition: src_avsynctest.c:63
AVSyncTestContext::delay_min
AVRational delay_min
Definition: src_avsynctest.c:55
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:39
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:90
FFFilter
Definition: filters.h:266
duration
int64_t duration
Definition: movenc.c:65
FPI
#define FPI
Definition: src_avsynctest.c:177
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:628
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVSyncTestContext::delay_range
AVRational delay_range
Definition: src_avsynctest.c:56
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:678
filters.h
AVSyncTestContext::draw
FFDrawContext draw
Definition: src_avsynctest.c:60
ff_set_common_samplerates_from_list2
int ff_set_common_samplerates_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *samplerates)
Definition: formats.c:944
ctx
AVFormatContext * ctx
Definition: movenc.c:49
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
AV_ROUND_NEAR_INF
@ AV_ROUND_NEAR_INF
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:135
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:264
AVSyncTestContext::delay_max
AVRational delay_max
Definition: src_avsynctest.c:55
if
if(ret)
Definition: filter_design.txt:179
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
period
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 default minimum maximum flags name is the option keep it simple and lowercase description are in without period
Definition: writing_filters.txt:89
query_formats
static av_cold int query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: src_avsynctest.c:96
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
parseutils.h
AVSyncTestContext::frame_rate
AVRational frame_rate
Definition: src_avsynctest.c:42
AVSyncTestContext::h
int h
Definition: src_avsynctest.c:41
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:121
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:198
AVSyncTestContext::rgba
uint8_t rgba[3][4]
Definition: src_avsynctest.c:59
aconfig_props
static av_cold int aconfig_props(AVFilterLink *outlink)
Definition: src_avsynctest.c:131
AV_ROUND_DOWN
@ AV_ROUND_DOWN
Round toward -infinity.
Definition: mathematics.h:133
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
av_ts2timestr
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:83
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
AVSyncTestContext::w
int w
Definition: src_avsynctest.c:41
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:319
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
video_frame
static int video_frame(AVFilterLink *outlink)
Definition: src_avsynctest.c:275
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:96
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
offset
static int offset(int x, int num, int den)
Definition: src_avsynctest.c:270
avsynctest_options
static const AVOption avsynctest_options[]
Definition: src_avsynctest.c:71
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
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
AVSyncTestContext::vpts
int64_t vpts
Definition: src_avsynctest.c:45
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:900
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
xga_font_data.h
M_PI
#define M_PI
Definition: mathematics.h:67
draw
static int draw(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: avf_showcwt.c:440
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
Definition: opt.h:271
activate
static int activate(AVFilterContext *ctx)
Definition: src_avsynctest.c:366
AVSyncTestContext::bg
FFDrawColor bg
Definition: src_avsynctest.c:62
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:253
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:658
common.h
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
delta
float delta
Definition: vorbis_enc_data.h:430
FILTER_QUERY_FUNC2
#define FILTER_QUERY_FUNC2(func)
Definition: filters.h:240
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
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
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:45
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
V
#define V
Definition: src_avsynctest.c:68
ff_draw_color
void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4])
Prepare a color.
Definition: drawutils.c:172
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
ret
ret
Definition: filter_design.txt:187
AVSyncTestContext::delay
int delay
Definition: src_avsynctest.c:48
AVSyncTestContext::sample_rate
int sample_rate
Definition: src_avsynctest.c:43
U
#define U(x)
Definition: vpx_arith.h:37
draw_text
static void draw_text(FFDrawContext *draw, AVFrame *out, FFDrawColor *color, int x0, int y0, const uint8_t *text)
Definition: src_avsynctest.c:252
AVSyncTestContext
Definition: src_avsynctest.c:38
channel_layout.h
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
avfilter.h
A
#define A
Definition: src_avsynctest.c:67
temp
else temp
Definition: vf_mcdeint.c:271
ffmath.h
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVFilterContext
An instance of a filter.
Definition: avfilter.h:269
R
#define R
Definition: src_avsynctest.c:69
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
FFFilter::p
AVFilter p
The public AVFilter.
Definition: filters.h:270
audio.h
AVSyncTestContext::flash
int flash
Definition: src_avsynctest.c:53
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:394
avpriv_cga_font
const uint8_t avpriv_cga_font[2048]
Definition: xga_font_data.c:29
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:273
sin32
static int32_t sin32(int32_t x, AVRational scale)
Definition: src_avsynctest.c:179
av_add_q
AVRational av_add_q(AVRational b, AVRational c)
Add two rationals.
Definition: rational.c:93
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
int32_t
int32_t
Definition: audioconvert.c:56
imgutils.h
OFFSET
#define OFFSET(x)
Definition: src_avsynctest.c:66
timestamp.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
audio_frame
static int audio_frame(AVFilterLink *outlink)
Definition: src_avsynctest.c:209
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
drawutils.h
AVSyncTestContext::vdelay
AVRational vdelay
Definition: src_avsynctest.c:55
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:59
snprintf
#define snprintf
Definition: snprintf.h:34
config_props
static av_cold int config_props(AVFilterLink *outlink)
Definition: src_avsynctest.c:145
Generated on Mon Jul 14 2025 19:22:43 for FFmpeg by   doxygen 1.8.17