FFmpeg
af_adelay.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013 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/avstring.h"
22 #include "libavutil/eval.h"
23 #include "libavutil/opt.h"
24 #include "libavutil/samplefmt.h"
25 #include "avfilter.h"
26 #include "audio.h"
27 #include "filters.h"
28 #include "internal.h"
29 
30 typedef struct ChanDelay {
31  int64_t delay;
32  size_t delay_index;
33  size_t index;
34  unsigned int samples_size;
35  uint8_t *samples;
36 } ChanDelay;
37 
38 typedef struct AudioDelayContext {
39  const AVClass *class;
40  int all;
41  char *delays;
43  int nb_delays;
45  int64_t padding;
46  int64_t max_delay;
47  int64_t next_pts;
48  int eof;
49 
50  void (*delay_channel)(ChanDelay *d, int nb_samples,
51  const uint8_t *src, uint8_t *dst);
52  int (*resize_channel_samples)(ChanDelay *d, int64_t new_delay);
54 
55 #define OFFSET(x) offsetof(AudioDelayContext, x)
56 #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
57 
58 static const AVOption adelay_options[] = {
59  { "delays", "set list of delays for each channel", OFFSET(delays), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, A | AV_OPT_FLAG_RUNTIME_PARAM },
60  { "all", "use last available delay for remained channels", OFFSET(all), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, A },
61  { NULL }
62 };
63 
64 AVFILTER_DEFINE_CLASS(adelay);
65 
66 #define DELAY(name, type, fill) \
67 static void delay_channel_## name ##p(ChanDelay *d, int nb_samples, \
68  const uint8_t *ssrc, uint8_t *ddst) \
69 { \
70  const type *src = (type *)ssrc; \
71  type *dst = (type *)ddst; \
72  type *samples = (type *)d->samples; \
73  \
74  while (nb_samples) { \
75  if (d->delay_index < d->delay) { \
76  const int len = FFMIN(nb_samples, d->delay - d->delay_index); \
77  \
78  memcpy(&samples[d->delay_index], src, len * sizeof(type)); \
79  memset(dst, fill, len * sizeof(type)); \
80  d->delay_index += len; \
81  src += len; \
82  dst += len; \
83  nb_samples -= len; \
84  } else { \
85  *dst = samples[d->index]; \
86  samples[d->index] = *src; \
87  nb_samples--; \
88  d->index++; \
89  src++, dst++; \
90  d->index = d->index >= d->delay ? 0 : d->index; \
91  } \
92  } \
93 }
94 
95 DELAY(u8, uint8_t, 0x80)
96 DELAY(s16, int16_t, 0)
97 DELAY(s32, int32_t, 0)
98 DELAY(flt, float, 0)
99 DELAY(dbl, double, 0)
100 
101 #define CHANGE_DELAY(name, type, fill) \
102 static int resize_samples_## name ##p(ChanDelay *d, int64_t new_delay) \
103 { \
104  type *samples; \
105  \
106  if (new_delay == d->delay) { \
107  return 0; \
108  } \
109  \
110  if (new_delay == 0) { \
111  av_freep(&d->samples); \
112  d->samples_size = 0; \
113  d->delay = 0; \
114  d->index = 0; \
115  d->delay_index = 0; \
116  return 0; \
117  } \
118  \
119  samples = (type *) av_fast_realloc(d->samples, &d->samples_size, new_delay * sizeof(type)); \
120  if (!samples) { \
121  return AVERROR(ENOMEM); \
122  } \
123  \
124  if (new_delay < d->delay) { \
125  if (d->index > new_delay) { \
126  d->index -= new_delay; \
127  memmove(samples, &samples[new_delay], d->index * sizeof(type)); \
128  d->delay_index = new_delay; \
129  } else if (d->delay_index > d->index) { \
130  memmove(&samples[d->index], &samples[d->index+(d->delay-new_delay)], \
131  (new_delay - d->index) * sizeof(type)); \
132  d->delay_index -= d->delay - new_delay; \
133  } \
134  } else { \
135  size_t block_size; \
136  if (d->delay_index >= d->delay) { \
137  block_size = (d->delay - d->index) * sizeof(type); \
138  memmove(&samples[d->index+(new_delay - d->delay)], &samples[d->index], block_size); \
139  d->delay_index = new_delay; \
140  } else { \
141  d->delay_index += new_delay - d->delay; \
142  } \
143  block_size = (new_delay - d->delay) * sizeof(type); \
144  memset(&samples[d->index], fill, block_size); \
145  } \
146  d->delay = new_delay; \
147  d->samples = (void *) samples; \
148  return 0; \
149 }
150 
151 CHANGE_DELAY(u8, uint8_t, 0x80)
152 CHANGE_DELAY(s16, int16_t, 0)
153 CHANGE_DELAY(s32, int32_t, 0)
154 CHANGE_DELAY(flt, float, 0)
155 CHANGE_DELAY(dbl, double, 0)
156 
157 static int parse_delays(char *p, char **saveptr, int64_t *result, AVFilterContext *ctx, int sample_rate) {
158  float delay, div;
159  int ret;
160  char *arg;
161  char type = 0;
162 
163  if (!(arg = av_strtok(p, "|", saveptr)))
164  return 1;
165 
166  ret = av_sscanf(arg, "%"SCNd64"%c", result, &type);
167  if (ret != 2 || type != 'S') {
168  div = type == 's' ? 1.0 : 1000.0;
169  if (av_sscanf(arg, "%f", &delay) != 1) {
170  av_log(ctx, AV_LOG_ERROR, "Invalid syntax for delay.\n");
171  return AVERROR(EINVAL);
172  }
173  *result = delay * sample_rate / div;
174  }
175 
176  if (*result < 0) {
177  av_log(ctx, AV_LOG_ERROR, "Delay must be non negative number.\n");
178  return AVERROR(EINVAL);
179  }
180  return 0;
181 }
182 
184 {
185  AVFilterContext *ctx = inlink->dst;
186  AudioDelayContext *s = ctx->priv;
187  char *p, *saveptr = NULL;
188  int i;
189 
190  s->chandelay = av_calloc(inlink->ch_layout.nb_channels, sizeof(*s->chandelay));
191  if (!s->chandelay)
192  return AVERROR(ENOMEM);
193  s->nb_delays = inlink->ch_layout.nb_channels;
194  s->block_align = av_get_bytes_per_sample(inlink->format);
195 
196  p = s->delays;
197  for (i = 0; i < s->nb_delays; i++) {
198  ChanDelay *d = &s->chandelay[i];
199  int ret;
200 
201  ret = parse_delays(p, &saveptr, &d->delay, ctx, inlink->sample_rate);
202  if (ret == 1)
203  break;
204  else if (ret < 0)
205  return ret;
206  p = NULL;
207  }
208 
209  if (s->all && i) {
210  for (int j = i; j < s->nb_delays; j++)
211  s->chandelay[j].delay = s->chandelay[i-1].delay;
212  }
213 
214  s->padding = s->chandelay[0].delay;
215  for (i = 1; i < s->nb_delays; i++) {
216  ChanDelay *d = &s->chandelay[i];
217 
218  s->padding = FFMIN(s->padding, d->delay);
219  }
220 
221  if (s->padding) {
222  for (i = 0; i < s->nb_delays; i++) {
223  ChanDelay *d = &s->chandelay[i];
224 
225  d->delay -= s->padding;
226  }
227  }
228 
229  for (i = 0; i < s->nb_delays; i++) {
230  ChanDelay *d = &s->chandelay[i];
231 
232  if (!d->delay)
233  continue;
234 
235  if (d->delay > SIZE_MAX) {
236  av_log(ctx, AV_LOG_ERROR, "Requested delay is too big.\n");
237  return AVERROR(EINVAL);
238  }
239 
240  d->samples = av_malloc_array(d->delay, s->block_align);
241  if (!d->samples)
242  return AVERROR(ENOMEM);
243  d->samples_size = d->delay * s->block_align;
244 
245  s->max_delay = FFMAX(s->max_delay, d->delay);
246  }
247 
248  switch (inlink->format) {
249  case AV_SAMPLE_FMT_U8P : s->delay_channel = delay_channel_u8p ;
250  s->resize_channel_samples = resize_samples_u8p; break;
251  case AV_SAMPLE_FMT_S16P: s->delay_channel = delay_channel_s16p;
252  s->resize_channel_samples = resize_samples_s16p; break;
253  case AV_SAMPLE_FMT_S32P: s->delay_channel = delay_channel_s32p;
254  s->resize_channel_samples = resize_samples_s32p; break;
255  case AV_SAMPLE_FMT_FLTP: s->delay_channel = delay_channel_fltp;
256  s->resize_channel_samples = resize_samples_fltp; break;
257  case AV_SAMPLE_FMT_DBLP: s->delay_channel = delay_channel_dblp;
258  s->resize_channel_samples = resize_samples_dblp; break;
259  }
260 
261  return 0;
262 }
263 
264 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
265  char *res, int res_len, int flags)
266 {
267  int ret = AVERROR(ENOSYS);
268  AVFilterLink *inlink = ctx->inputs[0];
269  AudioDelayContext *s = ctx->priv;
270 
271  if (!strcmp(cmd, "delays")) {
272  int64_t delay;
273  char *p, *saveptr = NULL;
274  int64_t all_delay = -1;
275  int64_t max_delay = 0;
276  char *args_cpy = av_strdup(args);
277  if (args_cpy == NULL) {
278  return AVERROR(ENOMEM);
279  }
280 
281  ret = 0;
282  p = args_cpy;
283 
284  if (!strncmp(args, "all:", 4)) {
285  p = &args_cpy[4];
286  ret = parse_delays(p, &saveptr, &all_delay, ctx, inlink->sample_rate);
287  if (ret == 1)
288  ret = AVERROR(EINVAL);
289  else if (ret == 0)
290  delay = all_delay;
291  }
292 
293  if (!ret) {
294  for (int i = 0; i < s->nb_delays; i++) {
295  ChanDelay *d = &s->chandelay[i];
296 
297  if (all_delay < 0) {
298  ret = parse_delays(p, &saveptr, &delay, ctx, inlink->sample_rate);
299  if (ret != 0) {
300  ret = 0;
301  break;
302  }
303  p = NULL;
304  }
305 
306  ret = s->resize_channel_samples(d, delay);
307  if (ret)
308  break;
309  max_delay = FFMAX(max_delay, d->delay);
310  }
311  s->max_delay = FFMAX(s->max_delay, max_delay);
312  }
313  av_freep(&args_cpy);
314  }
315  return ret;
316 }
317 
319 {
320  AVFilterContext *ctx = inlink->dst;
321  AVFilterLink *outlink = ctx->outputs[0];
322  AudioDelayContext *s = ctx->priv;
323  AVFrame *out_frame;
324  int i;
325 
326  if (ctx->is_disabled || !s->delays)
327  return ff_filter_frame(outlink, frame);
328 
329  out_frame = ff_get_audio_buffer(outlink, frame->nb_samples);
330  if (!out_frame) {
332  return AVERROR(ENOMEM);
333  }
334  av_frame_copy_props(out_frame, frame);
335 
336  for (i = 0; i < s->nb_delays; i++) {
337  ChanDelay *d = &s->chandelay[i];
338  const uint8_t *src = frame->extended_data[i];
339  uint8_t *dst = out_frame->extended_data[i];
340 
341  if (!d->delay)
342  memcpy(dst, src, frame->nb_samples * s->block_align);
343  else
344  s->delay_channel(d, frame->nb_samples, src, dst);
345  }
346 
347  out_frame->pts = s->next_pts;
348  s->next_pts += av_rescale_q(frame->nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
350  return ff_filter_frame(outlink, out_frame);
351 }
352 
354 {
355  AVFilterLink *inlink = ctx->inputs[0];
356  AVFilterLink *outlink = ctx->outputs[0];
357  AudioDelayContext *s = ctx->priv;
358  AVFrame *frame = NULL;
359  int ret, status;
360  int64_t pts;
361 
363 
364  if (s->padding) {
365  int nb_samples = FFMIN(s->padding, 2048);
366 
367  frame = ff_get_audio_buffer(outlink, nb_samples);
368  if (!frame)
369  return AVERROR(ENOMEM);
370  s->padding -= nb_samples;
371 
372  av_samples_set_silence(frame->extended_data, 0,
373  frame->nb_samples,
374  outlink->ch_layout.nb_channels,
375  frame->format);
376 
377  frame->pts = s->next_pts;
378  if (s->next_pts != AV_NOPTS_VALUE)
379  s->next_pts += av_rescale_q(nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
380 
381  return ff_filter_frame(outlink, frame);
382  }
383 
385  if (ret < 0)
386  return ret;
387 
388  if (ret > 0)
389  return filter_frame(inlink, frame);
390 
392  if (status == AVERROR_EOF)
393  s->eof = 1;
394  }
395 
396  if (s->eof && s->max_delay) {
397  int nb_samples = FFMIN(s->max_delay, 2048);
398 
399  frame = ff_get_audio_buffer(outlink, nb_samples);
400  if (!frame)
401  return AVERROR(ENOMEM);
402  s->max_delay -= nb_samples;
403 
404  av_samples_set_silence(frame->extended_data, 0,
405  frame->nb_samples,
406  outlink->ch_layout.nb_channels,
407  frame->format);
408 
409  frame->pts = s->next_pts;
410  return filter_frame(inlink, frame);
411  }
412 
413  if (s->eof && s->max_delay == 0) {
414  ff_outlink_set_status(outlink, AVERROR_EOF, s->next_pts);
415  return 0;
416  }
417 
418  if (!s->eof)
420 
421  return FFERROR_NOT_READY;
422 }
423 
425 {
426  AudioDelayContext *s = ctx->priv;
427 
428  if (s->chandelay) {
429  for (int i = 0; i < s->nb_delays; i++)
430  av_freep(&s->chandelay[i].samples);
431  }
432  av_freep(&s->chandelay);
433 }
434 
435 static const AVFilterPad adelay_inputs[] = {
436  {
437  .name = "default",
438  .type = AVMEDIA_TYPE_AUDIO,
439  .config_props = config_input,
440  },
441 };
442 
443 static const AVFilterPad adelay_outputs[] = {
444  {
445  .name = "default",
446  .type = AVMEDIA_TYPE_AUDIO,
447  },
448 };
449 
451  .name = "adelay",
452  .description = NULL_IF_CONFIG_SMALL("Delay one or more audio channels."),
453  .priv_size = sizeof(AudioDelayContext),
454  .priv_class = &adelay_class,
455  .activate = activate,
456  .uninit = uninit,
462  .process_command = process_command,
463 };
AudioDelayContext::next_pts
int64_t next_pts
Definition: af_adelay.c:47
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:100
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
status
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
AudioDelayContext::resize_channel_samples
int(* resize_channel_samples)(ChanDelay *d, int64_t new_delay)
Definition: af_adelay.c:52
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_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1009
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
FFERROR_NOT_READY
return FFERROR_NOT_READY
Definition: filter_design.txt:204
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
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:432
AVOption
AVOption.
Definition: opt.h:251
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(adelay)
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:65
AV_OPT_FLAG_RUNTIME_PARAM
#define AV_OPT_FLAG_RUNTIME_PARAM
a generic parameter which can be set by the user at runtime
Definition: opt.h:296
ChanDelay
Definition: af_adelay.c:30
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:175
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:311
ChanDelay::delay
int64_t delay
Definition: af_adelay.c:31
FF_FILTER_FORWARD_STATUS_BACK
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
Definition: filters.h:199
ff_af_adelay
const AVFilter ff_af_adelay
Definition: af_adelay.c:450
sample_rate
sample_rate
Definition: ffmpeg_filter.c:156
OFFSET
#define OFFSET(x)
Definition: af_adelay.c:55
ff_inlink_consume_frame
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
Definition: avfilter.c:1404
AudioDelayContext
Definition: af_adelay.c:38
samplefmt.h
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
pts
static int64_t pts
Definition: transcode_aac.c:654
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:49
activate
static int activate(AVFilterContext *ctx)
Definition: af_adelay.c:353
config_input
static int config_input(AVFilterLink *inlink)
Definition: af_adelay.c:183
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AudioDelayContext::delay_channel
void(* delay_channel)(ChanDelay *d, int nb_samples, const uint8_t *src, uint8_t *dst)
Definition: af_adelay.c:50
av_cold
#define av_cold
Definition: attributes.h:90
ff_outlink_set_status
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: filters.h:189
s
#define s(width, name)
Definition: cbs_vp9.c:256
AudioDelayContext::delays
char * delays
Definition: af_adelay.c:41
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:189
filters.h
adelay_options
static const AVOption adelay_options[]
Definition: af_adelay.c:58
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AudioDelayContext::nb_delays
int nb_delays
Definition: af_adelay.c:43
AudioDelayContext::padding
int64_t padding
Definition: af_adelay.c:45
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
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:190
arg
const char * arg
Definition: jacosubdec.c:67
av_sscanf
int av_sscanf(const char *string, const char *format,...)
See libc sscanf manual for more information.
Definition: avsscanf.c:962
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:603
adelay_outputs
static const AVFilterPad adelay_outputs[]
Definition: af_adelay.c:443
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
parse_delays
static int parse_delays(char *p, char **saveptr, int64_t *result, AVFilterContext *ctx, int sample_rate)
Definition: af_adelay.c:157
A
#define A
Definition: af_adelay.c:56
ff_inlink_acknowledge_status
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
Definition: avfilter.c:1358
eval.h
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:115
AV_SAMPLE_FMT_U8P
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
Definition: samplefmt.h:63
DELAY
#define DELAY(name, type, fill)
Definition: af_adelay.c:66
AudioDelayContext::block_align
int block_align
Definition: af_adelay.c:44
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: af_adelay.c:318
FF_FILTER_FORWARD_WANTED
FF_FILTER_FORWARD_WANTED(outlink, inlink)
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
internal.h
ChanDelay::index
size_t index
Definition: af_adelay.c:33
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:108
AudioDelayContext::chandelay
ChanDelay * chandelay
Definition: af_adelay.c:42
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:386
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
ChanDelay::samples
uint8_t * samples
Definition: af_adelay.c:35
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:55
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
CHANGE_DELAY
#define CHANGE_DELAY(name, type, fill)
Definition: af_adelay.c:101
av_samples_set_silence
int av_samples_set_silence(uint8_t **audio_data, int offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Fill an audio buffer with silence.
Definition: samplefmt.c:246
AVFilter
Filter definition.
Definition: avfilter.h:171
ret
ret
Definition: filter_design.txt:187
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
adelay_inputs
static const AVFilterPad adelay_inputs[]
Definition: af_adelay.c:435
avfilter.h
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: af_adelay.c:264
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
AudioDelayContext::eof
int eof
Definition: af_adelay.c:48
AVFilterContext
An instance of a filter.
Definition: avfilter.h:415
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:280
audio.h
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:191
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AudioDelayContext::all
int all
Definition: af_adelay.c:40
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
d
d
Definition: ffmpeg_filter.c:156
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_adelay.c:424
int32_t
int32_t
Definition: audioconvert.c:56
AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
Definition: avfilter.h:160
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ChanDelay::delay_index
size_t delay_index
Definition: af_adelay.c:32
ChanDelay::samples_size
unsigned int samples_size
Definition: af_adelay.c:34
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
AudioDelayContext::max_delay
int64_t max_delay
Definition: af_adelay.c:46
int
int
Definition: ffmpeg_filter.c:156
FILTER_SAMPLEFMTS
#define FILTER_SAMPLEFMTS(...)
Definition: internal.h:178