98 #define OFFSET(x) offsetof(LoudNormContext, x)
99 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
135 double total_weight = 0.0;
136 const double sigma = 3.5;
140 const int offset = 21 / 2;
141 const double c1 = 1.0 / (sigma * sqrt(2.0 *
M_PI));
142 const double c2 = 2.0 * pow(sigma, 2.0);
144 for (
i = 0;
i < 21;
i++) {
146 s->weights[
i] =
c1 *
exp(-(pow(x, 2.0) /
c2));
147 total_weight +=
s->weights[
i];
150 adjust = 1.0 / total_weight;
151 for (
i = 0;
i < 21;
i++)
161 for (
i = 0;
i < 21;
i++)
174 buf =
s->limiter_buf;
175 ceiling =
s->target_tp;
178 if (
index >=
s->limiter_buf_size)
179 index -=
s->limiter_buf_size;
186 for (n = 0; n < nb_samples; n++) {
188 double this, next, max_peak;
193 if ((
s->prev_smp[
c] <=
this) && (next <=
this) && (
this > ceiling) && (n > 0)) {
197 for (
i = 2;
i < 12;
i++) {
217 *peak_value = max_peak;
221 s->prev_smp[
c] =
this;
225 if (
index >=
s->limiter_buf_size)
226 index -=
s->limiter_buf_size;
232 int n,
c,
index, peak_delta, smp_cnt;
233 double ceiling, peak_value;
236 buf =
s->limiter_buf;
237 ceiling =
s->target_tp;
238 index =
s->limiter_buf_index;
245 for (n = 0; n < 1920; n++) {
253 s->gain_reduction[1] = ceiling /
max;
255 buf =
s->limiter_buf;
257 for (n = 0; n < 1920; n++) {
260 env =
s->gain_reduction[1];
267 buf =
s->limiter_buf;
272 switch(
s->limiter_state) {
275 if (peak_delta != -1) {
277 smp_cnt += (peak_delta -
s->attack_length);
278 s->gain_reduction[0] = 1.;
279 s->gain_reduction[1] = ceiling / peak_value;
282 s->env_index =
s->peak_index - (
s->attack_length *
channels);
283 if (
s->env_index < 0)
284 s->env_index +=
s->limiter_buf_size;
287 if (
s->env_index >
s->limiter_buf_size)
288 s->env_index -=
s->limiter_buf_size;
291 smp_cnt = nb_samples;
296 for (;
s->env_cnt <
s->attack_length;
s->env_cnt++) {
299 env =
s->gain_reduction[0] - ((double)
s->env_cnt / (
s->attack_length - 1) * (
s->gain_reduction[0] -
s->gain_reduction[1]));
300 buf[
s->env_index +
c] *= env;
304 if (
s->env_index >=
s->limiter_buf_size)
305 s->env_index -=
s->limiter_buf_size;
308 if (smp_cnt >= nb_samples) {
314 if (smp_cnt < nb_samples) {
316 s->attack_length = 1920;
323 if (peak_delta == -1) {
325 s->gain_reduction[0] =
s->gain_reduction[1];
326 s->gain_reduction[1] = 1.;
330 double gain_reduction;
331 gain_reduction = ceiling / peak_value;
333 if (gain_reduction < s->gain_reduction[1]) {
336 s->attack_length = peak_delta;
337 if (
s->attack_length <= 1)
338 s->attack_length = 2;
340 s->gain_reduction[0] =
s->gain_reduction[1];
341 s->gain_reduction[1] = gain_reduction;
346 for (
s->env_cnt = 0;
s->env_cnt < peak_delta;
s->env_cnt++) {
349 env =
s->gain_reduction[1];
350 buf[
s->env_index +
c] *= env;
354 if (
s->env_index >=
s->limiter_buf_size)
355 s->env_index -=
s->limiter_buf_size;
358 if (smp_cnt >= nb_samples) {
367 for (;
s->env_cnt <
s->release_length;
s->env_cnt++) {
370 env =
s->gain_reduction[0] + (((double)
s->env_cnt / (
s->release_length - 1)) * (
s->gain_reduction[1] -
s->gain_reduction[0]));
371 buf[
s->env_index +
c] *= env;
375 if (
s->env_index >=
s->limiter_buf_size)
376 s->env_index -=
s->limiter_buf_size;
379 if (smp_cnt >= nb_samples) {
385 if (smp_cnt < nb_samples) {
387 s->limiter_state =
OUT;
393 }
while (smp_cnt < nb_samples);
395 for (n = 0; n < nb_samples; n++) {
399 out[
c] = ceiling * (
out[
c] < 0 ? -1 : 1);
404 if (
index >=
s->limiter_buf_size)
405 index -=
s->limiter_buf_size;
419 int i, n,
c, subframe_length, src_index;
420 double gain, gain_next, env_global, env_shortterm,
421 global, shortterm, lra, relative_threshold;
438 src = (
const double *)
in->data[0];
439 dst = (
double *)
out->data[0];
441 limiter_buf =
s->limiter_buf;
446 double offset, offset_tp, true_peak;
452 if (
c == 0 ||
tmp > true_peak)
456 offset = pow(10., (
s->target_i - global) / 20.);
457 offset_tp = true_peak *
offset;
458 s->offset = offset_tp <
s->target_tp ?
offset :
s->target_tp - true_peak;
462 switch (
s->frame_type) {
464 for (n = 0; n <
in->nb_samples; n++) {
466 buf[
s->buf_index +
c] =
src[
c];
474 if (shortterm < s->measured_thresh) {
475 s->above_threshold = 0;
476 env_shortterm = shortterm <= -70. ? 0. :
s->target_i -
s->measured_i;
478 s->above_threshold = 1;
479 env_shortterm = shortterm <= -70. ? 0. :
s->target_i - shortterm;
482 for (n = 0; n < 30; n++)
483 s->delta[n] = pow(10., env_shortterm / 20.);
484 s->prev_delta =
s->delta[
s->index];
487 s->limiter_buf_index = 0;
489 for (n = 0; n < (
s->limiter_buf_size / inlink->
channels); n++) {
491 limiter_buf[
s->limiter_buf_index +
c] = buf[
s->buf_index +
c] *
s->delta[
s->index] *
s->offset;
493 s->limiter_buf_index += inlink->
channels;
494 if (
s->limiter_buf_index >=
s->limiter_buf_size)
495 s->limiter_buf_index -=
s->limiter_buf_size;
517 for (n = 0; n <
in->nb_samples; n++) {
519 buf[
s->prev_buf_index +
c] =
src[
c];
520 limiter_buf[
s->limiter_buf_index +
c] = buf[
s->buf_index +
c] * (gain + (((double) n /
in->nb_samples) * (gain_next - gain))) *
s->offset;
524 s->limiter_buf_index += inlink->
channels;
525 if (
s->limiter_buf_index >=
s->limiter_buf_size)
526 s->limiter_buf_index -=
s->limiter_buf_size;
529 if (
s->prev_buf_index >=
s->buf_size)
530 s->prev_buf_index -=
s->buf_size;
533 if (
s->buf_index >=
s->buf_size)
534 s->buf_index -=
s->buf_size;
538 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;
548 if (
s->above_threshold == 0) {
549 double shortterm_out;
551 if (shortterm >
s->measured_thresh)
552 s->prev_delta *= 1.0058;
555 if (shortterm_out >=
s->target_i)
556 s->above_threshold = 1;
559 if (shortterm < relative_threshold || shortterm <= -70. || s->above_threshold == 0) {
560 s->delta[
s->index] =
s->prev_delta;
562 env_global =
fabs(shortterm - global) < (
s->target_lra / 2.) ? shortterm - global : (
s->target_lra / 2.) * ((shortterm - global) < 0 ? -1 : 1);
563 env_shortterm =
s->target_i - shortterm;
564 s->delta[
s->index] = pow(10., (env_global + env_shortterm) / 20.);
567 s->prev_delta =
s->delta[
s->index];
571 s->prev_nb_samples =
in->nb_samples;
572 s->pts +=
in->nb_samples;
577 s->limiter_buf_index = 0;
580 for (n = 0; n <
s->limiter_buf_size / inlink->
channels; n++) {
582 s->limiter_buf[
s->limiter_buf_index +
c] =
src[src_index +
c] * gain *
s->offset;
586 s->limiter_buf_index += inlink->
channels;
587 if (
s->limiter_buf_index >=
s->limiter_buf_size)
588 s->limiter_buf_index -=
s->limiter_buf_size;
592 for (
i = 0;
i <
in->nb_samples / subframe_length;
i++) {
595 for (n = 0; n < subframe_length; n++) {
597 if (src_index < (
in->nb_samples * inlink->
channels)) {
598 limiter_buf[
s->limiter_buf_index +
c] =
src[src_index +
c] * gain *
s->offset;
600 limiter_buf[
s->limiter_buf_index +
c] = 0.;
604 if (src_index < (
in->nb_samples * inlink->
channels))
607 s->limiter_buf_index += inlink->
channels;
608 if (
s->limiter_buf_index >=
s->limiter_buf_size)
609 s->limiter_buf_index -=
s->limiter_buf_size;
612 dst += (subframe_length * inlink->
channels);
615 dst = (
double *)
out->data[0];
620 for (n = 0; n <
in->nb_samples; n++) {
622 dst[
c] =
src[
c] *
s->offset;
628 dst = (
double *)
out->data[0];
630 s->pts +=
in->nb_samples;
654 nb_samples = (
s->buf_size / inlink->
channels) -
s->prev_nb_samples;
667 s->buf_index =
s->buf_index - offset < 0 ? s->buf_index -
offset +
s->buf_size :
s->buf_index -
offset;
669 for (n = 0; n < nb_samples; n++) {
671 src[
c] = buf[
s->buf_index +
c];
675 if (
s->buf_index >=
s->buf_size)
676 s->buf_index -=
s->buf_size;
692 static const int input_srate[] = {192000, -1};
741 if (inlink->
channels == 1 &&
s->dual_mono) {
771 s->limiter_buf_index = 0;
774 s->limiter_state =
OUT;
775 s->offset = pow(10.,
s->offset / 20.);
776 s->target_tp = pow(10.,
s->target_tp / 20.);
790 offset =
s->target_i -
s->measured_i;
791 offset_tp =
s->measured_tp +
offset;
793 if (
s->measured_tp != 99 &&
s->measured_thresh != -70 &&
s->measured_lra != 0 &&
s->measured_i != 0) {
794 if ((offset_tp <= s->target_tp) && (
s->measured_lra <=
s->target_lra)) {
807 double i_in, i_out, lra_in, lra_out, thresh_in, thresh_out, tp_in, tp_out;
810 if (!
s->r128_in || !
s->r128_out)
816 for (
c = 0;
c <
s->channels;
c++) {
819 if ((
c == 0) || (
tmp > tp_in))
826 for (
c = 0;
c <
s->channels;
c++) {
829 if ((
c == 0) || (
tmp > tp_out))
833 switch(
s->print_format) {
840 "\t\"input_i\" : \"%.2f\",\n"
841 "\t\"input_tp\" : \"%.2f\",\n"
842 "\t\"input_lra\" : \"%.2f\",\n"
843 "\t\"input_thresh\" : \"%.2f\",\n"
844 "\t\"output_i\" : \"%.2f\",\n"
845 "\t\"output_tp\" : \"%+.2f\",\n"
846 "\t\"output_lra\" : \"%.2f\",\n"
847 "\t\"output_thresh\" : \"%.2f\",\n"
848 "\t\"normalization_type\" : \"%s\",\n"
849 "\t\"target_offset\" : \"%.2f\"\n"
867 "Input Integrated: %+6.1f LUFS\n"
868 "Input True Peak: %+6.1f dBTP\n"
869 "Input LRA: %6.1f LU\n"
870 "Input Threshold: %+6.1f LUFS\n"
872 "Output Integrated: %+6.1f LUFS\n"
873 "Output True Peak: %+6.1f dBTP\n"
874 "Output LRA: %6.1f LU\n"
875 "Output Threshold: %+6.1f LUFS\n"
877 "Normalization Type: %s\n"
878 "Target Offset: %+6.1f LU\n",
926 .priv_class = &loudnorm_class,
static enum AVSampleFormat sample_fmts[]
static const AVFilterPad inputs[]
static const AVFilterPad outputs[]
static const AVOption loudnorm_options[]
static void true_peak_limiter(LoudNormContext *s, double *out, int nb_samples, int channels)
static const AVFilterPad avfilter_af_loudnorm_inputs[]
static int query_formats(AVFilterContext *ctx)
static int config_input(AVFilterLink *inlink)
static int frame_size(int sample_rate, int frame_len_msec)
AVFILTER_DEFINE_CLASS(loudnorm)
static int request_frame(AVFilterLink *outlink)
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
static void init_gaussian_filter(LoudNormContext *s)
static const AVFilterPad avfilter_af_loudnorm_outputs[]
static void detect_peak(LoudNormContext *s, int offset, int nb_samples, int channels, int *peak_delta, double *peak_value)
static av_cold int init(AVFilterContext *ctx)
static av_cold void uninit(AVFilterContext *ctx)
static double gaussian_filter(LoudNormContext *s, int index)
AVFrame * ff_get_audio_buffer(AVFilterLink *link, int nb_samples)
Request an audio samples buffer with a specific set of permissions.
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;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);return NULL;} return ac;} 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;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->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);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Main libavfilter public API header.
static __device__ float fabs(float a)
int ff_ebur128_set_channel(FFEBUR128State *st, unsigned int channel_number, int value)
Set channel type.
int ff_ebur128_loudness_range(FFEBUR128State *st, double *out)
Get loudness range (LRA) of programme in LU.
int ff_ebur128_sample_peak(FFEBUR128State *st, unsigned int channel_number, double *out)
Get maximum sample peak of selected channel in float format.
int ff_ebur128_relative_threshold(FFEBUR128State *st, double *out)
Get relative threshold in LUFS.
void ff_ebur128_destroy(FFEBUR128State **st)
Destroy library state.
int ff_ebur128_loudness_global(FFEBUR128State *st, double *out)
Get global integrated loudness in LUFS.
FFEBUR128State * ff_ebur128_init(unsigned int channels, unsigned long samplerate, unsigned long window, int mode)
Initialize library state.
int ff_ebur128_loudness_shortterm(FFEBUR128State *st, double *out)
Get short-term loudness (last 3s) in LUFS.
libebur128 - a library for loudness measurement according to the EBU R128 standard.
@ FF_EBUR128_MODE_I
can call ff_ebur128_loudness_global_* and ff_ebur128_relative_threshold
@ FF_EBUR128_MODE_LRA
can call ff_ebur128_loudness_range
@ FF_EBUR128_MODE_S
can call ff_ebur128_loudness_shortterm
@ FF_EBUR128_MODE_SAMPLE_PEAK
can call ff_ebur128_sample_peak
void ff_ebur128_add_frames_double(FFEBUR128State *st, const double *src, size_t frames)
Add frames to be processed.
@ FF_EBUR128_DUAL_MONO
a channel that is counted twice
static char * print_format
FrameType
G723.1 frame types.
#define AVERROR_EOF
End of file.
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
#define AV_LOG_INFO
Standard information.
AVSampleFormat
Audio sample formats.
@ AV_SAMPLE_FMT_DBL
double
#define AV_NOPTS_VALUE
Undefined timestamp value.
static int linear(InterplayACMContext *s, unsigned ind, unsigned col)
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static av_always_inline av_const double round(double x)
static int adjust(int x, int size)
enum MovChannelLayoutTag * layouts
Describe the class of an AVClass context structure.
A list of supported channel layouts.
A link between two filters.
AVFilterFormatsConfig incfg
Lists of supported formats / etc.
int max_samples
Maximum number of samples to filter at once.
int channels
Number of channels.
AVFilterFormatsConfig outcfg
Lists of supported formats / etc.
int partial_buf_size
Size of the partial buffer to allocate.
AVFilterContext * src
source filter
int sample_rate
samples per second
AVFilterContext * dst
dest filter
int min_samples
Minimum number of samples to filter at once.
A filter pad used for either input or output.
const char * name
Pad name.
const char * name
Filter name.
This structure describes decoded (raw) audio or video data.
int nb_samples
number of audio samples (per channel) described by this frame
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Contains information about the state of a loudness measurement.
enum FrameType frame_type
enum PrintFormat print_format
enum LimiterState limiter_state
FFEBUR128State * r128_out
#define av_malloc_array(a, b)
static const uint8_t offset[127][2]