FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
af_chorus.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 1998 Juergen Mueller And Sundry Contributors
3  * This source code is freely redistributable and may be used for
4  * any purpose. This copyright notice must be maintained.
5  * Juergen Mueller And Sundry Contributors are not responsible for
6  * the consequences of using this software.
7  *
8  * Copyright (c) 2015 Paul B Mahol
9  *
10  * This file is part of FFmpeg.
11  *
12  * FFmpeg is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Lesser General Public
14  * License as published by the Free Software Foundation; either
15  * version 2.1 of the License, or (at your option) any later version.
16  *
17  * FFmpeg is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20  * Lesser General Public License for more details.
21  *
22  * You should have received a copy of the GNU Lesser General Public
23  * License along with FFmpeg; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25  */
26 
27 /**
28  * @file
29  * chorus audio filter
30  */
31 
32 #include "libavutil/avstring.h"
33 #include "libavutil/opt.h"
34 #include "audio.h"
35 #include "avfilter.h"
36 #include "internal.h"
37 #include "generate_wave_table.h"
38 
39 typedef struct ChorusContext {
40  const AVClass *class;
41  float in_gain, out_gain;
42  char *delays_str;
43  char *decays_str;
44  char *speeds_str;
45  char *depths_str;
46  float *delays;
47  float *decays;
48  float *speeds;
49  float *depths;
51  int **phase;
52  int *length;
54  int *counter;
57  int channels;
59  int fade_out;
60  int64_t next_pts;
62 
63 #define OFFSET(x) offsetof(ChorusContext, x)
64 #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
65 
66 static const AVOption chorus_options[] = {
67  { "in_gain", "set input gain", OFFSET(in_gain), AV_OPT_TYPE_FLOAT, {.dbl=.4}, 0, 1, A },
68  { "out_gain", "set output gain", OFFSET(out_gain), AV_OPT_TYPE_FLOAT, {.dbl=.4}, 0, 1, A },
69  { "delays", "set delays", OFFSET(delays_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, A },
70  { "decays", "set decays", OFFSET(decays_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, A },
71  { "speeds", "set speeds", OFFSET(speeds_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, A },
72  { "depths", "set depths", OFFSET(depths_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, A },
73  { NULL }
74 };
75 
76 AVFILTER_DEFINE_CLASS(chorus);
77 
78 static void count_items(char *item_str, int *nb_items)
79 {
80  char *p;
81 
82  *nb_items = 1;
83  for (p = item_str; *p; p++) {
84  if (*p == '|')
85  (*nb_items)++;
86  }
87 
88 }
89 
90 static void fill_items(char *item_str, int *nb_items, float *items)
91 {
92  char *p, *saveptr = NULL;
93  int i, new_nb_items = 0;
94 
95  p = item_str;
96  for (i = 0; i < *nb_items; i++) {
97  char *tstr = av_strtok(p, "|", &saveptr);
98  p = NULL;
99  new_nb_items += sscanf(tstr, "%f", &items[i]) == 1;
100  }
101 
102  *nb_items = new_nb_items;
103 }
104 
106 {
107  ChorusContext *s = ctx->priv;
108  int nb_delays, nb_decays, nb_speeds, nb_depths;
109 
110  if (!s->delays_str || !s->decays_str || !s->speeds_str || !s->depths_str) {
111  av_log(ctx, AV_LOG_ERROR, "Both delays & decays & speeds & depths must be set.\n");
112  return AVERROR(EINVAL);
113  }
114 
115  count_items(s->delays_str, &nb_delays);
116  count_items(s->decays_str, &nb_decays);
117  count_items(s->speeds_str, &nb_speeds);
118  count_items(s->depths_str, &nb_depths);
119 
120  s->delays = av_realloc_f(s->delays, nb_delays, sizeof(*s->delays));
121  s->decays = av_realloc_f(s->decays, nb_decays, sizeof(*s->decays));
122  s->speeds = av_realloc_f(s->speeds, nb_speeds, sizeof(*s->speeds));
123  s->depths = av_realloc_f(s->depths, nb_depths, sizeof(*s->depths));
124 
125  if (!s->delays || !s->decays || !s->speeds || !s->depths)
126  return AVERROR(ENOMEM);
127 
128  fill_items(s->delays_str, &nb_delays, s->delays);
129  fill_items(s->decays_str, &nb_decays, s->decays);
130  fill_items(s->speeds_str, &nb_speeds, s->speeds);
131  fill_items(s->depths_str, &nb_depths, s->depths);
132 
133  if (nb_delays != nb_decays && nb_delays != nb_speeds && nb_delays != nb_depths) {
134  av_log(ctx, AV_LOG_ERROR, "Number of delays & decays & speeds & depths given must be same.\n");
135  return AVERROR(EINVAL);
136  }
137 
138  s->num_chorus = nb_delays;
139 
140  if (s->num_chorus < 1) {
141  av_log(ctx, AV_LOG_ERROR, "At least one delay & decay & speed & depth must be set.\n");
142  return AVERROR(EINVAL);
143  }
144 
145  s->length = av_calloc(s->num_chorus, sizeof(*s->length));
146  s->lookup_table = av_calloc(s->num_chorus, sizeof(*s->lookup_table));
147 
148  if (!s->length || !s->lookup_table)
149  return AVERROR(ENOMEM);
150 
152 
153  return 0;
154 }
155 
157 {
160  static const enum AVSampleFormat sample_fmts[] = {
162  };
163  int ret;
164 
165  layouts = ff_all_channel_counts();
166  if (!layouts)
167  return AVERROR(ENOMEM);
168  ret = ff_set_common_channel_layouts(ctx, layouts);
169  if (ret < 0)
170  return ret;
171 
172  formats = ff_make_format_list(sample_fmts);
173  if (!formats)
174  return AVERROR(ENOMEM);
175  ret = ff_set_common_formats(ctx, formats);
176  if (ret < 0)
177  return ret;
178 
179  formats = ff_all_samplerates();
180  if (!formats)
181  return AVERROR(ENOMEM);
182  return ff_set_common_samplerates(ctx, formats);
183 }
184 
185 static int config_output(AVFilterLink *outlink)
186 {
187  AVFilterContext *ctx = outlink->src;
188  ChorusContext *s = ctx->priv;
189  float sum_in_volume = 1.0;
190  int n;
191 
192  s->channels = outlink->channels;
193 
194  for (n = 0; n < s->num_chorus; n++) {
195  int samples = (int) ((s->delays[n] + s->depths[n]) * outlink->sample_rate / 1000.0);
196  int depth_samples = (int) (s->depths[n] * outlink->sample_rate / 1000.0);
197 
198  s->length[n] = outlink->sample_rate / s->speeds[n];
199 
200  s->lookup_table[n] = av_malloc(sizeof(int32_t) * s->length[n]);
201  if (!s->lookup_table[n])
202  return AVERROR(ENOMEM);
203 
205  s->length[n], 0., depth_samples, 0);
206  s->max_samples = FFMAX(s->max_samples, samples);
207  }
208 
209  for (n = 0; n < s->num_chorus; n++)
210  sum_in_volume += s->decays[n];
211 
212  if (s->in_gain * (sum_in_volume) > 1.0 / s->out_gain)
213  av_log(ctx, AV_LOG_WARNING, "output gain can cause saturation or clipping of output\n");
214 
215  s->counter = av_calloc(outlink->channels, sizeof(*s->counter));
216  if (!s->counter)
217  return AVERROR(ENOMEM);
218 
219  s->phase = av_calloc(outlink->channels, sizeof(*s->phase));
220  if (!s->phase)
221  return AVERROR(ENOMEM);
222 
223  for (n = 0; n < outlink->channels; n++) {
224  s->phase[n] = av_calloc(s->num_chorus, sizeof(int));
225  if (!s->phase[n])
226  return AVERROR(ENOMEM);
227  }
228 
229  s->fade_out = s->max_samples;
230 
232  outlink->channels,
233  s->max_samples,
234  outlink->format, 0);
235 }
236 
237 #define MOD(a, b) (((a) >= (b)) ? (a) - (b) : (a))
238 
239 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
240 {
241  AVFilterContext *ctx = inlink->dst;
242  ChorusContext *s = ctx->priv;
243  AVFrame *out_frame;
244  int c, i, n;
245 
246  if (av_frame_is_writable(frame)) {
247  out_frame = frame;
248  } else {
249  out_frame = ff_get_audio_buffer(inlink, frame->nb_samples);
250  if (!out_frame) {
251  av_frame_free(&frame);
252  return AVERROR(ENOMEM);
253  }
254  av_frame_copy_props(out_frame, frame);
255  }
256 
257  for (c = 0; c < inlink->channels; c++) {
258  const float *src = (const float *)frame->extended_data[c];
259  float *dst = (float *)out_frame->extended_data[c];
260  float *chorusbuf = (float *)s->chorusbuf[c];
261  int *phase = s->phase[c];
262 
263  for (i = 0; i < frame->nb_samples; i++) {
264  float out, in = src[i];
265 
266  out = in * s->in_gain;
267 
268  for (n = 0; n < s->num_chorus; n++) {
269  out += chorusbuf[MOD(s->max_samples + s->counter[c] -
270  s->lookup_table[n][phase[n]],
271  s->max_samples)] * s->decays[n];
272  phase[n] = MOD(phase[n] + 1, s->length[n]);
273  }
274 
275  out *= s->out_gain;
276 
277  dst[i] = out;
278 
279  chorusbuf[s->counter[c]] = in;
280  s->counter[c] = MOD(s->counter[c] + 1, s->max_samples);
281  }
282  }
283 
284  s->next_pts = frame->pts + av_rescale_q(frame->nb_samples, (AVRational){1, inlink->sample_rate}, inlink->time_base);
285 
286  if (frame != out_frame)
288 
289  return ff_filter_frame(ctx->outputs[0], out_frame);
290 }
291 
292 static int request_frame(AVFilterLink *outlink)
293 {
294  AVFilterContext *ctx = outlink->src;
295  ChorusContext *s = ctx->priv;
296  int ret;
297 
298  ret = ff_request_frame(ctx->inputs[0]);
299 
300  if (ret == AVERROR_EOF && !ctx->is_disabled && s->fade_out) {
301  int nb_samples = FFMIN(s->fade_out, 2048);
302  AVFrame *frame;
303 
304  frame = ff_get_audio_buffer(outlink, nb_samples);
305  if (!frame)
306  return AVERROR(ENOMEM);
307  s->fade_out -= nb_samples;
308 
310  frame->nb_samples,
311  outlink->channels,
312  frame->format);
313 
314  frame->pts = s->next_pts;
315  if (s->next_pts != AV_NOPTS_VALUE)
316  s->next_pts += av_rescale_q(nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
317 
318  ret = filter_frame(ctx->inputs[0], frame);
319  }
320 
321  return ret;
322 }
323 
325 {
326  ChorusContext *s = ctx->priv;
327  int n;
328 
329  av_freep(&s->delays);
330  av_freep(&s->decays);
331  av_freep(&s->speeds);
332  av_freep(&s->depths);
333 
334  if (s->chorusbuf)
335  av_freep(&s->chorusbuf[0]);
336  av_freep(&s->chorusbuf);
337 
338  if (s->phase)
339  for (n = 0; n < s->channels; n++)
340  av_freep(&s->phase[n]);
341  av_freep(&s->phase);
342 
343  av_freep(&s->counter);
344  av_freep(&s->length);
345 
346  if (s->lookup_table)
347  for (n = 0; n < s->num_chorus; n++)
348  av_freep(&s->lookup_table[n]);
349  av_freep(&s->lookup_table);
350 }
351 
352 static const AVFilterPad chorus_inputs[] = {
353  {
354  .name = "default",
355  .type = AVMEDIA_TYPE_AUDIO,
356  .filter_frame = filter_frame,
357  },
358  { NULL }
359 };
360 
361 static const AVFilterPad chorus_outputs[] = {
362  {
363  .name = "default",
364  .type = AVMEDIA_TYPE_AUDIO,
365  .request_frame = request_frame,
366  .config_props = config_output,
367  },
368  { NULL }
369 };
370 
372  .name = "chorus",
373  .description = NULL_IF_CONFIG_SMALL("Add a chorus effect to the audio."),
374  .query_formats = query_formats,
375  .priv_size = sizeof(ChorusContext),
376  .priv_class = &chorus_class,
377  .init = init,
378  .uninit = uninit,
379  .inputs = chorus_inputs,
380  .outputs = chorus_outputs,
381 };
float, planar
Definition: samplefmt.h:69
char * speeds_str
Definition: af_chorus.c:44
#define NULL
Definition: coverity.c:32
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates...
Definition: formats.c:549
const char * s
Definition: avisynth_c.h:768
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
#define av_realloc_f(p, o, n)
AVOption.
Definition: opt.h:245
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
Main libavfilter public API header.
static enum AVSampleFormat formats[]
Definition: avresample.c:163
static void count_items(char *item_str, int *nb_items)
Definition: af_chorus.c:78
int * length
Definition: af_chorus.c:52
int is_disabled
the enabled state from the last expression evaluation
Definition: avfilter.h:354
AVFilter ff_af_chorus
Definition: af_chorus.c:371
int av_samples_alloc_array_and_samples(uint8_t ***audio_data, int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Allocate a data pointers array, samples buffer for nb_samples samples, and fill data pointers and lin...
Definition: samplefmt.c:198
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:260
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
const char * name
Pad name.
Definition: internal.h:59
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:315
char * depths_str
Definition: af_chorus.c:45
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1189
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVOptions.
static int query_formats(AVFilterContext *ctx)
Definition: af_chorus.c:156
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:268
static AVFrame * frame
#define AVERROR_EOF
End of file.
Definition: error.h:55
float * delays
Definition: af_chorus.c:46
signed 32 bits
Definition: samplefmt.h:62
#define av_log(a,...)
uint8_t ** chorusbuf
Definition: af_chorus.c:50
A filter pad used for either input or output.
Definition: internal.h:53
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
AVFILTER_DEFINE_CLASS(chorus)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int 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:568
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:237
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:64
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:158
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
void * priv
private data for use by the filter
Definition: avfilter.h:322
static av_cold void uninit(AVFilterContext *ctx)
Definition: af_chorus.c:324
int64_t next_pts
Definition: af_chorus.c:60
static const AVFilterPad chorus_inputs[]
Definition: af_chorus.c:352
#define MOD(a, b)
Definition: af_chorus.c:237
#define FFMAX(a, b)
Definition: common.h:94
float * decays
Definition: af_chorus.c:47
int num_chorus
Definition: af_chorus.c:55
char * decays_str
Definition: af_chorus.c:43
float * depths
Definition: af_chorus.c:49
#define FFMIN(a, b)
Definition: common.h:96
int32_t ** lookup_table
Definition: af_chorus.c:53
static int request_frame(AVFilterLink *outlink)
Definition: af_chorus.c:292
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
int n
Definition: avisynth_c.h:684
char * delays_str
Definition: af_chorus.c:42
static const AVFilterPad outputs[]
Definition: af_afftfilt.c:386
#define src
Definition: vp9dsp.c:530
#define A
Definition: af_chorus.c:64
int ** phase
Definition: af_chorus.c:51
static int config_output(AVFilterLink *outlink)
Definition: af_chorus.c:185
void ff_generate_wave_table(enum WaveType wave_type, enum AVSampleFormat sample_fmt, void *table, int table_size, double min, double max, double phase)
A list of supported channel layouts.
Definition: formats.h:85
int modulation
Definition: af_chorus.c:58
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:248
float * speeds
Definition: af_chorus.c:48
static const AVFilterPad inputs[]
Definition: af_afftfilt.c:376
static av_cold int init(AVFilterContext *ctx)
Definition: af_chorus.c:105
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:529
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
static const AVOption chorus_options[]
Definition: af_chorus.c:66
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
Rational number (pair of numerator and denominator).
Definition: rational.h:58
const char * name
Filter name.
Definition: avfilter.h:148
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:395
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:184
int * counter
Definition: af_chorus.c:54
if(ret< 0)
Definition: vf_mcdeint.c:282
static double c[64]
A list of supported formats for one end of a filter link.
Definition: formats.h:64
#define OFFSET(x)
Definition: af_chorus.c:63
An instance of a filter.
Definition: avfilter.h:307
float in_gain
Definition: af_chorus.c:41
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
FILE * out
Definition: movenc.c:54
#define av_freep(p)
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:369
static const AVFilterPad chorus_outputs[]
Definition: af_chorus.c:361
internal API functions
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition...
Definition: formats.c:410
int max_samples
Definition: af_chorus.c:56
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:231
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: af_chorus.c:239
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:241
for(j=16;j >0;--j)
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:556
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:589
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:242
static void fill_items(char *item_str, int *nb_items, float *items)
Definition: af_chorus.c:90
float out_gain
Definition: af_chorus.c:41