Go to the documentation of this file.
100 #define OFFSET(x) offsetof(LoudNormContext, x)
101 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
137 double total_weight = 0.0;
138 const double sigma = 3.5;
142 const int offset = 21 / 2;
143 const double c1 = 1.0 / (sigma * sqrt(2.0 *
M_PI));
144 const double c2 = 2.0 * pow(sigma, 2.0);
146 for (
i = 0;
i < 21;
i++) {
148 s->weights[
i] =
c1 *
exp(-(pow(x, 2.0) /
c2));
149 total_weight +=
s->weights[
i];
152 adjust = 1.0 / total_weight;
153 for (
i = 0;
i < 21;
i++)
163 for (
i = 0;
i < 21;
i++)
176 buf =
s->limiter_buf;
177 ceiling =
s->target_tp;
180 if (
index >=
s->limiter_buf_size)
181 index -=
s->limiter_buf_size;
188 for (n = 0; n < nb_samples; n++) {
190 double this, next, max_peak;
195 if ((
s->prev_smp[
c] <=
this) && (next <=
this) && (
this > ceiling) && (n > 0)) {
199 for (
i = 2;
i < 12;
i++) {
219 *peak_value = max_peak;
223 s->prev_smp[
c] =
this;
227 if (
index >=
s->limiter_buf_size)
228 index -=
s->limiter_buf_size;
234 int n,
c,
index, peak_delta, smp_cnt;
235 double ceiling, peak_value;
238 buf =
s->limiter_buf;
239 ceiling =
s->target_tp;
240 index =
s->limiter_buf_index;
247 for (n = 0; n < 1920; n++) {
255 s->gain_reduction[1] = ceiling /
max;
257 buf =
s->limiter_buf;
259 for (n = 0; n < 1920; n++) {
262 env =
s->gain_reduction[1];
269 buf =
s->limiter_buf;
274 switch(
s->limiter_state) {
277 if (peak_delta != -1) {
279 smp_cnt += (peak_delta -
s->attack_length);
280 s->gain_reduction[0] = 1.;
281 s->gain_reduction[1] = ceiling / peak_value;
284 s->env_index =
s->peak_index - (
s->attack_length *
channels);
285 if (
s->env_index < 0)
286 s->env_index +=
s->limiter_buf_size;
289 if (
s->env_index >
s->limiter_buf_size)
290 s->env_index -=
s->limiter_buf_size;
293 smp_cnt = nb_samples;
298 for (;
s->env_cnt <
s->attack_length;
s->env_cnt++) {
301 env =
s->gain_reduction[0] - ((
double)
s->env_cnt / (
s->attack_length - 1) * (
s->gain_reduction[0] -
s->gain_reduction[1]));
302 buf[
s->env_index +
c] *= env;
306 if (
s->env_index >=
s->limiter_buf_size)
307 s->env_index -=
s->limiter_buf_size;
310 if (smp_cnt >= nb_samples) {
316 if (smp_cnt < nb_samples) {
318 s->attack_length = 1920;
325 if (peak_delta == -1) {
327 s->gain_reduction[0] =
s->gain_reduction[1];
328 s->gain_reduction[1] = 1.;
332 double gain_reduction;
333 gain_reduction = ceiling / peak_value;
335 if (gain_reduction < s->gain_reduction[1]) {
338 s->attack_length = peak_delta;
339 if (
s->attack_length <= 1)
340 s->attack_length = 2;
342 s->gain_reduction[0] =
s->gain_reduction[1];
343 s->gain_reduction[1] = gain_reduction;
348 for (
s->env_cnt = 0;
s->env_cnt < peak_delta;
s->env_cnt++) {
351 env =
s->gain_reduction[1];
352 buf[
s->env_index +
c] *= env;
356 if (
s->env_index >=
s->limiter_buf_size)
357 s->env_index -=
s->limiter_buf_size;
360 if (smp_cnt >= nb_samples) {
369 for (;
s->env_cnt <
s->release_length;
s->env_cnt++) {
372 env =
s->gain_reduction[0] + (((
double)
s->env_cnt / (
s->release_length - 1)) * (
s->gain_reduction[1] -
s->gain_reduction[0]));
373 buf[
s->env_index +
c] *= env;
377 if (
s->env_index >=
s->limiter_buf_size)
378 s->env_index -=
s->limiter_buf_size;
381 if (smp_cnt >= nb_samples) {
387 if (smp_cnt < nb_samples) {
389 s->limiter_state =
OUT;
395 }
while (smp_cnt < nb_samples);
397 for (n = 0; n < nb_samples; n++) {
401 out[
c] = ceiling * (
out[
c] < 0 ? -1 : 1);
406 if (
index >=
s->limiter_buf_size)
407 index -=
s->limiter_buf_size;
421 int i, n,
c, subframe_length, src_index;
422 double gain, gain_next, env_global, env_shortterm,
423 global, shortterm, lra, relative_threshold;
436 out->pts =
s->pts[0];
439 src = (
const double *)in->
data[0];
440 dst = (
double *)
out->data[0];
442 limiter_buf =
s->limiter_buf;
447 double offset, offset_tp, true_peak;
450 for (
c = 0;
c <
inlink->ch_layout.nb_channels;
c++) {
453 if (
c == 0 ||
tmp > true_peak)
457 offset = pow(10., (
s->target_i - global) / 20.);
458 offset_tp = true_peak *
offset;
459 s->offset = offset_tp <
s->target_tp ?
offset :
s->target_tp / true_peak;
463 switch (
s->frame_type) {
466 for (
c = 0;
c <
inlink->ch_layout.nb_channels;
c++) {
467 buf[
s->buf_index +
c] =
src[
c];
470 s->buf_index +=
inlink->ch_layout.nb_channels;
475 if (shortterm < s->measured_thresh) {
476 s->above_threshold = 0;
477 env_shortterm = shortterm <= -70. ? 0. :
s->target_i -
s->measured_i;
479 s->above_threshold = 1;
480 env_shortterm = shortterm <= -70. ? 0. :
s->target_i - shortterm;
483 for (n = 0; n < 30; n++)
484 s->delta[n] = pow(10., env_shortterm / 20.);
485 s->prev_delta =
s->delta[
s->index];
488 s->limiter_buf_index = 0;
490 for (n = 0; n < (
s->limiter_buf_size /
inlink->ch_layout.nb_channels); n++) {
491 for (
c = 0;
c <
inlink->ch_layout.nb_channels;
c++) {
492 limiter_buf[
s->limiter_buf_index +
c] = buf[
s->buf_index +
c] *
s->delta[
s->index] *
s->offset;
494 s->limiter_buf_index +=
inlink->ch_layout.nb_channels;
495 if (
s->limiter_buf_index >=
s->limiter_buf_size)
496 s->limiter_buf_index -=
s->limiter_buf_size;
498 s->buf_index +=
inlink->ch_layout.nb_channels;
505 out->nb_samples = subframe_length;
515 for (
c = 0;
c <
inlink->ch_layout.nb_channels;
c++) {
516 buf[
s->prev_buf_index +
c] =
src[
c];
517 limiter_buf[
s->limiter_buf_index +
c] = buf[
s->buf_index +
c] * (gain + (((
double) n / in->
nb_samples) * (gain_next - gain))) *
s->offset;
521 s->limiter_buf_index +=
inlink->ch_layout.nb_channels;
522 if (
s->limiter_buf_index >=
s->limiter_buf_size)
523 s->limiter_buf_index -=
s->limiter_buf_size;
525 s->prev_buf_index +=
inlink->ch_layout.nb_channels;
526 if (
s->prev_buf_index >=
s->buf_size)
527 s->prev_buf_index -=
s->buf_size;
529 s->buf_index +=
inlink->ch_layout.nb_channels;
530 if (
s->buf_index >=
s->buf_size)
531 s->buf_index -=
s->buf_size;
535 s->limiter_buf_index =
s->limiter_buf_index + subframe_length < s->limiter_buf_size ?
s->limiter_buf_index + subframe_length :
s->limiter_buf_index + subframe_length -
s->limiter_buf_size;
545 if (
s->above_threshold == 0) {
546 double shortterm_out;
548 if (shortterm >
s->measured_thresh)
549 s->prev_delta *= 1.0058;
552 if (shortterm_out >=
s->target_i)
553 s->above_threshold = 1;
556 if (shortterm < relative_threshold || shortterm <= -70. || s->above_threshold == 0) {
557 s->delta[
s->index] =
s->prev_delta;
559 env_global =
fabs(shortterm - global) < (
s->target_lra / 2.) ? shortterm - global : (
s->target_lra / 2.) * ((shortterm - global) < 0 ? -1 : 1);
560 env_shortterm =
s->target_i - shortterm;
561 s->delta[
s->index] = pow(10., (env_global + env_shortterm) / 20.);
564 s->prev_delta =
s->delta[
s->index];
573 s->limiter_buf_index = 0;
576 for (n = 0; n <
s->limiter_buf_size /
inlink->ch_layout.nb_channels; n++) {
577 for (
c = 0;
c <
inlink->ch_layout.nb_channels;
c++) {
578 s->limiter_buf[
s->limiter_buf_index +
c] =
src[src_index +
c] * gain *
s->offset;
580 src_index +=
inlink->ch_layout.nb_channels;
582 s->limiter_buf_index +=
inlink->ch_layout.nb_channels;
583 if (
s->limiter_buf_index >=
s->limiter_buf_size)
584 s->limiter_buf_index -=
s->limiter_buf_size;
591 for (n = 0; n < subframe_length; n++) {
592 for (
c = 0;
c <
inlink->ch_layout.nb_channels;
c++) {
594 limiter_buf[
s->limiter_buf_index +
c] =
src[src_index +
c] * gain *
s->offset;
596 limiter_buf[
s->limiter_buf_index +
c] = 0.;
601 src_index +=
inlink->ch_layout.nb_channels;
603 s->limiter_buf_index +=
inlink->ch_layout.nb_channels;
604 if (
s->limiter_buf_index >=
s->limiter_buf_size)
605 s->limiter_buf_index -=
s->limiter_buf_size;
608 dst += (subframe_length *
inlink->ch_layout.nb_channels);
611 dst = (
double *)
out->data[0];
617 for (
c = 0;
c <
inlink->ch_layout.nb_channels;
c++) {
618 dst[
c] =
src[
c] *
s->offset;
621 dst +=
inlink->ch_layout.nb_channels;
624 dst = (
double *)
out->data[0];
647 nb_samples = (
s->buf_size /
inlink->ch_layout.nb_channels) -
s->prev_nb_samples;
658 offset = ((
s->limiter_buf_size /
inlink->ch_layout.nb_channels) -
s->prev_nb_samples) *
inlink->ch_layout.nb_channels;
660 s->buf_index =
s->buf_index - offset < 0 ? s->buf_index -
offset +
s->buf_size :
s->buf_index -
offset;
662 for (n = 0; n < nb_samples; n++) {
663 for (
c = 0;
c <
inlink->ch_layout.nb_channels;
c++) {
664 src[
c] = buf[
s->buf_index +
c];
667 s->buf_index +=
inlink->ch_layout.nb_channels;
668 if (
s->buf_index >=
s->buf_size)
669 s->buf_index -=
s->buf_size;
710 s->pts[
i] = in->
pts +
i * nb_samples;
734 static const int input_srate[] = {192000, -1};
767 if (
inlink->ch_layout.nb_channels == 1 &&
s->dual_mono) {
790 s->limiter_buf_index = 0;
791 s->channels =
inlink->ch_layout.nb_channels;
793 s->limiter_state =
OUT;
794 s->offset = pow(10.,
s->offset / 20.);
795 s->target_tp = pow(10.,
s->target_tp / 20.);
809 offset =
s->target_i -
s->measured_i;
810 offset_tp =
s->measured_tp +
offset;
812 if (
s->measured_tp != 99 &&
s->measured_thresh != -70 &&
s->measured_lra != 0 &&
s->measured_i != 0) {
813 if ((offset_tp <= s->target_tp) && (
s->measured_lra <=
s->target_lra)) {
826 double i_in, i_out, lra_in, lra_out, thresh_in, thresh_out, tp_in, tp_out;
829 if (!
s->r128_in || !
s->r128_out)
835 for (
c = 0;
c <
s->channels;
c++) {
838 if ((
c == 0) || (
tmp > tp_in))
845 for (
c = 0;
c <
s->channels;
c++) {
848 if ((
c == 0) || (
tmp > tp_out))
852 switch(
s->print_format) {
859 "\t\"input_i\" : \"%.2f\",\n"
860 "\t\"input_tp\" : \"%.2f\",\n"
861 "\t\"input_lra\" : \"%.2f\",\n"
862 "\t\"input_thresh\" : \"%.2f\",\n"
863 "\t\"output_i\" : \"%.2f\",\n"
864 "\t\"output_tp\" : \"%+.2f\",\n"
865 "\t\"output_lra\" : \"%.2f\",\n"
866 "\t\"output_thresh\" : \"%.2f\",\n"
867 "\t\"normalization_type\" : \"%s\",\n"
868 "\t\"target_offset\" : \"%.2f\"\n"
886 "Input Integrated: %+6.1f LUFS\n"
887 "Input True Peak: %+6.1f dBTP\n"
888 "Input LRA: %6.1f LU\n"
889 "Input Threshold: %+6.1f LUFS\n"
891 "Output Integrated: %+6.1f LUFS\n"
892 "Output True Peak: %+6.1f dBTP\n"
893 "Output LRA: %6.1f LU\n"
894 "Output Threshold: %+6.1f LUFS\n"
896 "Normalization Type: %s\n"
897 "Target Offset: %+6.1f LU\n",
934 .priv_class = &loudnorm_class,
static av_cold int init(AVFilterContext *ctx)
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
static av_cold void uninit(AVFilterContext *ctx)
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
static enum AVSampleFormat sample_fmts[]
static int frame_size(int sample_rate, int frame_len_msec)
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).
#define FILTER_QUERY_FUNC(func)
static int linear(InterplayACMContext *s, unsigned ind, unsigned col)
@ FF_EBUR128_MODE_I
can call ff_ebur128_loudness_global_* and ff_ebur128_relative_threshold
enum PrintFormat print_format
const char * name
Filter name.
A link between two filters.
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
int ff_ebur128_loudness_range(FFEBUR128State *st, double *out)
Get loudness range (LRA) of programme in LU.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
void ff_ebur128_destroy(FFEBUR128State **st)
Destroy library state.
static void true_peak_limiter(LoudNormContext *s, double *out, int nb_samples, int channels)
A filter pad used for either input or output.
@ FF_EBUR128_DUAL_MONO
a channel that is counted twice
static int flush_frame(AVFilterLink *outlink)
#define FF_ARRAY_ELEMS(a)
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
@ FF_EBUR128_MODE_LRA
can call ff_ebur128_loudness_range
void ff_ebur128_add_frames_double(FFEBUR128State *st, const double *src, size_t frames)
Add frames to be processed.
static int adjust(int x, int size)
enum LimiterState limiter_state
#define FILTER_INPUTS(array)
FrameType
G723.1 frame types.
const AVFilter ff_af_loudnorm
Describe the class of an AVClass context structure.
and forward the result(frame or status change) to the corresponding input. If nothing is possible
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.
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
int ff_ebur128_sample_peak(FFEBUR128State *st, unsigned int channel_number, double *out)
Get maximum sample peak of selected channel in float format.
static const AVOption loudnorm_options[]
const AVFilterPad ff_audio_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_AUDIO.
static int activate(AVFilterContext *ctx)
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 query_formats(AVFilterContext *ctx)
AVFILTER_DEFINE_CLASS(loudnorm)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
int ff_ebur128_loudness_shortterm(FFEBUR128State *st, double *out)
Get short-term loudness (last 3s) in LUFS.
static void init_gaussian_filter(LoudNormContext *s)
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
AVFilterContext * src
source filter
@ FF_EBUR128_MODE_S
can call ff_ebur128_loudness_shortterm
FFEBUR128State * ff_ebur128_init(unsigned int channels, unsigned long samplerate, unsigned long window, int mode)
Initialize library state.
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 offset
FF_FILTER_FORWARD_WANTED(outlink, inlink)
#define AV_LOG_INFO
Standard information.
enum FrameType frame_type
int nb_samples
number of audio samples (per channel) described by this frame
#define i(width, name, range_min, range_max)
int ff_ebur128_set_channel(FFEBUR128State *st, unsigned int channel_number, int value)
Set channel type.
static av_always_inline av_const double round(double x)
libebur128 - a library for loudness measurement according to the EBU R128 standard.
#define av_malloc_array(a, b)
AVSampleFormat
Audio sample formats.
Contains information about the state of a loudness measurement.
const char * name
Pad name.
static const AVFilterPad avfilter_af_loudnorm_inputs[]
static int config_input(AVFilterLink *inlink)
int ff_ebur128_relative_threshold(FFEBUR128State *st, double *out)
Get relative threshold in LUFS.
#define FILTER_OUTPUTS(array)
@ FF_EBUR128_MODE_SAMPLE_PEAK
can call ff_ebur128_sample_peak
static void detect_peak(LoudNormContext *s, int offset, int nb_samples, int channels, int *peak_delta, double *peak_value)
static double gaussian_filter(LoudNormContext *s, int index)
FFEBUR128State * r128_out
@ AV_SAMPLE_FMT_DBL
double
int ff_ebur128_loudness_global(FFEBUR128State *st, double *out)
Get global integrated loudness in LUFS.