FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
af_silencedetect.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012 Clément Bœsch <u pkh me>
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  * Audio silence detector
24  */
25 
26 #include <float.h> /* DBL_MAX */
27 
28 #include "libavutil/opt.h"
29 #include "libavutil/timestamp.h"
30 #include "audio.h"
31 #include "formats.h"
32 #include "avfilter.h"
33 #include "internal.h"
34 
35 typedef struct SilenceDetectContext {
36  const AVClass *class;
37  double noise; ///< noise amplitude ratio
38  double duration; ///< minimum duration of silence until notification
39  int mono; ///< mono mode : check each channel separately (default = check when ALL channels are silent)
40  int channels; ///< number of channels
41  int independant_channels; ///< number of entries in following arrays (always 1 in mono mode)
42  int64_t *nb_null_samples; ///< (array) current number of continuous zero samples
43  int64_t *start; ///< (array) if silence is detected, this value contains the time of the first zero sample (default/unset = INT64_MIN)
44  int64_t frame_end; ///< pts of the end of the current frame (used to compute duration of silence at EOS)
45  int last_sample_rate; ///< last sample rate to check for sample rate changes
46  AVRational time_base; ///< time_base
47 
49  int nb_samples, int64_t nb_samples_notify,
52 
53 #define OFFSET(x) offsetof(SilenceDetectContext, x)
54 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_AUDIO_PARAM
55 static const AVOption silencedetect_options[] = {
56  { "n", "set noise tolerance", OFFSET(noise), AV_OPT_TYPE_DOUBLE, {.dbl=0.001}, 0, DBL_MAX, FLAGS },
57  { "noise", "set noise tolerance", OFFSET(noise), AV_OPT_TYPE_DOUBLE, {.dbl=0.001}, 0, DBL_MAX, FLAGS },
58  { "d", "set minimum duration in seconds", OFFSET(duration), AV_OPT_TYPE_DOUBLE, {.dbl=2.}, 0, 24*60*60, FLAGS },
59  { "duration", "set minimum duration in seconds", OFFSET(duration), AV_OPT_TYPE_DOUBLE, {.dbl=2.}, 0, 24*60*60, FLAGS },
60  { "mono", "check each channel separately", OFFSET(mono), AV_OPT_TYPE_BOOL, {.i64=0.}, 0, 1, FLAGS },
61  { NULL }
62 };
63 
65 
66 static void set_meta(AVFrame *insamples, int channel, const char *key, char *value)
67 {
68  char key2[128];
69 
70  if (channel)
71  snprintf(key2, sizeof(key2), "lavfi.%s.%d", key, channel);
72  else
73  snprintf(key2, sizeof(key2), "lavfi.%s", key);
74  av_dict_set(&insamples->metadata, key2, value, 0);
75 }
77  int is_silence, int current_sample, int64_t nb_samples_notify,
79 {
80  int channel = current_sample % s->independant_channels;
81  if (is_silence) {
82  if (s->start[channel] == INT64_MIN) {
84  if (s->nb_null_samples[channel] >= nb_samples_notify) {
85  s->start[channel] = insamples->pts + av_rescale_q(current_sample / s->channels + 1 - nb_samples_notify * s->independant_channels / s->channels,
87  set_meta(insamples, s->mono ? channel + 1 : 0, "silence_start",
88  av_ts2timestr(s->start[channel], &time_base));
89  if (s->mono)
90  av_log(s, AV_LOG_INFO, "channel: %d | ", channel);
91  av_log(s, AV_LOG_INFO, "silence_start: %s\n",
92  av_ts2timestr(s->start[channel], &time_base));
93  }
94  }
95  } else {
96  if (s->start[channel] > INT64_MIN) {
97  int64_t end_pts = insamples ? insamples->pts + av_rescale_q(current_sample / s->channels,
98  (AVRational){ 1, s->last_sample_rate }, time_base)
99  : s->frame_end;
100  int64_t duration_ts = end_pts - s->start[channel];
101  if (insamples) {
102  set_meta(insamples, s->mono ? channel + 1 : 0, "silence_end",
103  av_ts2timestr(end_pts, &time_base));
104  set_meta(insamples, s->mono ? channel + 1 : 0, "silence_duration",
105  av_ts2timestr(duration_ts, &time_base));
106  }
107  if (s->mono)
108  av_log(s, AV_LOG_INFO, "channel: %d | ", channel);
109  av_log(s, AV_LOG_INFO, "silence_end: %s | silence_duration: %s\n",
110  av_ts2timestr(end_pts, &time_base),
111  av_ts2timestr(duration_ts, &time_base));
112  }
113  s->nb_null_samples[channel] = 0;
114  s->start[channel] = INT64_MIN;
115  }
116 }
117 
118 #define SILENCE_DETECT(name, type) \
119 static void silencedetect_##name(SilenceDetectContext *s, AVFrame *insamples, \
120  int nb_samples, int64_t nb_samples_notify, \
121  AVRational time_base) \
122 { \
123  const type *p = (const type *)insamples->data[0]; \
124  const type noise = s->noise; \
125  int i; \
126  \
127  for (i = 0; i < nb_samples; i++, p++) \
128  update(s, insamples, *p < noise && *p > -noise, i, \
129  nb_samples_notify, time_base); \
130 }
131 
132 SILENCE_DETECT(dbl, double)
133 SILENCE_DETECT(flt, float)
135 SILENCE_DETECT(s16, int16_t)
136 
137 static int config_input(AVFilterLink *inlink)
138 {
139  AVFilterContext *ctx = inlink->dst;
140  SilenceDetectContext *s = ctx->priv;
141  int c;
142 
143  s->channels = inlink->channels;
144  s->independant_channels = s->mono ? s->channels : 1;
146  if (!s->nb_null_samples)
147  return AVERROR(ENOMEM);
148  s->start = av_malloc_array(sizeof(*s->start), s->independant_channels);
149  if (!s->start)
150  return AVERROR(ENOMEM);
151  for (c = 0; c < s->independant_channels; c++)
152  s->start[c] = INT64_MIN;
153 
154  switch (inlink->format) {
155  case AV_SAMPLE_FMT_DBL: s->silencedetect = silencedetect_dbl; break;
156  case AV_SAMPLE_FMT_FLT: s->silencedetect = silencedetect_flt; break;
157  case AV_SAMPLE_FMT_S32:
158  s->noise *= INT32_MAX;
159  s->silencedetect = silencedetect_s32;
160  break;
161  case AV_SAMPLE_FMT_S16:
162  s->noise *= INT16_MAX;
163  s->silencedetect = silencedetect_s16;
164  break;
165  }
166 
167  return 0;
168 }
169 
170 static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
171 {
172  SilenceDetectContext *s = inlink->dst->priv;
173  const int nb_channels = inlink->channels;
174  const int srate = inlink->sample_rate;
175  const int nb_samples = insamples->nb_samples * nb_channels;
176  const int64_t nb_samples_notify = srate * s->duration * (s->mono ? 1 : nb_channels);
177  int c;
178 
179  // scale number of null samples to the new sample rate
180  if (s->last_sample_rate && s->last_sample_rate != srate)
181  for (c = 0; c < s->independant_channels; c++) {
182  s->nb_null_samples[c] = srate * s->nb_null_samples[c] / s->last_sample_rate;
183  }
184  s->last_sample_rate = srate;
185  s->time_base = inlink->time_base;
186  s->frame_end = insamples->pts + av_rescale_q(insamples->nb_samples,
187  (AVRational){ 1, s->last_sample_rate }, inlink->time_base);
188 
189  // TODO: document metadata
190  s->silencedetect(s, insamples, nb_samples, nb_samples_notify,
191  inlink->time_base);
192 
193  return ff_filter_frame(inlink->dst->outputs[0], insamples);
194 }
195 
197 {
200  static const enum AVSampleFormat sample_fmts[] = {
206  };
207  int ret;
208 
209  layouts = ff_all_channel_layouts();
210  if (!layouts)
211  return AVERROR(ENOMEM);
212  ret = ff_set_common_channel_layouts(ctx, layouts);
213  if (ret < 0)
214  return ret;
215 
216  formats = ff_make_format_list(sample_fmts);
217  if (!formats)
218  return AVERROR(ENOMEM);
219  ret = ff_set_common_formats(ctx, formats);
220  if (ret < 0)
221  return ret;
222 
223  formats = ff_all_samplerates();
224  if (!formats)
225  return AVERROR(ENOMEM);
226  return ff_set_common_samplerates(ctx, formats);
227 }
228 
230 {
231  SilenceDetectContext *s = ctx->priv;
232  int c;
233 
234  for (c = 0; c < s->independant_channels; c++)
235  if (s->start[c] > INT64_MIN)
236  update(s, NULL, 0, c, 0, s->time_base);
238  av_freep(&s->start);
239 }
240 
242  {
243  .name = "default",
244  .type = AVMEDIA_TYPE_AUDIO,
245  .config_props = config_input,
246  .filter_frame = filter_frame,
247  },
248  { NULL }
249 };
250 
252  {
253  .name = "default",
254  .type = AVMEDIA_TYPE_AUDIO,
255  },
256  { NULL }
257 };
258 
260  .name = "silencedetect",
261  .description = NULL_IF_CONFIG_SMALL("Detect silence."),
262  .priv_size = sizeof(SilenceDetectContext),
264  .uninit = uninit,
265  .inputs = silencedetect_inputs,
266  .outputs = silencedetect_outputs,
267  .priv_class = &silencedetect_class,
268 };
#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
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
AVOption.
Definition: opt.h:246
Main libavfilter public API header.
int64_t frame_end
pts of the end of the current frame (used to compute duration of silence at EOS)
const char * key
#define SILENCE_DETECT(name, type)
AVFilter ff_af_silencedetect
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:60
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
#define av_cold
Definition: attributes.h:82
AVOptions.
timestamp utils, mostly useful for debugging/logging purposes
static const AVFilterPad silencedetect_inputs[]
double duration
minimum duration of silence until notification
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:311
#define OFFSET(x)
int64_t duration
Definition: movenc.c:63
AVDictionary * metadata
metadata.
Definition: frame.h:505
signed 32 bits
Definition: samplefmt.h:62
#define av_log(a,...)
A filter pad used for either input or output.
Definition: internal.h:54
AVRational time_base
time_base
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
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
static const AVFilterPad silencedetect_outputs[]
static av_always_inline void update(SilenceDetectContext *s, AVFrame *insamples, int is_silence, int current_sample, int64_t nb_samples_notify, AVRational time_base)
#define AVERROR(e)
Definition: error.h:43
#define FLAGS
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:76
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
int independant_channels
number of entries in following arrays (always 1 in mono mode)
double noise
noise amplitude ratio
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
static int config_input(AVFilterLink *inlink)
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (w...
Definition: formats.c:401
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
A list of supported channel layouts.
Definition: formats.h:85
int channels
number of channels
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
int64_t * nb_null_samples
(array) current number of continuous zero samples
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
AVFILTER_DEFINE_CLASS(silencedetect)
int mono
mono mode : check each channel separately (default = check when ALL channels are silent) ...
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
static int query_formats(AVFilterContext *ctx)
const char * name
Filter name.
Definition: avfilter.h:148
#define snprintf
Definition: snprintf.h:34
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:395
static int noise(AVBSFContext *ctx, AVPacket *pkt)
Definition: noise_bsf.c:38
void(* silencedetect)(struct SilenceDetectContext *s, AVFrame *insamples, int nb_samples, int64_t nb_samples_notify, AVRational time_base)
if(ret< 0)
Definition: vf_mcdeint.c:279
signed 16 bits
Definition: samplefmt.h:61
static double c[64]
channel
Use these values when setting the channel map with ebur128_set_channel().
Definition: ebur128.h:39
static const AVOption silencedetect_options[]
static av_cold void uninit(AVFilterContext *ctx)
A list of supported formats for one end of a filter link.
Definition: formats.h:64
An instance of a filter.
Definition: avfilter.h:338
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
#define av_freep(p)
#define av_always_inline
Definition: attributes.h:39
static void set_meta(AVFrame *insamples, int channel, const char *key, char *value)
#define av_malloc_array(a, b)
formats
Definition: signature.h:48
int nb_channels
int last_sample_rate
last sample rate to check for sample rate changes
internal API functions
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:284
int64_t * start
(array) if silence is detected, this value contains the time of the first zero sample (default/unset ...
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:556
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191