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 |
|
|
int64_t 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 independent_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 |
|
|
|
48 |
|
|
void (*silencedetect)(struct SilenceDetectContext *s, AVFrame *insamples, |
49 |
|
|
int nb_samples, int64_t nb_samples_notify, |
50 |
|
|
AVRational time_base); |
51 |
|
|
} SilenceDetectContext; |
52 |
|
|
|
53 |
|
|
#define MAX_DURATION (24*3600*1000000LL) |
54 |
|
|
#define OFFSET(x) offsetof(SilenceDetectContext, x) |
55 |
|
|
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_AUDIO_PARAM |
56 |
|
|
static const AVOption silencedetect_options[] = { |
57 |
|
|
{ "n", "set noise tolerance", OFFSET(noise), AV_OPT_TYPE_DOUBLE, {.dbl=0.001}, 0, DBL_MAX, FLAGS }, |
58 |
|
|
{ "noise", "set noise tolerance", OFFSET(noise), AV_OPT_TYPE_DOUBLE, {.dbl=0.001}, 0, DBL_MAX, FLAGS }, |
59 |
|
|
{ "d", "set minimum duration in seconds", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64=2000000}, 0, MAX_DURATION,FLAGS }, |
60 |
|
|
{ "duration", "set minimum duration in seconds", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64=2000000}, 0, MAX_DURATION,FLAGS }, |
61 |
|
|
{ "mono", "check each channel separately", OFFSET(mono), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS }, |
62 |
|
|
{ "m", "check each channel separately", OFFSET(mono), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS }, |
63 |
|
|
{ NULL } |
64 |
|
|
}; |
65 |
|
|
|
66 |
|
|
AVFILTER_DEFINE_CLASS(silencedetect); |
67 |
|
|
|
68 |
|
9 |
static void set_meta(AVFrame *insamples, int channel, const char *key, char *value) |
69 |
|
|
{ |
70 |
|
|
char key2[128]; |
71 |
|
|
|
72 |
✗✓ |
9 |
if (channel) |
73 |
|
|
snprintf(key2, sizeof(key2), "lavfi.%s.%d", key, channel); |
74 |
|
|
else |
75 |
|
9 |
snprintf(key2, sizeof(key2), "lavfi.%s", key); |
76 |
|
9 |
av_dict_set(&insamples->metadata, key2, value, 0); |
77 |
|
9 |
} |
78 |
|
1048554 |
static av_always_inline void update(SilenceDetectContext *s, AVFrame *insamples, |
79 |
|
|
int is_silence, int current_sample, int64_t nb_samples_notify, |
80 |
|
|
AVRational time_base) |
81 |
|
|
{ |
82 |
|
1048554 |
int channel = current_sample % s->independent_channels; |
83 |
✓✓ |
1048554 |
if (is_silence) { |
84 |
✓✓ |
304774 |
if (s->start[channel] == INT64_MIN) { |
85 |
|
221400 |
s->nb_null_samples[channel]++; |
86 |
✓✓ |
221400 |
if (s->nb_null_samples[channel] >= nb_samples_notify) { |
87 |
|
3 |
s->start[channel] = insamples->pts + av_rescale_q(current_sample / s->channels + 1 - nb_samples_notify * s->independent_channels / s->channels, |
88 |
|
3 |
(AVRational){ 1, s->last_sample_rate }, time_base); |
89 |
✗✓ |
3 |
set_meta(insamples, s->mono ? channel + 1 : 0, "silence_start", |
90 |
|
3 |
av_ts2timestr(s->start[channel], &time_base)); |
91 |
✗✓ |
3 |
if (s->mono) |
92 |
|
|
av_log(s, AV_LOG_INFO, "channel: %d | ", channel); |
93 |
|
3 |
av_log(s, AV_LOG_INFO, "silence_start: %s\n", |
94 |
|
3 |
av_ts2timestr(s->start[channel], &time_base)); |
95 |
|
|
} |
96 |
|
|
} |
97 |
|
|
} else { |
98 |
✓✓ |
743780 |
if (s->start[channel] > INT64_MIN) { |
99 |
|
6 |
int64_t end_pts = insamples ? insamples->pts + av_rescale_q(current_sample / s->channels, |
100 |
|
3 |
(AVRational){ 1, s->last_sample_rate }, time_base) |
101 |
✓✗ |
3 |
: s->frame_end; |
102 |
|
3 |
int64_t duration_ts = end_pts - s->start[channel]; |
103 |
✓✗ |
3 |
if (insamples) { |
104 |
✗✓ |
3 |
set_meta(insamples, s->mono ? channel + 1 : 0, "silence_end", |
105 |
|
3 |
av_ts2timestr(end_pts, &time_base)); |
106 |
✗✓ |
3 |
set_meta(insamples, s->mono ? channel + 1 : 0, "silence_duration", |
107 |
|
3 |
av_ts2timestr(duration_ts, &time_base)); |
108 |
|
|
} |
109 |
✗✓ |
3 |
if (s->mono) |
110 |
|
|
av_log(s, AV_LOG_INFO, "channel: %d | ", channel); |
111 |
|
3 |
av_log(s, AV_LOG_INFO, "silence_end: %s | silence_duration: %s\n", |
112 |
|
3 |
av_ts2timestr(end_pts, &time_base), |
113 |
|
3 |
av_ts2timestr(duration_ts, &time_base)); |
114 |
|
|
} |
115 |
|
743780 |
s->nb_null_samples[channel] = 0; |
116 |
|
743780 |
s->start[channel] = INT64_MIN; |
117 |
|
|
} |
118 |
|
1048554 |
} |
119 |
|
|
|
120 |
|
|
#define SILENCE_DETECT(name, type) \ |
121 |
|
|
static void silencedetect_##name(SilenceDetectContext *s, AVFrame *insamples, \ |
122 |
|
|
int nb_samples, int64_t nb_samples_notify, \ |
123 |
|
|
AVRational time_base) \ |
124 |
|
|
{ \ |
125 |
|
|
const type *p = (const type *)insamples->data[0]; \ |
126 |
|
|
const type noise = s->noise; \ |
127 |
|
|
int i; \ |
128 |
|
|
\ |
129 |
|
|
for (i = 0; i < nb_samples; i++, p++) \ |
130 |
|
|
update(s, insamples, *p < noise && *p > -noise, i, \ |
131 |
|
|
nb_samples_notify, time_base); \ |
132 |
|
|
} |
133 |
|
|
|
134 |
|
|
SILENCE_DETECT(dbl, double) |
135 |
|
|
SILENCE_DETECT(flt, float) |
136 |
|
|
SILENCE_DETECT(s32, int32_t) |
137 |
✓✓✓✓ ✓✓ |
1048566 |
SILENCE_DETECT(s16, int16_t) |
138 |
|
|
|
139 |
|
1 |
static int config_input(AVFilterLink *inlink) |
140 |
|
|
{ |
141 |
|
1 |
AVFilterContext *ctx = inlink->dst; |
142 |
|
1 |
SilenceDetectContext *s = ctx->priv; |
143 |
|
|
int c; |
144 |
|
|
|
145 |
|
1 |
s->channels = inlink->channels; |
146 |
|
1 |
s->duration = av_rescale(s->duration, inlink->sample_rate, AV_TIME_BASE); |
147 |
✗✓ |
1 |
s->independent_channels = s->mono ? s->channels : 1; |
148 |
|
1 |
s->nb_null_samples = av_mallocz_array(sizeof(*s->nb_null_samples), s->independent_channels); |
149 |
✗✓ |
1 |
if (!s->nb_null_samples) |
150 |
|
|
return AVERROR(ENOMEM); |
151 |
|
1 |
s->start = av_malloc_array(sizeof(*s->start), s->independent_channels); |
152 |
✗✓ |
1 |
if (!s->start) |
153 |
|
|
return AVERROR(ENOMEM); |
154 |
✓✓ |
2 |
for (c = 0; c < s->independent_channels; c++) |
155 |
|
1 |
s->start[c] = INT64_MIN; |
156 |
|
|
|
157 |
✗✗✗✓ ✗ |
1 |
switch (inlink->format) { |
158 |
|
|
case AV_SAMPLE_FMT_DBL: s->silencedetect = silencedetect_dbl; break; |
159 |
|
|
case AV_SAMPLE_FMT_FLT: s->silencedetect = silencedetect_flt; break; |
160 |
|
|
case AV_SAMPLE_FMT_S32: |
161 |
|
|
s->noise *= INT32_MAX; |
162 |
|
|
s->silencedetect = silencedetect_s32; |
163 |
|
|
break; |
164 |
|
1 |
case AV_SAMPLE_FMT_S16: |
165 |
|
1 |
s->noise *= INT16_MAX; |
166 |
|
1 |
s->silencedetect = silencedetect_s16; |
167 |
|
1 |
break; |
168 |
|
|
} |
169 |
|
|
|
170 |
|
1 |
return 0; |
171 |
|
|
} |
172 |
|
|
|
173 |
|
12 |
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples) |
174 |
|
|
{ |
175 |
|
12 |
SilenceDetectContext *s = inlink->dst->priv; |
176 |
|
12 |
const int nb_channels = inlink->channels; |
177 |
|
12 |
const int srate = inlink->sample_rate; |
178 |
|
12 |
const int nb_samples = insamples->nb_samples * nb_channels; |
179 |
✓✗ |
12 |
const int64_t nb_samples_notify = s->duration * (s->mono ? 1 : nb_channels); |
180 |
|
|
int c; |
181 |
|
|
|
182 |
|
|
// scale number of null samples to the new sample rate |
183 |
✓✓✗✓
|
12 |
if (s->last_sample_rate && s->last_sample_rate != srate) |
184 |
|
|
for (c = 0; c < s->independent_channels; c++) { |
185 |
|
|
s->nb_null_samples[c] = srate * s->nb_null_samples[c] / s->last_sample_rate; |
186 |
|
|
} |
187 |
|
12 |
s->last_sample_rate = srate; |
188 |
|
12 |
s->time_base = inlink->time_base; |
189 |
|
12 |
s->frame_end = insamples->pts + av_rescale_q(insamples->nb_samples, |
190 |
|
12 |
(AVRational){ 1, s->last_sample_rate }, inlink->time_base); |
191 |
|
|
|
192 |
|
12 |
s->silencedetect(s, insamples, nb_samples, nb_samples_notify, |
193 |
|
|
inlink->time_base); |
194 |
|
|
|
195 |
|
12 |
return ff_filter_frame(inlink->dst->outputs[0], insamples); |
196 |
|
|
} |
197 |
|
|
|
198 |
|
1 |
static int query_formats(AVFilterContext *ctx) |
199 |
|
|
{ |
200 |
|
1 |
AVFilterFormats *formats = NULL; |
201 |
|
1 |
AVFilterChannelLayouts *layouts = NULL; |
202 |
|
|
static const enum AVSampleFormat sample_fmts[] = { |
203 |
|
|
AV_SAMPLE_FMT_DBL, |
204 |
|
|
AV_SAMPLE_FMT_FLT, |
205 |
|
|
AV_SAMPLE_FMT_S32, |
206 |
|
|
AV_SAMPLE_FMT_S16, |
207 |
|
|
AV_SAMPLE_FMT_NONE |
208 |
|
|
}; |
209 |
|
|
int ret; |
210 |
|
|
|
211 |
|
1 |
layouts = ff_all_channel_layouts(); |
212 |
✗✓ |
1 |
if (!layouts) |
213 |
|
|
return AVERROR(ENOMEM); |
214 |
|
1 |
ret = ff_set_common_channel_layouts(ctx, layouts); |
215 |
✗✓ |
1 |
if (ret < 0) |
216 |
|
|
return ret; |
217 |
|
|
|
218 |
|
1 |
formats = ff_make_format_list(sample_fmts); |
219 |
✗✓ |
1 |
if (!formats) |
220 |
|
|
return AVERROR(ENOMEM); |
221 |
|
1 |
ret = ff_set_common_formats(ctx, formats); |
222 |
✗✓ |
1 |
if (ret < 0) |
223 |
|
|
return ret; |
224 |
|
|
|
225 |
|
1 |
formats = ff_all_samplerates(); |
226 |
✗✓ |
1 |
if (!formats) |
227 |
|
|
return AVERROR(ENOMEM); |
228 |
|
1 |
return ff_set_common_samplerates(ctx, formats); |
229 |
|
|
} |
230 |
|
|
|
231 |
|
1 |
static av_cold void uninit(AVFilterContext *ctx) |
232 |
|
|
{ |
233 |
|
1 |
SilenceDetectContext *s = ctx->priv; |
234 |
|
|
int c; |
235 |
|
|
|
236 |
✓✓ |
2 |
for (c = 0; c < s->independent_channels; c++) |
237 |
✗✓ |
1 |
if (s->start[c] > INT64_MIN) |
238 |
|
|
update(s, NULL, 0, c, 0, s->time_base); |
239 |
|
1 |
av_freep(&s->nb_null_samples); |
240 |
|
1 |
av_freep(&s->start); |
241 |
|
1 |
} |
242 |
|
|
|
243 |
|
|
static const AVFilterPad silencedetect_inputs[] = { |
244 |
|
|
{ |
245 |
|
|
.name = "default", |
246 |
|
|
.type = AVMEDIA_TYPE_AUDIO, |
247 |
|
|
.config_props = config_input, |
248 |
|
|
.filter_frame = filter_frame, |
249 |
|
|
}, |
250 |
|
|
{ NULL } |
251 |
|
|
}; |
252 |
|
|
|
253 |
|
|
static const AVFilterPad silencedetect_outputs[] = { |
254 |
|
|
{ |
255 |
|
|
.name = "default", |
256 |
|
|
.type = AVMEDIA_TYPE_AUDIO, |
257 |
|
|
}, |
258 |
|
|
{ NULL } |
259 |
|
|
}; |
260 |
|
|
|
261 |
|
|
AVFilter ff_af_silencedetect = { |
262 |
|
|
.name = "silencedetect", |
263 |
|
|
.description = NULL_IF_CONFIG_SMALL("Detect silence."), |
264 |
|
|
.priv_size = sizeof(SilenceDetectContext), |
265 |
|
|
.query_formats = query_formats, |
266 |
|
|
.uninit = uninit, |
267 |
|
|
.inputs = silencedetect_inputs, |
268 |
|
|
.outputs = silencedetect_outputs, |
269 |
|
|
.priv_class = &silencedetect_class, |
270 |
|
|
}; |