FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
af_silenceremove.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2001 Heikki Leinonen
3  * Copyright (c) 2001 Chris Bagwell
4  * Copyright (c) 2003 Donnie Smith
5  * Copyright (c) 2014 Paul B Mahol
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 #include <float.h> /* DBL_MAX */
25 
26 #include "libavutil/opt.h"
27 #include "libavutil/timestamp.h"
28 #include "audio.h"
29 #include "formats.h"
30 #include "avfilter.h"
31 #include "internal.h"
32 
39 };
40 
41 typedef struct SilenceRemoveContext {
42  const AVClass *class;
43 
45 
47  int64_t start_duration;
49 
51  int64_t stop_duration;
53 
54  double *start_holdoff;
58 
59  double *stop_holdoff;
63 
64  double window_ratio;
65  double *window;
66  double *window_current;
67  double *window_end;
69  double sum;
70 
72  int restart;
73  int64_t next_pts;
74 
75  int detection;
76  void (*update)(struct SilenceRemoveContext *s, double sample);
77  double(*compute)(struct SilenceRemoveContext *s, double sample);
79 
80 #define OFFSET(x) offsetof(SilenceRemoveContext, x)
81 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_AUDIO_PARAM
82 static const AVOption silenceremove_options[] = {
83  { "start_periods", NULL, OFFSET(start_periods), AV_OPT_TYPE_INT, {.i64=0}, 0, 9000, FLAGS },
84  { "start_duration", NULL, OFFSET(start_duration), AV_OPT_TYPE_DURATION, {.i64=0}, 0, 9000, FLAGS },
85  { "start_threshold", NULL, OFFSET(start_threshold), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, DBL_MAX, FLAGS },
86  { "stop_periods", NULL, OFFSET(stop_periods), AV_OPT_TYPE_INT, {.i64=0}, -9000, 9000, FLAGS },
87  { "stop_duration", NULL, OFFSET(stop_duration), AV_OPT_TYPE_DURATION, {.i64=0}, 0, 9000, FLAGS },
88  { "stop_threshold", NULL, OFFSET(stop_threshold), AV_OPT_TYPE_DOUBLE, {.dbl=0}, 0, DBL_MAX, FLAGS },
89  { "leave_silence", NULL, OFFSET(leave_silence), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS },
90  { "detection", NULL, OFFSET(detection), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS, "detection" },
91  { "peak", 0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "detection" },
92  { "rms", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "detection" },
93  { "window", NULL, OFFSET(window_ratio), AV_OPT_TYPE_DOUBLE, {.dbl=0.02}, 0, 10, FLAGS },
94  { NULL }
95 };
96 
97 AVFILTER_DEFINE_CLASS(silenceremove);
98 
99 static double compute_peak(SilenceRemoveContext *s, double sample)
100 {
101  double new_sum;
102 
103  new_sum = s->sum;
104  new_sum -= *s->window_current;
105  new_sum += fabs(sample);
106 
107  return new_sum / s->window_size;
108 }
109 
111 {
112  s->sum -= *s->window_current;
113  *s->window_current = fabs(sample);
114  s->sum += *s->window_current;
115 
116  s->window_current++;
117  if (s->window_current >= s->window_end)
118  s->window_current = s->window;
119 }
120 
121 static double compute_rms(SilenceRemoveContext *s, double sample)
122 {
123  double new_sum;
124 
125  new_sum = s->sum;
126  new_sum -= *s->window_current;
127  new_sum += sample * sample;
128 
129  return sqrt(new_sum / s->window_size);
130 }
131 
133 {
134  s->sum -= *s->window_current;
135  *s->window_current = sample * sample;
136  s->sum += *s->window_current;
137 
138  s->window_current++;
139  if (s->window_current >= s->window_end)
140  s->window_current = s->window;
141 }
142 
144 {
145  SilenceRemoveContext *s = ctx->priv;
146 
147  if (s->stop_periods < 0) {
148  s->stop_periods = -s->stop_periods;
149  s->restart = 1;
150  }
151 
152  switch (s->detection) {
153  case 0:
154  s->update = update_peak;
155  s->compute = compute_peak;
156  break;
157  case 1:
158  s->update = update_rms;
159  s->compute = compute_rms;
160  break;
161  };
162 
163  return 0;
164 }
165 
167 {
168  memset(s->window, 0, s->window_size * sizeof(*s->window));
169 
170  s->window_current = s->window;
171  s->window_end = s->window + s->window_size;
172  s->sum = 0;
173 }
174 
175 static int config_input(AVFilterLink *inlink)
176 {
177  AVFilterContext *ctx = inlink->dst;
178  SilenceRemoveContext *s = ctx->priv;
179 
180  s->window_size = FFMAX((inlink->sample_rate * s->window_ratio), 1) * inlink->channels;
181  s->window = av_malloc_array(s->window_size, sizeof(*s->window));
182  if (!s->window)
183  return AVERROR(ENOMEM);
184 
185  clear_window(s);
186 
188  AV_TIME_BASE);
190  AV_TIME_BASE);
191 
193  sizeof(*s->start_holdoff) *
194  inlink->channels);
195  if (!s->start_holdoff)
196  return AVERROR(ENOMEM);
197 
198  s->start_holdoff_offset = 0;
199  s->start_holdoff_end = 0;
200  s->start_found_periods = 0;
201 
203  sizeof(*s->stop_holdoff) *
204  inlink->channels);
205  if (!s->stop_holdoff)
206  return AVERROR(ENOMEM);
207 
208  s->stop_holdoff_offset = 0;
209  s->stop_holdoff_end = 0;
210  s->stop_found_periods = 0;
211 
212  if (s->start_periods)
213  s->mode = SILENCE_TRIM;
214  else
215  s->mode = SILENCE_COPY;
216 
217  return 0;
218 }
219 
220 static void flush(AVFrame *out, AVFilterLink *outlink,
221  int *nb_samples_written, int *ret)
222 {
223  if (*nb_samples_written) {
224  out->nb_samples = *nb_samples_written / outlink->channels;
225  *ret = ff_filter_frame(outlink, out);
226  *nb_samples_written = 0;
227  } else {
228  av_frame_free(&out);
229  }
230 }
231 
232 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
233 {
234  AVFilterContext *ctx = inlink->dst;
235  AVFilterLink *outlink = ctx->outputs[0];
236  SilenceRemoveContext *s = ctx->priv;
237  int i, j, threshold, ret = 0;
238  int nbs, nb_samples_read, nb_samples_written;
239  double *obuf, *ibuf = (double *)in->data[0];
240  AVFrame *out;
241 
242  nb_samples_read = nb_samples_written = 0;
243 
244  switch (s->mode) {
245  case SILENCE_TRIM:
246 silence_trim:
247  nbs = in->nb_samples - nb_samples_read / inlink->channels;
248  if (!nbs)
249  break;
250 
251  for (i = 0; i < nbs; i++) {
252  threshold = 0;
253  for (j = 0; j < inlink->channels; j++) {
254  threshold |= s->compute(s, ibuf[j]) > s->start_threshold;
255  }
256 
257  if (threshold) {
258  for (j = 0; j < inlink->channels; j++) {
259  s->update(s, *ibuf);
260  s->start_holdoff[s->start_holdoff_end++] = *ibuf++;
261  }
262  nb_samples_read += inlink->channels;
263 
264  if (s->start_holdoff_end >= s->start_duration * inlink->channels) {
265  if (++s->start_found_periods >= s->start_periods) {
267  goto silence_trim_flush;
268  }
269 
270  s->start_holdoff_offset = 0;
271  s->start_holdoff_end = 0;
272  }
273  } else {
274  s->start_holdoff_end = 0;
275 
276  for (j = 0; j < inlink->channels; j++)
277  s->update(s, ibuf[j]);
278 
279  ibuf += inlink->channels;
280  nb_samples_read += inlink->channels;
281  }
282  }
283  break;
284 
285  case SILENCE_TRIM_FLUSH:
286 silence_trim_flush:
288  nbs -= nbs % inlink->channels;
289  if (!nbs)
290  break;
291 
292  out = ff_get_audio_buffer(inlink, nbs / inlink->channels);
293  if (!out) {
294  av_frame_free(&in);
295  return AVERROR(ENOMEM);
296  }
297 
298  memcpy(out->data[0], &s->start_holdoff[s->start_holdoff_offset],
299  nbs * sizeof(double));
300  s->start_holdoff_offset += nbs;
301 
302  ret = ff_filter_frame(outlink, out);
303 
305  s->start_holdoff_offset = 0;
306  s->start_holdoff_end = 0;
307  s->mode = SILENCE_COPY;
308  goto silence_copy;
309  }
310  break;
311 
312  case SILENCE_COPY:
313 silence_copy:
314  nbs = in->nb_samples - nb_samples_read / inlink->channels;
315  if (!nbs)
316  break;
317 
318  out = ff_get_audio_buffer(inlink, nbs);
319  if (!out) {
320  av_frame_free(&in);
321  return AVERROR(ENOMEM);
322  }
323  obuf = (double *)out->data[0];
324 
325  if (s->stop_periods) {
326  for (i = 0; i < nbs; i++) {
327  threshold = 1;
328  for (j = 0; j < inlink->channels; j++)
329  threshold &= s->compute(s, ibuf[j]) > s->stop_threshold;
330 
331  if (threshold && s->stop_holdoff_end && !s->leave_silence) {
333  flush(out, outlink, &nb_samples_written, &ret);
334  goto silence_copy_flush;
335  } else if (threshold) {
336  for (j = 0; j < inlink->channels; j++) {
337  s->update(s, *ibuf);
338  *obuf++ = *ibuf++;
339  }
340  nb_samples_read += inlink->channels;
341  nb_samples_written += inlink->channels;
342  } else if (!threshold) {
343  for (j = 0; j < inlink->channels; j++) {
344  s->update(s, *ibuf);
345  if (s->leave_silence) {
346  *obuf++ = *ibuf;
347  nb_samples_written++;
348  }
349 
350  s->stop_holdoff[s->stop_holdoff_end++] = *ibuf++;
351  }
352  nb_samples_read += inlink->channels;
353 
354  if (s->stop_holdoff_end >= s->stop_duration * inlink->channels) {
355  if (++s->stop_found_periods >= s->stop_periods) {
356  s->stop_holdoff_offset = 0;
357  s->stop_holdoff_end = 0;
358 
359  if (!s->restart) {
360  s->mode = SILENCE_STOP;
361  flush(out, outlink, &nb_samples_written, &ret);
362  goto silence_stop;
363  } else {
364  s->stop_found_periods = 0;
365  s->start_found_periods = 0;
366  s->start_holdoff_offset = 0;
367  s->start_holdoff_end = 0;
368  clear_window(s);
369  s->mode = SILENCE_TRIM;
370  flush(out, outlink, &nb_samples_written, &ret);
371  goto silence_trim;
372  }
373  }
375  flush(out, outlink, &nb_samples_written, &ret);
376  goto silence_copy_flush;
377  }
378  }
379  }
380  flush(out, outlink, &nb_samples_written, &ret);
381  } else {
382  memcpy(obuf, ibuf, sizeof(double) * nbs * inlink->channels);
383  ret = ff_filter_frame(outlink, out);
384  }
385  break;
386 
387  case SILENCE_COPY_FLUSH:
388 silence_copy_flush:
390  nbs -= nbs % inlink->channels;
391  if (!nbs)
392  break;
393 
394  out = ff_get_audio_buffer(inlink, nbs / inlink->channels);
395  if (!out) {
396  av_frame_free(&in);
397  return AVERROR(ENOMEM);
398  }
399 
400  memcpy(out->data[0], &s->stop_holdoff[s->stop_holdoff_offset],
401  nbs * sizeof(double));
402  s->stop_holdoff_offset += nbs;
403 
404  ret = ff_filter_frame(outlink, out);
405 
406  if (s->stop_holdoff_offset == s->stop_holdoff_end) {
407  s->stop_holdoff_offset = 0;
408  s->stop_holdoff_end = 0;
409  s->mode = SILENCE_COPY;
410  goto silence_copy;
411  }
412  break;
413  case SILENCE_STOP:
414 silence_stop:
415  break;
416  }
417 
418  av_frame_free(&in);
419 
420  return ret;
421 }
422 
423 static int request_frame(AVFilterLink *outlink)
424 {
425  AVFilterContext *ctx = outlink->src;
426  SilenceRemoveContext *s = ctx->priv;
427  int ret;
428 
429  ret = ff_request_frame(ctx->inputs[0]);
430  if (ret == AVERROR_EOF && (s->mode == SILENCE_COPY_FLUSH ||
431  s->mode == SILENCE_COPY)) {
432  int nbs = s->stop_holdoff_end - s->stop_holdoff_offset;
433  if (nbs) {
434  AVFrame *frame;
435 
436  frame = ff_get_audio_buffer(outlink, nbs / outlink->channels);
437  if (!frame)
438  return AVERROR(ENOMEM);
439 
440  memcpy(frame->data[0], &s->stop_holdoff[s->stop_holdoff_offset],
441  nbs * sizeof(double));
442  ret = ff_filter_frame(ctx->inputs[0], frame);
443  }
444  s->mode = SILENCE_STOP;
445  }
446  return ret;
447 }
448 
450 {
453  static const enum AVSampleFormat sample_fmts[] = {
455  };
456  int ret;
457 
458  layouts = ff_all_channel_counts();
459  if (!layouts)
460  return AVERROR(ENOMEM);
461  ret = ff_set_common_channel_layouts(ctx, layouts);
462  if (ret < 0)
463  return ret;
464 
465  formats = ff_make_format_list(sample_fmts);
466  if (!formats)
467  return AVERROR(ENOMEM);
468  ret = ff_set_common_formats(ctx, formats);
469  if (ret < 0)
470  return ret;
471 
472  formats = ff_all_samplerates();
473  if (!formats)
474  return AVERROR(ENOMEM);
475  return ff_set_common_samplerates(ctx, formats);
476 }
477 
479 {
480  SilenceRemoveContext *s = ctx->priv;
481 
482  av_freep(&s->start_holdoff);
483  av_freep(&s->stop_holdoff);
484  av_freep(&s->window);
485 }
486 
488  {
489  .name = "default",
490  .type = AVMEDIA_TYPE_AUDIO,
491  .config_props = config_input,
492  .filter_frame = filter_frame,
493  },
494  { NULL }
495 };
496 
498  {
499  .name = "default",
500  .type = AVMEDIA_TYPE_AUDIO,
501  .request_frame = request_frame,
502  },
503  { NULL }
504 };
505 
507  .name = "silenceremove",
508  .description = NULL_IF_CONFIG_SMALL("Remove silence."),
509  .priv_size = sizeof(SilenceRemoveContext),
510  .priv_class = &silenceremove_class,
511  .init = init,
512  .uninit = uninit,
514  .inputs = silenceremove_inputs,
515  .outputs = silenceremove_outputs,
516 };
static void flush(AVFrame *out, AVFilterLink *outlink, int *nb_samples_written, int *ret)
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
#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:631
This structure describes decoded (raw) audio or video data.
Definition: frame.h:181
AVOption.
Definition: opt.h:245
static const AVFilterPad silenceremove_outputs[]
AVFormatContext * ctx
Definition: movenc-test.c:48
Main libavfilter public API header.
void(* update)(struct SilenceRemoveContext *s, double sample)
AVFilter ff_af_silenceremove
static enum AVSampleFormat formats[]
#define sample
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
double(* compute)(struct SilenceRemoveContext *s, double sample)
#define FLAGS
const char * name
Pad name.
Definition: internal.h:59
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:312
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1163
#define av_cold
Definition: attributes.h:82
AVOptions.
timestamp utils, mostly useful for debugging/logging purposes
SilenceMode
static AVFrame * frame
static av_cold int init(AVFilterContext *ctx)
#define AVERROR_EOF
End of file.
Definition: error.h:55
A filter pad used for either input or output.
Definition: internal.h:53
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
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
Definition: audio.c:65
#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:154
#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:319
#define FFMAX(a, b)
Definition: common.h:94
static int query_formats(AVFilterContext *ctx)
static int config_input(AVFilterLink *inlink)
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
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:246
static const AVFilterPad silenceremove_inputs[]
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static int request_frame(AVFilterLink *outlink)
AVFILTER_DEFINE_CLASS(silenceremove)
enum SilenceMode mode
static const AVFilterPad outputs[]
Definition: af_afftfilt.c:385
A list of supported channel layouts.
Definition: formats.h:85
FILE * out
Definition: movenc-test.c:54
static double compute_peak(SilenceRemoveContext *s, double sample)
static const AVFilterPad inputs[]
Definition: af_afftfilt.c:375
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:59
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 av_cold void uninit(AVFilterContext *ctx)
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:141
static void update_rms(SilenceRemoveContext *s, double sample)
static double compute_rms(SilenceRemoveContext *s, double sample)
static void clear_window(SilenceRemoveContext *s)
const char * name
Filter name.
Definition: avfilter.h:145
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:316
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:395
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:192
static void update_peak(SilenceRemoveContext *s, double sample)
if(ret< 0)
Definition: vf_mcdeint.c:282
static const AVOption silenceremove_options[]
A list of supported formats for one end of a filter link.
Definition: formats.h:64
An instance of a filter.
Definition: avfilter.h:304
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
#define av_freep(p)
#define av_malloc_array(a, b)
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:356
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
#define OFFSET(x)
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:235
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:556