FFmpeg
af_afade.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013-2015 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 /**
22  * @file
23  * fade audio filter
24  */
25 
26 #include "libavutil/opt.h"
27 #include "audio.h"
28 #include "avfilter.h"
29 #include "filters.h"
30 #include "internal.h"
31 
32 typedef struct AudioFadeContext {
33  const AVClass *class;
34  int type;
35  int curve, curve2;
36  int64_t nb_samples;
37  int64_t start_sample;
38  int64_t duration;
39  int64_t start_time;
40  int overlap;
41  int cf0_eof;
42  int crossfade_is_over;
43  int64_t pts;
44 
45  void (*fade_samples)(uint8_t **dst, uint8_t * const *src,
46  int nb_samples, int channels, int direction,
47  int64_t start, int64_t range, int curve);
48  void (*crossfade_samples)(uint8_t **dst, uint8_t * const *cf0,
49  uint8_t * const *cf1,
50  int nb_samples, int channels,
51  int curve0, int curve1);
52 } AudioFadeContext;
53 
54 enum CurveType { TRI, QSIN, ESIN, HSIN, LOG, IPAR, QUA, CUB, SQU, CBR, PAR, EXP, IQSIN, IHSIN, DESE, DESI, LOSI, NONE, NB_CURVES };
55 
56 #define OFFSET(x) offsetof(AudioFadeContext, x)
57 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
58 
59 static int query_formats(AVFilterContext *ctx)
60 {
61  AVFilterFormats *formats;
62  AVFilterChannelLayouts *layouts;
63  static const enum AVSampleFormat sample_fmts[] = {
64  AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P,
65  AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32P,
66  AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP,
67  AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBLP,
68  AV_SAMPLE_FMT_NONE
69  };
70  int ret;
71 
72  layouts = ff_all_channel_counts();
73  if (!layouts)
74  return AVERROR(ENOMEM);
75  ret = ff_set_common_channel_layouts(ctx, layouts);
76  if (ret < 0)
77  return ret;
78 
79  formats = ff_make_format_list(sample_fmts);
80  if (!formats)
81  return AVERROR(ENOMEM);
82  ret = ff_set_common_formats(ctx, formats);
83  if (ret < 0)
84  return ret;
85 
86  formats = ff_all_samplerates();
87  if (!formats)
88  return AVERROR(ENOMEM);
89  return ff_set_common_samplerates(ctx, formats);
90 }
91 
92 static double fade_gain(int curve, int64_t index, int64_t range)
93 {
94 #define CUBE(a) ((a)*(a)*(a))
95  double gain;
96 
97  gain = av_clipd(1.0 * index / range, 0, 1.0);
98 
99  switch (curve) {
100  case QSIN:
101  gain = sin(gain * M_PI / 2.0);
102  break;
103  case IQSIN:
104  /* 0.6... = 2 / M_PI */
105  gain = 0.6366197723675814 * asin(gain);
106  break;
107  case ESIN:
108  gain = 1.0 - cos(M_PI / 4.0 * (CUBE(2.0*gain - 1) + 1));
109  break;
110  case HSIN:
111  gain = (1.0 - cos(gain * M_PI)) / 2.0;
112  break;
113  case IHSIN:
114  /* 0.3... = 1 / M_PI */
115  gain = 0.3183098861837907 * acos(1 - 2 * gain);
116  break;
117  case EXP:
118  /* -11.5... = 5*ln(0.1) */
119  gain = exp(-11.512925464970227 * (1 - gain));
120  break;
121  case LOG:
122  gain = av_clipd(1 + 0.2 * log10(gain), 0, 1.0);
123  break;
124  case PAR:
125  gain = 1 - sqrt(1 - gain);
126  break;
127  case IPAR:
128  gain = (1 - (1 - gain) * (1 - gain));
129  break;
130  case QUA:
131  gain *= gain;
132  break;
133  case CUB:
134  gain = CUBE(gain);
135  break;
136  case SQU:
137  gain = sqrt(gain);
138  break;
139  case CBR:
140  gain = cbrt(gain);
141  break;
142  case DESE:
143  gain = gain <= 0.5 ? cbrt(2 * gain) / 2: 1 - cbrt(2 * (1 - gain)) / 2;
144  break;
145  case DESI:
146  gain = gain <= 0.5 ? CUBE(2 * gain) / 2: 1 - CUBE(2 * (1 - gain)) / 2;
147  break;
148  case LOSI: {
149  const double a = 1. / (1. - 0.787) - 1;
150  double A = 1. / (1.0 + exp(0 -((gain-0.5) * a * 2.0)));
151  double B = 1. / (1.0 + exp(a));
152  double C = 1. / (1.0 + exp(0-a));
153  gain = (A - B) / (C - B);
154  }
155  break;
156  case NONE:
157  gain = 1.0;
158  break;
159  }
160 
161  return gain;
162 }
163 
164 #define FADE_PLANAR(name, type) \
165 static void fade_samples_## name ##p(uint8_t **dst, uint8_t * const *src, \
166  int nb_samples, int channels, int dir, \
167  int64_t start, int64_t range, int curve) \
168 { \
169  int i, c; \
170  \
171  for (i = 0; i < nb_samples; i++) { \
172  double gain = fade_gain(curve, start + i * dir, range); \
173  for (c = 0; c < channels; c++) { \
174  type *d = (type *)dst[c]; \
175  const type *s = (type *)src[c]; \
176  \
177  d[i] = s[i] * gain; \
178  } \
179  } \
180 }
181 
182 #define FADE(name, type) \
183 static void fade_samples_## name (uint8_t **dst, uint8_t * const *src, \
184  int nb_samples, int channels, int dir, \
185  int64_t start, int64_t range, int curve) \
186 { \
187  type *d = (type *)dst[0]; \
188  const type *s = (type *)src[0]; \
189  int i, c, k = 0; \
190  \
191  for (i = 0; i < nb_samples; i++) { \
192  double gain = fade_gain(curve, start + i * dir, range); \
193  for (c = 0; c < channels; c++, k++) \
194  d[k] = s[k] * gain; \
195  } \
196 }
197 
198 FADE_PLANAR(dbl, double)
199 FADE_PLANAR(flt, float)
200 FADE_PLANAR(s16, int16_t)
201 FADE_PLANAR(s32, int32_t)
202 
203 FADE(dbl, double)
204 FADE(flt, float)
205 FADE(s16, int16_t)
206 FADE(s32, int32_t)
207 
208 static int config_output(AVFilterLink *outlink)
209 {
210  AVFilterContext *ctx = outlink->src;
211  AudioFadeContext *s = ctx->priv;
212 
213  switch (outlink->format) {
214  case AV_SAMPLE_FMT_DBL: s->fade_samples = fade_samples_dbl; break;
215  case AV_SAMPLE_FMT_DBLP: s->fade_samples = fade_samples_dblp; break;
216  case AV_SAMPLE_FMT_FLT: s->fade_samples = fade_samples_flt; break;
217  case AV_SAMPLE_FMT_FLTP: s->fade_samples = fade_samples_fltp; break;
218  case AV_SAMPLE_FMT_S16: s->fade_samples = fade_samples_s16; break;
219  case AV_SAMPLE_FMT_S16P: s->fade_samples = fade_samples_s16p; break;
220  case AV_SAMPLE_FMT_S32: s->fade_samples = fade_samples_s32; break;
221  case AV_SAMPLE_FMT_S32P: s->fade_samples = fade_samples_s32p; break;
222  }
223 
224  if (s->duration)
225  s->nb_samples = av_rescale(s->duration, outlink->sample_rate, AV_TIME_BASE);
226  if (s->start_time)
227  s->start_sample = av_rescale(s->start_time, outlink->sample_rate, AV_TIME_BASE);
228 
229  return 0;
230 }
231 
232 #if CONFIG_AFADE_FILTER
233 
234 static const AVOption afade_options[] = {
235  { "type", "set the fade direction", OFFSET(type), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, FLAGS, "type" },
236  { "t", "set the fade direction", OFFSET(type), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, FLAGS, "type" },
237  { "in", "fade-in", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, FLAGS, "type" },
238  { "out", "fade-out", 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, FLAGS, "type" },
239  { "start_sample", "set number of first sample to start fading", OFFSET(start_sample), AV_OPT_TYPE_INT64, {.i64 = 0 }, 0, INT64_MAX, FLAGS },
240  { "ss", "set number of first sample to start fading", OFFSET(start_sample), AV_OPT_TYPE_INT64, {.i64 = 0 }, 0, INT64_MAX, FLAGS },
241  { "nb_samples", "set number of samples for fade duration", OFFSET(nb_samples), AV_OPT_TYPE_INT64, {.i64 = 44100}, 1, INT64_MAX, FLAGS },
242  { "ns", "set number of samples for fade duration", OFFSET(nb_samples), AV_OPT_TYPE_INT64, {.i64 = 44100}, 1, INT64_MAX, FLAGS },
243  { "start_time", "set time to start fading", OFFSET(start_time), AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT64_MAX, FLAGS },
244  { "st", "set time to start fading", OFFSET(start_time), AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT64_MAX, FLAGS },
245  { "duration", "set fade duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT64_MAX, FLAGS },
246  { "d", "set fade duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, INT64_MAX, FLAGS },
247  { "curve", "set fade curve type", OFFSET(curve), AV_OPT_TYPE_INT, {.i64 = TRI }, 0, NB_CURVES - 1, FLAGS, "curve" },
248  { "c", "set fade curve type", OFFSET(curve), AV_OPT_TYPE_INT, {.i64 = TRI }, 0, NB_CURVES - 1, FLAGS, "curve" },
249  { "tri", "linear slope", 0, AV_OPT_TYPE_CONST, {.i64 = TRI }, 0, 0, FLAGS, "curve" },
250  { "qsin", "quarter of sine wave", 0, AV_OPT_TYPE_CONST, {.i64 = QSIN }, 0, 0, FLAGS, "curve" },
251  { "esin", "exponential sine wave", 0, AV_OPT_TYPE_CONST, {.i64 = ESIN }, 0, 0, FLAGS, "curve" },
252  { "hsin", "half of sine wave", 0, AV_OPT_TYPE_CONST, {.i64 = HSIN }, 0, 0, FLAGS, "curve" },
253  { "log", "logarithmic", 0, AV_OPT_TYPE_CONST, {.i64 = LOG }, 0, 0, FLAGS, "curve" },
254  { "ipar", "inverted parabola", 0, AV_OPT_TYPE_CONST, {.i64 = IPAR }, 0, 0, FLAGS, "curve" },
255  { "qua", "quadratic", 0, AV_OPT_TYPE_CONST, {.i64 = QUA }, 0, 0, FLAGS, "curve" },
256  { "cub", "cubic", 0, AV_OPT_TYPE_CONST, {.i64 = CUB }, 0, 0, FLAGS, "curve" },
257  { "squ", "square root", 0, AV_OPT_TYPE_CONST, {.i64 = SQU }, 0, 0, FLAGS, "curve" },
258  { "cbr", "cubic root", 0, AV_OPT_TYPE_CONST, {.i64 = CBR }, 0, 0, FLAGS, "curve" },
259  { "par", "parabola", 0, AV_OPT_TYPE_CONST, {.i64 = PAR }, 0, 0, FLAGS, "curve" },
260  { "exp", "exponential", 0, AV_OPT_TYPE_CONST, {.i64 = EXP }, 0, 0, FLAGS, "curve" },
261  { "iqsin", "inverted quarter of sine wave", 0, AV_OPT_TYPE_CONST, {.i64 = IQSIN}, 0, 0, FLAGS, "curve" },
262  { "ihsin", "inverted half of sine wave", 0, AV_OPT_TYPE_CONST, {.i64 = IHSIN}, 0, 0, FLAGS, "curve" },
263  { "dese", "double-exponential seat", 0, AV_OPT_TYPE_CONST, {.i64 = DESE }, 0, 0, FLAGS, "curve" },
264  { "desi", "double-exponential sigmoid", 0, AV_OPT_TYPE_CONST, {.i64 = DESI }, 0, 0, FLAGS, "curve" },
265  { "losi", "logistic sigmoid", 0, AV_OPT_TYPE_CONST, {.i64 = LOSI }, 0, 0, FLAGS, "curve" },
266  { "nofade", "no fade; keep audio as-is", 0, AV_OPT_TYPE_CONST, {.i64 = NONE }, 0, 0, FLAGS, "curve" },
267  { NULL }
268 };
269 
270 AVFILTER_DEFINE_CLASS(afade);
271 
272 static av_cold int init(AVFilterContext *ctx)
273 {
274  AudioFadeContext *s = ctx->priv;
275 
276  if (INT64_MAX - s->nb_samples < s->start_sample)
277  return AVERROR(EINVAL);
278 
279  return 0;
280 }
281 
282 static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
283 {
284  AudioFadeContext *s = inlink->dst->priv;
285  AVFilterLink *outlink = inlink->dst->outputs[0];
286  int nb_samples = buf->nb_samples;
287  AVFrame *out_buf;
288  int64_t cur_sample = av_rescale_q(buf->pts, inlink->time_base, (AVRational){1, inlink->sample_rate});
289 
290  if ((!s->type && (s->start_sample + s->nb_samples < cur_sample)) ||
291  ( s->type && (cur_sample + nb_samples < s->start_sample)))
292  return ff_filter_frame(outlink, buf);
293 
294  if (av_frame_is_writable(buf)) {
295  out_buf = buf;
296  } else {
297  out_buf = ff_get_audio_buffer(outlink, nb_samples);
298  if (!out_buf)
299  return AVERROR(ENOMEM);
300  av_frame_copy_props(out_buf, buf);
301  }
302 
303  if ((!s->type && (cur_sample + nb_samples < s->start_sample)) ||
304  ( s->type && (s->start_sample + s->nb_samples < cur_sample))) {
305  av_samples_set_silence(out_buf->extended_data, 0, nb_samples,
306  out_buf->channels, out_buf->format);
307  } else {
308  int64_t start;
309 
310  if (!s->type)
311  start = cur_sample - s->start_sample;
312  else
313  start = s->start_sample + s->nb_samples - cur_sample;
314 
315  s->fade_samples(out_buf->extended_data, buf->extended_data,
316  nb_samples, buf->channels,
317  s->type ? -1 : 1, start,
318  s->nb_samples, s->curve);
319  }
320 
321  if (buf != out_buf)
322  av_frame_free(&buf);
323 
324  return ff_filter_frame(outlink, out_buf);
325 }
326 
327 static const AVFilterPad avfilter_af_afade_inputs[] = {
328  {
329  .name = "default",
330  .type = AVMEDIA_TYPE_AUDIO,
331  .filter_frame = filter_frame,
332  },
333  { NULL }
334 };
335 
336 static const AVFilterPad avfilter_af_afade_outputs[] = {
337  {
338  .name = "default",
339  .type = AVMEDIA_TYPE_AUDIO,
340  .config_props = config_output,
341  },
342  { NULL }
343 };
344 
345 AVFilter ff_af_afade = {
346  .name = "afade",
347  .description = NULL_IF_CONFIG_SMALL("Fade in/out input audio."),
348  .query_formats = query_formats,
349  .priv_size = sizeof(AudioFadeContext),
350  .init = init,
351  .inputs = avfilter_af_afade_inputs,
352  .outputs = avfilter_af_afade_outputs,
353  .priv_class = &afade_class,
354  .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
355 };
356 
357 #endif /* CONFIG_AFADE_FILTER */
358 
359 #if CONFIG_ACROSSFADE_FILTER
360 
361 static const AVOption acrossfade_options[] = {
362  { "nb_samples", "set number of samples for cross fade duration", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 44100}, 1, INT32_MAX/10, FLAGS },
363  { "ns", "set number of samples for cross fade duration", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.i64 = 44100}, 1, INT32_MAX/10, FLAGS },
364  { "duration", "set cross fade duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, 60000000, FLAGS },
365  { "d", "set cross fade duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = 0. }, 0, 60000000, FLAGS },
366  { "overlap", "overlap 1st stream end with 2nd stream start", OFFSET(overlap), AV_OPT_TYPE_BOOL, {.i64 = 1 }, 0, 1, FLAGS },
367  { "o", "overlap 1st stream end with 2nd stream start", OFFSET(overlap), AV_OPT_TYPE_BOOL, {.i64 = 1 }, 0, 1, FLAGS },
368  { "curve1", "set fade curve type for 1st stream", OFFSET(curve), AV_OPT_TYPE_INT, {.i64 = TRI }, 0, NB_CURVES - 1, FLAGS, "curve" },
369  { "c1", "set fade curve type for 1st stream", OFFSET(curve), AV_OPT_TYPE_INT, {.i64 = TRI }, 0, NB_CURVES - 1, FLAGS, "curve" },
370  { "tri", "linear slope", 0, AV_OPT_TYPE_CONST, {.i64 = TRI }, 0, 0, FLAGS, "curve" },
371  { "qsin", "quarter of sine wave", 0, AV_OPT_TYPE_CONST, {.i64 = QSIN }, 0, 0, FLAGS, "curve" },
372  { "esin", "exponential sine wave", 0, AV_OPT_TYPE_CONST, {.i64 = ESIN }, 0, 0, FLAGS, "curve" },
373  { "hsin", "half of sine wave", 0, AV_OPT_TYPE_CONST, {.i64 = HSIN }, 0, 0, FLAGS, "curve" },
374  { "log", "logarithmic", 0, AV_OPT_TYPE_CONST, {.i64 = LOG }, 0, 0, FLAGS, "curve" },
375  { "ipar", "inverted parabola", 0, AV_OPT_TYPE_CONST, {.i64 = IPAR }, 0, 0, FLAGS, "curve" },
376  { "qua", "quadratic", 0, AV_OPT_TYPE_CONST, {.i64 = QUA }, 0, 0, FLAGS, "curve" },
377  { "cub", "cubic", 0, AV_OPT_TYPE_CONST, {.i64 = CUB }, 0, 0, FLAGS, "curve" },
378  { "squ", "square root", 0, AV_OPT_TYPE_CONST, {.i64 = SQU }, 0, 0, FLAGS, "curve" },
379  { "cbr", "cubic root", 0, AV_OPT_TYPE_CONST, {.i64 = CBR }, 0, 0, FLAGS, "curve" },
380  { "par", "parabola", 0, AV_OPT_TYPE_CONST, {.i64 = PAR }, 0, 0, FLAGS, "curve" },
381  { "exp", "exponential", 0, AV_OPT_TYPE_CONST, {.i64 = EXP }, 0, 0, FLAGS, "curve" },
382  { "iqsin", "inverted quarter of sine wave", 0, AV_OPT_TYPE_CONST, {.i64 = IQSIN}, 0, 0, FLAGS, "curve" },
383  { "ihsin", "inverted half of sine wave", 0, AV_OPT_TYPE_CONST, {.i64 = IHSIN}, 0, 0, FLAGS, "curve" },
384  { "dese", "double-exponential seat", 0, AV_OPT_TYPE_CONST, {.i64 = DESE }, 0, 0, FLAGS, "curve" },
385  { "desi", "double-exponential sigmoid", 0, AV_OPT_TYPE_CONST, {.i64 = DESI }, 0, 0, FLAGS, "curve" },
386  { "losi", "logistic sigmoid", 0, AV_OPT_TYPE_CONST, {.i64 = LOSI }, 0, 0, FLAGS, "curve" },
387  { "nofade", "no fade; keep audio as-is", 0, AV_OPT_TYPE_CONST, {.i64 = NONE }, 0, 0, FLAGS, "curve" },
388  { "curve2", "set fade curve type for 2nd stream", OFFSET(curve2), AV_OPT_TYPE_INT, {.i64 = TRI }, 0, NB_CURVES - 1, FLAGS, "curve" },
389  { "c2", "set fade curve type for 2nd stream", OFFSET(curve2), AV_OPT_TYPE_INT, {.i64 = TRI }, 0, NB_CURVES - 1, FLAGS, "curve" },
390  { NULL }
391 };
392 
393 AVFILTER_DEFINE_CLASS(acrossfade);
394 
395 #define CROSSFADE_PLANAR(name, type) \
396 static void crossfade_samples_## name ##p(uint8_t **dst, uint8_t * const *cf0, \
397  uint8_t * const *cf1, \
398  int nb_samples, int channels, \
399  int curve0, int curve1) \
400 { \
401  int i, c; \
402  \
403  for (i = 0; i < nb_samples; i++) { \
404  double gain0 = fade_gain(curve0, nb_samples - 1 - i, nb_samples); \
405  double gain1 = fade_gain(curve1, i, nb_samples); \
406  for (c = 0; c < channels; c++) { \
407  type *d = (type *)dst[c]; \
408  const type *s0 = (type *)cf0[c]; \
409  const type *s1 = (type *)cf1[c]; \
410  \
411  d[i] = s0[i] * gain0 + s1[i] * gain1; \
412  } \
413  } \
414 }
415 
416 #define CROSSFADE(name, type) \
417 static void crossfade_samples_## name (uint8_t **dst, uint8_t * const *cf0, \
418  uint8_t * const *cf1, \
419  int nb_samples, int channels, \
420  int curve0, int curve1) \
421 { \
422  type *d = (type *)dst[0]; \
423  const type *s0 = (type *)cf0[0]; \
424  const type *s1 = (type *)cf1[0]; \
425  int i, c, k = 0; \
426  \
427  for (i = 0; i < nb_samples; i++) { \
428  double gain0 = fade_gain(curve0, nb_samples - 1 - i, nb_samples); \
429  double gain1 = fade_gain(curve1, i, nb_samples); \
430  for (c = 0; c < channels; c++, k++) \
431  d[k] = s0[k] * gain0 + s1[k] * gain1; \
432  } \
433 }
434 
435 CROSSFADE_PLANAR(dbl, double)
436 CROSSFADE_PLANAR(flt, float)
437 CROSSFADE_PLANAR(s16, int16_t)
438 CROSSFADE_PLANAR(s32, int32_t)
439 
440 CROSSFADE(dbl, double)
441 CROSSFADE(flt, float)
442 CROSSFADE(s16, int16_t)
443 CROSSFADE(s32, int32_t)
444 
445 static int activate(AVFilterContext *ctx)
446 {
447  AudioFadeContext *s = ctx->priv;
448  AVFilterLink *outlink = ctx->outputs[0];
449  AVFrame *in = NULL, *out, *cf[2] = { NULL };
450  int ret = 0, nb_samples, status;
451  int64_t pts;
452 
453  FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, ctx);
454 
455  if (s->crossfade_is_over) {
456  ret = ff_inlink_consume_frame(ctx->inputs[1], &in);
457  if (ret < 0) {
458  return ret;
459  } else if (ff_inlink_acknowledge_status(ctx->inputs[1], &status, &pts)) {
460  ff_outlink_set_status(ctx->outputs[0], status, pts);
461  return 0;
462  } else {
463  if (ff_outlink_frame_wanted(ctx->outputs[0]) && !in) {
464  ff_inlink_request_frame(ctx->inputs[1]);
465  return 0;
466  }
467  }
468  in->pts = s->pts;
469  s->pts += av_rescale_q(in->nb_samples,
470  (AVRational){ 1, outlink->sample_rate }, outlink->time_base);
471  return ff_filter_frame(outlink, in);
472  }
473 
474  if (ff_inlink_queued_samples(ctx->inputs[0]) > s->nb_samples) {
475  nb_samples = ff_inlink_queued_samples(ctx->inputs[0]) - s->nb_samples;
476  if (nb_samples > 0) {
477  ret = ff_inlink_consume_samples(ctx->inputs[0], nb_samples, nb_samples, &in);
478  if (ret < 0) {
479  return ret;
480  }
481  }
482  in->pts = s->pts;
483  s->pts += av_rescale_q(in->nb_samples,
484  (AVRational){ 1, outlink->sample_rate }, outlink->time_base);
485  return ff_filter_frame(outlink, in);
486  } else if (ff_inlink_queued_samples(ctx->inputs[1]) >= s->nb_samples) {
487  if (s->overlap) {
488  out = ff_get_audio_buffer(outlink, s->nb_samples);
489  if (!out)
490  return AVERROR(ENOMEM);
491 
492  ret = ff_inlink_consume_samples(ctx->inputs[0], s->nb_samples, s->nb_samples, &cf[0]);
493  if (ret < 0) {
494  av_frame_free(&out);
495  return ret;
496  }
497 
498  ret = ff_inlink_consume_samples(ctx->inputs[1], s->nb_samples, s->nb_samples, &cf[1]);
499  if (ret < 0) {
500  av_frame_free(&out);
501  return ret;
502  }
503 
504  s->crossfade_samples(out->extended_data, cf[0]->extended_data,
505  cf[1]->extended_data,
506  s->nb_samples, out->channels,
507  s->curve, s->curve2);
508  out->pts = s->pts;
509  s->pts += av_rescale_q(s->nb_samples,
510  (AVRational){ 1, outlink->sample_rate }, outlink->time_base);
511  s->crossfade_is_over = 1;
512  av_frame_free(&cf[0]);
513  av_frame_free(&cf[1]);
514  return ff_filter_frame(outlink, out);
515  } else {
516  out = ff_get_audio_buffer(outlink, s->nb_samples);
517  if (!out)
518  return AVERROR(ENOMEM);
519 
520  ret = ff_inlink_consume_samples(ctx->inputs[0], s->nb_samples, s->nb_samples, &cf[0]);
521  if (ret < 0) {
522  av_frame_free(&out);
523  return ret;
524  }
525 
526  s->fade_samples(out->extended_data, cf[0]->extended_data, s->nb_samples,
527  outlink->channels, -1, s->nb_samples - 1, s->nb_samples, s->curve);
528  out->pts = s->pts;
529  s->pts += av_rescale_q(s->nb_samples,
530  (AVRational){ 1, outlink->sample_rate }, outlink->time_base);
531  av_frame_free(&cf[0]);
532  ret = ff_filter_frame(outlink, out);
533  if (ret < 0)
534  return ret;
535 
536  out = ff_get_audio_buffer(outlink, s->nb_samples);
537  if (!out)
538  return AVERROR(ENOMEM);
539 
540  ret = ff_inlink_consume_samples(ctx->inputs[1], s->nb_samples, s->nb_samples, &cf[1]);
541  if (ret < 0) {
542  av_frame_free(&out);
543  return ret;
544  }
545 
546  s->fade_samples(out->extended_data, cf[1]->extended_data, s->nb_samples,
547  outlink->channels, 1, 0, s->nb_samples, s->curve2);
548  out->pts = s->pts;
549  s->pts += av_rescale_q(s->nb_samples,
550  (AVRational){ 1, outlink->sample_rate }, outlink->time_base);
551  s->crossfade_is_over = 1;
552  av_frame_free(&cf[1]);
553  return ff_filter_frame(outlink, out);
554  }
555  } else if (ff_outlink_frame_wanted(ctx->outputs[0])) {
556  if (!s->cf0_eof && ff_outlink_get_status(ctx->inputs[0])) {
557  s->cf0_eof = 1;
558  }
559  if (ff_outlink_get_status(ctx->inputs[1])) {
560  ff_outlink_set_status(ctx->outputs[0], AVERROR_EOF, AV_NOPTS_VALUE);
561  return 0;
562  }
563  if (!s->cf0_eof)
564  ff_inlink_request_frame(ctx->inputs[0]);
565  else
566  ff_inlink_request_frame(ctx->inputs[1]);
567  return 0;
568  }
569 
570  return ret;
571 }
572 
573 static int acrossfade_config_output(AVFilterLink *outlink)
574 {
575  AVFilterContext *ctx = outlink->src;
576  AudioFadeContext *s = ctx->priv;
577 
578  if (ctx->inputs[0]->sample_rate != ctx->inputs[1]->sample_rate) {
579  av_log(ctx, AV_LOG_ERROR,
580  "Inputs must have the same sample rate "
581  "%d for in0 vs %d for in1\n",
582  ctx->inputs[0]->sample_rate, ctx->inputs[1]->sample_rate);
583  return AVERROR(EINVAL);
584  }
585 
586  outlink->sample_rate = ctx->inputs[0]->sample_rate;
587  outlink->time_base = ctx->inputs[0]->time_base;
588  outlink->channel_layout = ctx->inputs[0]->channel_layout;
589  outlink->channels = ctx->inputs[0]->channels;
590 
591  switch (outlink->format) {
592  case AV_SAMPLE_FMT_DBL: s->crossfade_samples = crossfade_samples_dbl; break;
593  case AV_SAMPLE_FMT_DBLP: s->crossfade_samples = crossfade_samples_dblp; break;
594  case AV_SAMPLE_FMT_FLT: s->crossfade_samples = crossfade_samples_flt; break;
595  case AV_SAMPLE_FMT_FLTP: s->crossfade_samples = crossfade_samples_fltp; break;
596  case AV_SAMPLE_FMT_S16: s->crossfade_samples = crossfade_samples_s16; break;
597  case AV_SAMPLE_FMT_S16P: s->crossfade_samples = crossfade_samples_s16p; break;
598  case AV_SAMPLE_FMT_S32: s->crossfade_samples = crossfade_samples_s32; break;
599  case AV_SAMPLE_FMT_S32P: s->crossfade_samples = crossfade_samples_s32p; break;
600  }
601 
602  config_output(outlink);
603 
604  return 0;
605 }
606 
607 static const AVFilterPad avfilter_af_acrossfade_inputs[] = {
608  {
609  .name = "crossfade0",
610  .type = AVMEDIA_TYPE_AUDIO,
611  },
612  {
613  .name = "crossfade1",
614  .type = AVMEDIA_TYPE_AUDIO,
615  },
616  { NULL }
617 };
618 
619 static const AVFilterPad avfilter_af_acrossfade_outputs[] = {
620  {
621  .name = "default",
622  .type = AVMEDIA_TYPE_AUDIO,
623  .config_props = acrossfade_config_output,
624  },
625  { NULL }
626 };
627 
628 AVFilter ff_af_acrossfade = {
629  .name = "acrossfade",
630  .description = NULL_IF_CONFIG_SMALL("Cross fade two input audio streams."),
631  .query_formats = query_formats,
632  .priv_size = sizeof(AudioFadeContext),
633  .activate = activate,
634  .priv_class = &acrossfade_class,
635  .inputs = avfilter_af_acrossfade_inputs,
636  .outputs = avfilter_af_acrossfade_outputs,
637 };
638 
639 #endif /* CONFIG_ACROSSFADE_FILTER */
formats
formats
Definition: signature.h:48
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:86
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
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
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
AudioFadeContext::type
int type
Definition: af_afade.c:34
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
AudioFadeContext::curve2
int curve2
Definition: af_afade.c:35
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
out
FILE * out
Definition: movenc.c:54
NONE
@ NONE
Definition: af_afade.c:54
ff_set_common_channel_layouts
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
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:686
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
ff_af_acrossfade
AVFilter ff_af_acrossfade
QUA
@ QUA
Definition: af_afade.c:54
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:202
ff_all_channel_counts
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition.
Definition: formats.c:410
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVOption
AVOption.
Definition: opt.h:246
IPAR
@ IPAR
Definition: af_afade.c:54
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:68
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Definition: opt.h:237
AudioFadeContext::fade_samples
void(* fade_samples)(uint8_t **dst, uint8_t *const *src, int nb_samples, int channels, int direction, int64_t start, int64_t range, int curve)
Definition: af_afade.c:45
config_output
static int config_output(AVFilterLink *outlink)
Definition: af_afade.c:208
channels
channels
Definition: aptx.c:30
NB_CURVES
@ NB_CURVES
Definition: af_afade.c:54
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:148
DESE
@ DESE
Definition: af_afade.c:54
DESI
@ DESI
Definition: af_afade.c:54
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
A
#define A(x)
Definition: vp56_arith.h:28
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:1481
FADE
#define FADE(name, type)
Definition: af_afade.c:182
FF_FILTER_FORWARD_STATUS_BACK_ALL
#define FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, filter)
Forward the status on an output link to all input links.
Definition: filters.h:212
start
void INT64 start
Definition: avisynth_c.h:767
CUBE
#define CUBE(a)
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:647
OFFSET
#define OFFSET(x)
Definition: af_afade.c:56
src
#define src
Definition: vp8dsp.c:254
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
cbrt
#define cbrt
Definition: tablegen.h:35
C
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
Definition: writing_filters.txt:58
AudioFadeContext::cf0_eof
int cf0_eof
Definition: af_afade.c:41
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
buf
void * buf
Definition: avisynth_c.h:766
av_cold
#define av_cold
Definition: attributes.h:84
CUB
@ CUB
Definition: af_afade.c:54
QSIN
@ QSIN
Definition: af_afade.c:54
ff_set_common_formats
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
duration
int64_t duration
Definition: movenc.c:63
IHSIN
@ IHSIN
Definition: af_afade.c:54
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
ff_inlink_request_frame
void ff_inlink_request_frame(AVFilterLink *link)
Mark that a frame is wanted on the link.
Definition: avfilter.c:1607
s
#define s(width, name)
Definition: cbs_vp9.c:257
TRI
@ TRI
Definition: af_afade.c:54
AVFrame::channels
int channels
number of audio channels, only used for audio.
Definition: frame.h:601
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
HSIN
@ HSIN
Definition: af_afade.c:54
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Definition: opt.h:224
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
filters.h
ctx
AVFormatContext * ctx
Definition: movenc.c:48
FLAGS
#define FLAGS
Definition: af_afade.c:57
IQSIN
@ IQSIN
Definition: af_afade.c:54
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
fade_gain
static double fade_gain(int curve, int64_t index, int64_t range)
Definition: af_afade.c:92
AudioFadeContext::crossfade_is_over
int crossfade_is_over
Definition: af_afade.c:42
int32_t
int32_t
Definition: audio_convert.c:194
AudioFadeContext::crossfade_samples
void(* crossfade_samples)(uint8_t **dst, uint8_t *const *cf0, uint8_t *const *cf1, int nb_samples, int channels, int curve0, int curve1)
Definition: af_afade.c:48
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
ff_inlink_consume_samples
int ff_inlink_consume_samples(AVFilterLink *link, unsigned min, unsigned max, AVFrame **rframe)
Take samples from the link's FIFO and update the link's stats.
Definition: avfilter.c:1500
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:654
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AudioFadeContext::start_sample
int64_t start_sample
Definition: af_afade.c:37
activate
filter_frame For filters that do not use the activate() callback
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: af_afade.c:59
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
exp
int8_t exp
Definition: eval.c:72
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:1436
index
int index
Definition: gxfenc.c:89
SQU
@ SQU
Definition: af_afade.c:54
CurveType
CurveType
Definition: af_afade.c:54
ff_af_afade
AVFilter ff_af_afade
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:188
start_time
static int64_t start_time
Definition: ffplay.c:331
AudioFadeContext::curve
int curve
Definition: af_afade.c:35
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:594
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:368
AudioFadeContext::duration
int64_t duration
Definition: af_afade.c:38
EXP
@ EXP
Definition: af_afade.c:54
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
M_PI
#define M_PI
Definition: mathematics.h:52
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:67
internal.h
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:125
AVFILTER_DEFINE_CLASS
#define AVFILTER_DEFINE_CLASS(fname)
Definition: internal.h:334
in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;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);return NULL;} return ac;} 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;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->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);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Definition: audio_convert.c:326
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:342
filter_frame
static int filter_frame(DBEContext *s, AVFrame *frame)
Definition: dolby_e.c:565
AudioFadeContext::pts
int64_t pts
Definition: af_afade.c:43
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
AudioFadeContext::overlap
int overlap
Definition: af_afade.c:40
uint8_t
uint8_t
Definition: audio_convert.c:194
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
CBR
@ CBR
Definition: af_afade.c:54
ff_inlink_queued_samples
int ff_inlink_queued_samples(AVFilterLink *link)
Definition: avfilter.c:1461
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
AudioFadeContext::start_time
int64_t start_time
Definition: af_afade.c:39
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:237
AVFilter
Filter definition.
Definition: avfilter.h:144
LOSI
@ LOSI
Definition: af_afade.c:54
ret
ret
Definition: filter_design.txt:187
B
#define B
Definition: huffyuvdsp.h:32
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:395
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
avfilter.h
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:70
FADE_PLANAR
#define FADE_PLANAR(name, type)
Definition: af_afade.c:164
ff_outlink_get_status
int ff_outlink_get_status(AVFilterLink *link)
Get the status on an output link.
Definition: avfilter.c:1630
AVFilterContext
An instance of a filter.
Definition: avfilter.h:338
audio.h
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:240
ESIN
@ ESIN
Definition: af_afade.c:54
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_set_common_samplerates
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:556
ff_outlink_frame_wanted
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the ff_outlink_frame_wanted() function. If this function returns true
AV_SAMPLE_FMT_DBL
@ AV_SAMPLE_FMT_DBL
double
Definition: samplefmt.h:64
PAR
@ PAR
Definition: af_afade.c:54
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:62
AudioFadeContext::nb_samples
int64_t nb_samples
Definition: af_afade.c:36
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:232
AudioFadeContext
Definition: af_afade.c:32
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
LOG
@ LOG
Definition: af_afade.c:54
Generated on Wed Aug 24 2022 21:27:07 for FFmpeg by   doxygen 1.8.17