Go to the documentation of this file.
87 double sigmae,
double *detection,
88 double *acoefficients, uint8_t *click,
int *
index,
89 const double *
src,
double *dst);
92 #define OFFSET(x) offsetof(AudioDeclickContext, x)
93 #define AF AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
124 s->window_size =
FFMAX(100,
inlink->sample_rate *
s->w / 1000.);
125 s->ar_order =
FFMAX(
s->window_size *
s->ar / 100., 1);
126 s->nb_burst_samples =
s->window_size *
s->burst / 1000.;
127 s->hop_size =
FFMAX(1,
s->window_size * (1. - (
s->overlap / 100.)));
129 s->window_func_lut =
av_calloc(
s->window_size,
sizeof(*
s->window_func_lut));
130 if (!
s->window_func_lut)
134 double *tx_in[2], *tx_out[2];
140 tx_size = 1 << (32 -
ff_clz(
s->window_size));
147 scale = 1.0 / tx_size;
152 tx_in[0] =
av_calloc(tx_size + 2,
sizeof(*tx_in[0]));
153 tx_in[1] =
av_calloc(tx_size + 2,
sizeof(*tx_in[1]));
154 tx_out[0] =
av_calloc(tx_size + 2,
sizeof(*tx_out[0]));
155 tx_out[1] =
av_calloc(tx_size + 2,
sizeof(*tx_out[1]));
156 if (!tx_in[0] || !tx_in[1] || !tx_out[0] || !tx_out[1])
159 for (
int n = 0; n <
s->window_size -
s->hop_size; n++)
162 for (
int n = 0; n <
s->hop_size; n++)
165 tx_fn(tx, tx_out[0], tx_in[0],
sizeof(
double));
166 tx_fn(tx, tx_out[1], tx_in[1],
sizeof(
double));
168 for (
int n = 0; n <= tx_size/2; n++) {
169 double re0 = tx_out[0][2*n];
170 double im0 = tx_out[0][2*n+1];
171 double re1 = tx_out[1][2*n];
172 double im1 = tx_out[1][2*n+1];
174 tx_in[0][2*n] = re0 * re1 - im0 * im1;
175 tx_in[0][2*n+1] = re0 * im1 + re1 * im0;
180 scale = 1.0 / (
s->window_size -
s->hop_size);
181 for (
int n = 0; n <
s->window_size; n++)
182 s->window_func_lut[n] = tx_out[0][n] *
scale;
202 if (!
s->in || !
s->out || !
s->buffer || !
s->is || !
s->enabled)
211 s->overlap_skip =
s->method ? (
s->window_size -
s->hop_size) / 2 : 0;
212 if (
s->overlap_skip > 0) {
217 s->nb_channels =
inlink->ch_layout.nb_channels;
222 for (
i = 0;
i <
inlink->ch_layout.nb_channels;
i++) {
225 c->detection =
av_calloc(
s->window_size,
sizeof(*
c->detection));
226 c->auxiliary =
av_calloc(
s->ar_order + 1,
sizeof(*
c->auxiliary));
227 c->acoefficients =
av_calloc(
s->ar_order + 1,
sizeof(*
c->acoefficients));
228 c->acorrelation =
av_calloc(
s->ar_order + 1,
sizeof(*
c->acorrelation));
230 c->click =
av_calloc(
s->window_size,
sizeof(*
c->click));
231 c->index =
av_calloc(
s->window_size,
sizeof(*
c->index));
232 c->interpolated =
av_calloc(
s->window_size,
sizeof(*
c->interpolated));
233 if (!
c->auxiliary || !
c->acoefficients || !
c->detection || !
c->click ||
234 !
c->index || !
c->interpolated || !
c->acorrelation || !
c->tmp)
246 for (
i = 0;
i <= order;
i++) {
249 for (j =
i; j <
size; j++)
267 k[0] =
a[0] = -
r[1] /
r[0];
268 alpha =
r[0] * (1. - k[0] * k[0]);
272 for (j = 0; j <
i; j++)
273 epsilon +=
a[j] *
r[
i - j];
278 for (j =
i - 1; j >= 0; j--)
279 k[j] =
a[j] + k[
i] *
a[
i - j - 1];
280 for (j = 0; j <=
i; j++)
312 while (start <= end) {
313 i = (end + start) / 2;
329 for (
i = 0;
i < n;
i++) {
330 const int in =
i * n;
334 for (j = 0; j <
i; j++)
342 for (j =
i + 1; j < n; j++) {
343 const int jn = j * n;
347 for (k = 0; k <
i; k++)
357 double *vector,
int n,
double *
out)
371 for (
i = 0;
i < n;
i++) {
372 const int in =
i * n;
376 for (j = 0; j <
i; j++)
381 for (
i = n - 1;
i >= 0;
i--) {
383 for (j =
i + 1; j < n; j++)
391 double *acoefficients,
int *
index,
int nb_errors,
392 double *auxiliary,
double *interpolated)
397 av_fast_malloc(&
c->matrix, &
c->matrix_size, nb_errors * nb_errors *
sizeof(*
c->matrix));
409 for (
i = 0;
i < nb_errors;
i++) {
410 const int im =
i * nb_errors;
412 for (j =
i; j < nb_errors; j++) {
421 for (
i = 0;
i < nb_errors;
i++) {
436 double *unused1,
double *unused2,
438 const double *
src,
double *dst)
441 double max_amplitude = 0;
445 av_fast_malloc(&
c->histogram, &
c->histogram_size,
s->nb_hbins *
sizeof(*
c->histogram));
448 histogram =
c->histogram;
449 memset(histogram, 0,
sizeof(*histogram) *
s->nb_hbins);
451 for (
i = 0;
i <
s->window_size;
i++) {
459 for (
i =
s->nb_hbins - 1;
i > 1;
i--) {
462 max_amplitude =
i / (
double)
s->nb_hbins;
468 if (max_amplitude > 0.) {
469 for (
i = 0;
i <
s->window_size;
i++) {
474 memset(
clip, 0,
s->ar_order *
sizeof(*
clip));
475 memset(
clip + (
s->window_size -
s->ar_order), 0,
s->ar_order *
sizeof(*
clip));
486 double *detection,
double *acoefficients,
487 uint8_t *click,
int *
index,
488 const double *
src,
double *dst)
491 int i, j, nb_clicks = 0, prev = -1;
493 memset(detection, 0,
s->window_size *
sizeof(*detection));
496 for (j = 0; j <=
s->ar_order; j++) {
497 detection[
i] += acoefficients[j] *
src[
i - j];
501 for (
i = 0;
i <
s->window_size;
i++) {
506 for (
i = 0;
i <
s->window_size;
i++) {
511 for (j = prev + 1; j <
i; j++)
516 memset(click, 0,
s->ar_order *
sizeof(*click));
517 memset(click + (
s->window_size -
s->ar_order), 0,
s->ar_order *
sizeof(*click));
535 const double *
src = (
const double *)
s->in->extended_data[ch];
536 double *
is = (
double *)
s->is->extended_data[ch];
537 double *dst = (
double *)
s->out->extended_data[ch];
538 double *ptr = (
double *)
out->extended_data[ch];
539 double *buf = (
double *)
s->buffer->extended_data[ch];
540 const double *
w =
s->window_func_lut;
548 double *interpolated =
c->interpolated;
552 nb_errors =
s->detector(
s,
c, sigmae,
c->detection,
c->acoefficients,
555 double *enabled = (
double *)
s->enabled->extended_data[0];
558 nb_errors,
c->auxiliary, interpolated);
564 for (j = 0; j < nb_errors; j++) {
565 if (enabled[
index[j]]) {
566 dst[
index[j]] = interpolated[j];
572 memcpy(dst,
src,
s->window_size *
sizeof(*dst));
575 if (
s->method == 0) {
576 for (j = 0; j <
s->window_size; j++)
577 buf[j] += dst[j] *
w[j];
579 const int skip =
s->overlap_skip;
581 for (j = 0; j <
s->hop_size; j++)
582 buf[j] = dst[
skip + j];
584 for (j = 0; j <
s->hop_size; j++)
587 memmove(buf, buf +
s->hop_size, (
s->window_size * 2 -
s->hop_size) *
sizeof(*buf));
588 memmove(
is,
is +
s->hop_size, (
s->window_size -
s->hop_size) *
sizeof(*
is));
589 memset(buf +
s->window_size * 2 -
s->hop_size, 0,
s->hop_size *
sizeof(*buf));
590 memset(
is +
s->window_size -
s->hop_size, 0,
s->hop_size *
sizeof(*
is));
601 int ret = 0, j, ch, detected_errors = 0;
618 for (ch = 0; ch <
s->in->ch_layout.nb_channels; ch++) {
619 double *
is = (
double *)
s->is->extended_data[ch];
621 for (j = 0; j <
s->hop_size; j++) {
630 if (
s->samples_left > 0)
631 out->nb_samples =
FFMIN(
s->hop_size,
s->samples_left);
636 s->detected_errors += detected_errors;
637 s->nb_samples +=
out->nb_samples *
inlink->ch_layout.nb_channels;
643 if (
s->samples_left > 0) {
644 s->samples_left -=
s->hop_size;
645 if (
s->samples_left <= 0)
670 double *e = (
double *)
s->enabled->extended_data[0];
678 e[
i] = !
ctx->is_disabled;
704 if (
s->eof &&
s->samples_left <= 0) {
719 s->is_declip = !strcmp(
ctx->filter->name,
"adeclip");
734 if (
s->nb_samples > 0)
736 s->is_declip ?
"clips" :
"clicks",
s->detected_errors,
737 s->nb_samples, 100. *
s->detected_errors /
s->nb_samples);
749 for (
i = 0;
i <
s->nb_channels;
i++) {
763 c->histogram_size = 0;
786 .priv_class = &adeclick_class,
822 .priv_class = &adeclip_class,
void av_audio_fifo_free(AVAudioFifo *af)
Free an AVAudioFifo.
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
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
The official guide to swscale for confused that is
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
#define AVERROR_EOF
End of file.
int av_audio_fifo_write(AVAudioFifo *af, void *const *data, int nb_samples)
Write data to an AVAudioFifo.
#define FILTER_SINGLE_SAMPLEFMT(sample_fmt_)
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
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
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
This structure describes decoded (raw) audio or video data.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
static av_cold int init(AVFilterContext *ctx)
const char * name
Filter name.
A link between two filters.
static int activate(AVFilterContext *ctx)
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
const AVFilter ff_af_adeclip
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Context for an Audio FIFO Buffer.
int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples)
Drain data from an AVAudioFifo.
A filter pad used for either input or output.
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
static int detect_clicks(AudioDeclickContext *s, DeclickChannel *c, double sigmae, double *detection, double *acoefficients, uint8_t *click, int *index, const double *src, double *dst)
static av_cold void uninit(AVFilterContext *ctx)
#define FILTER_INPUTS(array)
static int config_input(AVFilterLink *inlink)
static void autocorrelation(const double *input, int order, int size, double *output, double scale)
Describe the class of an AVClass context structure.
static __device__ float fabs(float a)
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.
Rational number (pair of numerator and denominator).
AVAudioFifo * av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, int nb_samples)
Allocate an AVAudioFifo.
const AVFilterPad ff_audio_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_AUDIO.
int(* detector)(struct AudioDeclickContext *s, DeclickChannel *c, double sigmae, double *detection, double *acoefficients, uint8_t *click, int *index, const double *src, double *dst)
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
static int filter_channel(AVFilterContext *ctx, void *arg, int ch, int nb_jobs)
static const AVOption adeclick_options[]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
double fmin(double, double)
#define AV_NOPTS_VALUE
Undefined timestamp value.
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
int av_audio_fifo_peek(const AVAudioFifo *af, void *const *data, int nb_samples)
Peek data from an AVAudioFifo.
FF_FILTER_FORWARD_WANTED(outlink, inlink)
int av_audio_fifo_size(AVAudioFifo *af)
Get the current number of samples in the AVAudioFifo available for reading.
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input
static double autoregression(const double *samples, int ar_order, int nb_samples, double *k, double *r, double *a)
static int interpolation(DeclickChannel *c, const double *src, int ar_order, double *acoefficients, int *index, int nb_errors, double *auxiliary, double *interpolated)
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
#define AV_LOG_INFO
Standard information.
static int detect_clips(AudioDeclickContext *s, DeclickChannel *c, double unused0, double *unused1, double *unused2, uint8_t *clip, int *index, const double *src, double *dst)
int nb_samples
number of audio samples (per channel) described by this frame
static int filter_frame(AVFilterLink *inlink)
#define i(width, name, range_min, range_max)
static int find_index(int *index, int value, int size)
static const AVOption adeclip_options[]
uint8_t ** extended_data
pointers to the data planes/channels.
Used for passing data between threads.
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 default value
const char * name
Pad name.
void * av_calloc(size_t nmemb, size_t size)
static int factorization(double *matrix, int n)
AVFILTER_DEFINE_CLASS(adeclick)
static const AVFilterPad inputs[]
@ AV_SAMPLE_FMT_DBLP
double, planar
Filter the word “frame” indicates either a video frame or a group of audio samples
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link.
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
static void scale(int *out, const int *in, const int w, const int h, const int shift)
static const int16_t alpha[]
static int do_interpolation(DeclickChannel *c, double *matrix, double *vector, int n, double *out)
#define FILTER_OUTPUTS(array)
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
const AVFilter ff_af_adeclick
static int isfinite_array(double *samples, int nb_samples)
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
void ff_filter_set_ready(AVFilterContext *filter, unsigned priority)
Mark a filter ready and schedule it for activation.