From 9eb2cf42a5f5940cd9abff063f69492a99364ca2 Mon Sep 17 00:00:00 2001 From: Kyle Swanson Date: Thu, 17 Nov 2016 10:42:11 -0600 Subject: [PATCH 2/2] lavfi/af_ebur128: update filter to use new ebur128 API Signed-off-by: Kyle Swanson --- Changelog | 1 + LICENSE.md | 1 - MAINTAINERS | 1 + configure | 1 - doc/filters.texi | 120 +++--- libavfilter/Makefile | 2 +- libavfilter/af_ebur128.c | 410 ++++++++++++++++++++ libavfilter/f_ebur128.c | 950 ----------------------------------------------- tools/normalize.py | 33 -- 9 files changed, 456 insertions(+), 1063 deletions(-) create mode 100644 libavfilter/af_ebur128.c delete mode 100644 libavfilter/f_ebur128.c delete mode 100755 tools/normalize.py diff --git a/Changelog b/Changelog index 8456022..ad48edc 100644 --- a/Changelog +++ b/Changelog @@ -5,6 +5,7 @@ version : - CrystalHD decoder moved to new decode API - add internal ebur128 library, remove external libebur128 dependency - Pro-MPEG CoP #3-R2 FEC protocol +- Update ebur128 filter to use new ebur128 API version 3.2: - libopenmpt demuxer diff --git a/LICENSE.md b/LICENSE.md index a384fa0..640633c 100644 --- a/LICENSE.md +++ b/LICENSE.md @@ -26,7 +26,6 @@ Specifically, the GPL parts of FFmpeg are: - `tests/checkasm/*` - `tests/tiny_ssim.c` - the following filters in libavfilter: - - `f_ebur128.c` - `vf_blackframe.c` - `vf_boxblur.c` - `vf_colormatrix.c` diff --git a/MAINTAINERS b/MAINTAINERS index 7bb9cc4..ee5eef0 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -313,6 +313,7 @@ Filters: af_biquads.c Paul B Mahol af_chorus.c Paul B Mahol af_compand.c Paul B Mahol + af_ebur128.c Kyle Swanson af_firequalizer.c Muhammad Faiz af_hdcd.c Burt P. af_ladspa.c Paul B Mahol diff --git a/configure b/configure index b5bfad6..086707f 100755 --- a/configure +++ b/configure @@ -3033,7 +3033,6 @@ cropdetect_filter_deps="gpl" delogo_filter_deps="gpl" deshake_filter_select="pixelutils" drawtext_filter_deps="libfreetype" -ebur128_filter_deps="gpl" eq_filter_deps="gpl" fftfilt_filter_deps="avcodec" fftfilt_filter_select="rdft" diff --git a/doc/filters.texi b/doc/filters.texi index 208be42..e379f91 100644 --- a/doc/filters.texi +++ b/doc/filters.texi @@ -15938,23 +15938,14 @@ signalstats,drawgraph=lavfi.signalstats.YAVG:min=0:max=255 Example using metadata from @ref{ebur128} filter: @example -ebur128=metadata=1,adrawgraph=lavfi.r128.M:min=-120:max=5 +ebur128=metadata=1:momentary=enable,adrawgraph=lavfi.r128.M:min=-120:max=5 @end example @anchor{ebur128} @section ebur128 -EBU R128 scanner filter. This filter takes an audio stream as input and outputs -it unchanged. By default, it logs a message at a frequency of 10Hz with the -Momentary loudness (identified by @code{M}), Short-term loudness (@code{S}), -Integrated loudness (@code{I}) and Loudness Range (@code{LRA}). - -The filter also has a video output (see the @var{video} option) with a real -time graph to observe the loudness evolution. The graphic contains the logged -message mentioned above, so it is not printed anymore when this option is set, -unless the verbose logging is set. The main graphing area contains the -short-term loudness (3 seconds of analysis), and the gauge on the right is for -the momentary loudness (400 milliseconds). +EBU R128 loudness measurement. This filter takes an audio stream as input and outputs +it unchanged. More information about the Loudness Recommendation EBU R128 on @url{http://tech.ebu.ch/loudness}. @@ -15963,89 +15954,64 @@ The filter accepts the following options: @table @option -@item video -Activate the video output. The audio stream is passed unchanged whether this -option is set or no. The video stream will be the first output stream if -activated. Default is @code{0}. +@item momentary +Make momentary measurement. Options are @code{enabled} or @code{disabled}. +Default is @code{disabled}. -@item size -Set the video size. This option is for video only. For the syntax of this -option, check the -@ref{video size syntax,,"Video size" section in the ffmpeg-utils manual,ffmpeg-utils}. -Default and minimum resolution is @code{640x480}. +@item short_term +Make short term measurement. Options are @code{enabled} or @code{disabled}. +Default is @code{disabled}. -@item meter -Set the EBU scale meter. Default is @code{9}. Common values are @code{9} and -@code{18}, respectively for EBU scale meter +9 and EBU scale meter +18. Any -other integer value between this range is allowed. - -@item metadata -Set metadata injection. If set to @code{1}, the audio input will be segmented -into 100ms output frames, each of them containing various loudness information -in metadata. All the metadata keys are prefixed with @code{lavfi.r128.}. - -Default is @code{0}. +@item integrated +Make integrated measurement. Options are @code{enabled} or @code{disabled}. +Default is @code{enabled}. -@item framelog -Force the frame logging level. - -Available values are: -@table @samp -@item info -information logging level -@item verbose -verbose logging level -@end table - -By default, the logging level is set to @var{info}. If the @option{video} or -the @option{metadata} options are set, it switches to @var{verbose}. - -@item peak -Set peak mode(s). +@item threshold +Make relative threshold measurement. Options are @code{enabled} or @code{disabled}. +Default is @code{disabled}. -Available modes can be cumulated (the option is a @code{flag} type). Possible -values are: -@table @samp -@item none -Disable any peak mode (default). -@item sample -Enable sample-peak mode. +@item lra +Make lra measurement. Options are @code{enabled} or @code{disabled}. +Default is @code{enabled}. -Simple peak mode looking for the higher sample value. It logs a message -for sample-peak (identified by @code{SPK}). -@item true -Enable true-peak mode. +@item sample_peak +Make sample peak measurement. Options are @code{enabled} or @code{disabled}. +Default is @code{disabled}. -If enabled, the peak lookup is done on an over-sampled version of the input -stream for better peak accuracy. It logs a message for true-peak. -(identified by @code{TPK}) and true-peak per frame (identified by @code{FTPK}). -This mode requires a build with @code{libswresample}. -@end table +@item true_peak +Make true peak measurement. Options are @code{enabled} or @code{disabled}. +Default is @code{disabled}. -@item dualmono -Treat mono input files as "dual mono". If a mono file is intended for playback +@item dual_mono +Treat mono input files as "dual-mono". If a mono file is intended for playback on a stereo system, its EBU R128 measurement will be perceptually incorrect. If set to @code{true}, this option will compensate for this effect. Multi-channel input files are not affected by this option. +Options are @code{true} or @code{false}. Default is false. -@item panlaw -Set a specific pan law to be used for the measurement of dual mono files. -This parameter is optional, and has a default value of -3.01dB. +@item metadata +Set metadata injection. If set to @code{enabled}, the audio input will be segmented +into 100ms output frames, each of them containing various loudness information +in metadata. All the metadata keys are prefixed with @code{lavfi.r128.}. +Default is @code{disabled}. + +@item framelog +Set framelog. If set to @code{enabled}, the audio input will be segmented into 100ms +output frames, and per-frame loudness stats will be logged to the console. +Default is @code{disabled}. + +@item print_format +Set print format for stats. Options are @code{summary}, @code{json}, or @code{none}. +Default value is @code{summary}. @end table @subsection Examples @itemize @item -Real-time graph using @command{ffplay}, with a EBU scale meter +18: -@example -ffplay -f lavfi -i "amovie=input.mp3,ebur128=video=1:meter=18 [out0][out1]" -@end example - -@item -Run an analysis with @command{ffmpeg}: +Run an loudness analysis with @command{ffmpeg}: @example -ffmpeg -nostats -i input.mp3 -filter_complex ebur128 -f null - +ffmpeg -i input.mp3 -af ebur128=integrated=enable:lra=enable:true_peak=enable -f null - @end example @end itemize diff --git a/libavfilter/Makefile b/libavfilter/Makefile index cdddb1b..6fff63b 100644 --- a/libavfilter/Makefile +++ b/libavfilter/Makefile @@ -84,7 +84,7 @@ OBJS-$(CONFIG_CRYSTALIZER_FILTER) += af_crystalizer.o OBJS-$(CONFIG_DCSHIFT_FILTER) += af_dcshift.o OBJS-$(CONFIG_DYNAUDNORM_FILTER) += af_dynaudnorm.o OBJS-$(CONFIG_EARWAX_FILTER) += af_earwax.o -OBJS-$(CONFIG_EBUR128_FILTER) += f_ebur128.o +OBJS-$(CONFIG_EBUR128_FILTER) += af_ebur128.o ebur128.o OBJS-$(CONFIG_EQUALIZER_FILTER) += af_biquads.o OBJS-$(CONFIG_EXTRASTEREO_FILTER) += af_extrastereo.o OBJS-$(CONFIG_FIREQUALIZER_FILTER) += af_firequalizer.o diff --git a/libavfilter/af_ebur128.c b/libavfilter/af_ebur128.c new file mode 100644 index 0000000..fc19315 --- /dev/null +++ b/libavfilter/af_ebur128.c @@ -0,0 +1,410 @@ +/* + * Copyright (c) 2016 Kyle Swanson . + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "libavutil/opt.h" +#include "avfilter.h" +#include "internal.h" +#include "audio.h" +#include "libavutil/avstring.h" +#include "libavutil/timestamp.h" +#include "ebur128.h" + +enum PrintFormat { + NONE, + JSON, + SUMMARY, + PF_NB +}; + +typedef struct Ebur128Strings { + char momentary[10]; + char short_term[10]; + char integrated[10]; + char lra[10]; + char threshold[10]; + char max_sample_peak[10]; + char max_true_peak[10]; +} Ebur128Strings; + +typedef struct Ebur128Context { + const AVClass *class; + FFEBUR128State *ebur128; + int momentary; + int short_term; + int integrated; + int lra; + int threshold; + int sample_peak; + int true_peak; + int dual_mono; + int metadata; + int framelog; + enum PrintFormat print_format; + + int channels; + Ebur128Strings strings; +} Ebur128Context; + +#define OFFSET(x) offsetof(Ebur128Context, x) +#define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM + +static const AVOption ebur128_options[] = { + { "momentary", "make momentary measurement", OFFSET(momentary), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS }, + { "short_term", "make short term measurement", OFFSET(short_term), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS }, + { "integrated", "make integrated measurement", OFFSET(integrated), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, FLAGS }, + { "threshold", "make threshold measurement", OFFSET(threshold), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS }, + { "lra", "make lra measurement", OFFSET(lra), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, FLAGS }, + { "sample_peak", "make sample peak measurement", OFFSET(sample_peak), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS }, + { "true_peak", "make true peak measurement", OFFSET(true_peak), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS }, + { "dual_mono", "treat mono input as dual-mono", OFFSET(dual_mono), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS }, + { "metadata", "inject metadata in the filtergraph", OFFSET(metadata), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS }, + { "framelog", "force frame logging", OFFSET(framelog), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS, "framelog" }, + { "print_format", "set print format for stats", OFFSET(print_format), AV_OPT_TYPE_INT, {.i64 = SUMMARY}, NONE, PF_NB -1, FLAGS, "print_format" }, + { "none", 0, 0, AV_OPT_TYPE_CONST, {.i64 = NONE}, 0, 0, FLAGS, "print_format" }, + { "json", 0, 0, AV_OPT_TYPE_CONST, {.i64 = JSON}, 0, 0, FLAGS, "print_format" }, + { "summary", 0, 0, AV_OPT_TYPE_CONST, {.i64 = SUMMARY}, 0, 0, FLAGS, "print_format" }, + { NULL } +}; + +AVFILTER_DEFINE_CLASS(ebur128); + +static inline void write_strings(Ebur128Context *s) +{ + if (s->momentary) { + double momentary; + ff_ebur128_loudness_momentary(s->ebur128, &momentary); + snprintf(s->strings.momentary, sizeof(s->strings.momentary), "%.2f", momentary); + } + + if (s->short_term) { + double short_term; + ff_ebur128_loudness_shortterm(s->ebur128, &short_term); + snprintf(s->strings.short_term, sizeof(s->strings.short_term), "%.2f", short_term); + } + + if (s->integrated) { + double integrated; + ff_ebur128_loudness_global(s->ebur128, &integrated); + snprintf(s->strings.integrated, sizeof(s->strings.integrated), "%.2f", integrated); + } + + if (s->lra) { + double lra; + ff_ebur128_loudness_range(s->ebur128, &lra); + snprintf(s->strings.lra, sizeof(s->strings.lra), "%.2f", lra); + } + + if (s->threshold) { + double threshold; + ff_ebur128_relative_threshold(s->ebur128, &threshold); + snprintf(s->strings.threshold, sizeof(s->strings.threshold), "%.2f", threshold); + } + + if (s->sample_peak) { + double sample_peak; + double max_sample_peak; + int c; + for (c = 0; c < s->channels; c++) { + ff_ebur128_sample_peak(s->ebur128, c, &sample_peak); + if ((c == 0) || (sample_peak > max_sample_peak)) + max_sample_peak = sample_peak; + } + snprintf(s->strings.max_sample_peak, sizeof(s->strings.max_sample_peak), "%+.2f", 20. * log10(max_sample_peak)); + } + + if (s->true_peak) { + double true_peak; + double max_true_peak; + int c; + for (c = 0; c < s->channels; c++) { + ff_ebur128_true_peak(s->ebur128, c, &true_peak); + if ((c == 0) || (true_peak > max_true_peak)) + max_true_peak = true_peak; + } + snprintf(s->strings.max_true_peak, sizeof(s->strings.max_true_peak), "%+.2f", 20. * log10(max_true_peak)); + } +} + +static int filter_frame(AVFilterLink *inlink, AVFrame *in) +{ + AVFilterContext *ctx = inlink->dst; + AVFilterLink *outlink = ctx->outputs[0]; + Ebur128Context *s = ctx->priv; + const double *src = (const double *)in->data[0]; + + ff_ebur128_add_frames_double(s->ebur128, src, in->nb_samples); + + if (s->metadata || s->framelog) + write_strings(s); + + if (s->metadata) { + if (s->momentary) + av_dict_set(&in->metadata, "lavfi.r128.momentary", s->strings.momentary, 0); + if (s->short_term) + av_dict_set(&in->metadata, "lavfi.r128.short_term", s->strings.short_term, 0); + if (s->integrated) + av_dict_set(&in->metadata, "lavfi.r128.integrated", s->strings.integrated, 0); + if (s->threshold) + av_dict_set(&in->metadata, "lavfi.r128.threshold", s->strings.threshold, 0); + if (s->lra) + av_dict_set(&in->metadata, "lavfi.r128.lra", s->strings.lra, 0); + if (s->sample_peak) + av_dict_set(&in->metadata, "lavfi.r128.sample_peak", s->strings.max_sample_peak, 0); + if (s->true_peak) + av_dict_set(&in->metadata, "lavfi.r128.true_peak", s->strings.max_true_peak, 0); + } + + if (s->framelog) { + av_log(ctx, AV_LOG_INFO, "%s" + "%-10s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "\n", + "t: ", + av_ts2timestr(in->pts, &outlink->time_base), + s->momentary ? "M: " : "", + s->momentary ? s->strings.momentary : "", + s->momentary ? " LUFS " : "", + s->short_term ? "S: " : "", + s->short_term ? s->strings.short_term : "", + s->short_term ? " LUFS " : "", + s->integrated ? "I: " : "", + s->integrated ? s->strings.integrated : "", + s->integrated ? " LUFS " : "", + s->lra ? "LRA: " : "", + s->lra ? s->strings.lra : "", + s->lra ? " LU " : "", + s->sample_peak ? "SPK: " : "", + s->sample_peak ? s->strings.max_sample_peak : "", + s->sample_peak ? " dBFS " : "", + s->true_peak ? "TPK: " : "", + s->true_peak ? s->strings.max_true_peak : "", + s->true_peak ? " dBTP " : "" + ); + } + + return ff_filter_frame(outlink, in); +} + +static int query_formats(AVFilterContext *ctx) +{ + AVFilterFormats *formats; + AVFilterChannelLayouts *layouts; + static const enum AVSampleFormat sample_fmts[] = { + AV_SAMPLE_FMT_DBL, + AV_SAMPLE_FMT_NONE + }; + int ret; + + layouts = ff_all_channel_counts(); + if (!layouts) + return AVERROR(ENOMEM); + ret = ff_set_common_channel_layouts(ctx, layouts); + if (ret < 0) + return ret; + + formats = ff_make_format_list(sample_fmts); + if (!formats) + return AVERROR(ENOMEM); + ret = ff_set_common_formats(ctx, formats); + if (ret < 0) + return ret; + + formats = ff_all_samplerates(); + if (!formats) + return AVERROR(ENOMEM); + return ff_set_common_samplerates(ctx, formats); +} + +static av_cold void uninit(AVFilterContext *ctx) +{ + Ebur128Context *s = ctx->priv; + + if (!s->ebur128) + goto end; + + if (s->print_format != NONE) + write_strings(s); + + switch(s->print_format) { + case NONE: + break; + + case JSON: + av_log(ctx, AV_LOG_INFO, "\n{\n" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "\n}\n", + s->integrated ? "\t\"integrated\" : " : "", + s->integrated ? s->strings.integrated : "", + s->integrated && (s->threshold || s->lra || s->sample_peak || s->true_peak) ? ",\n" : "", + s->threshold ? "\t\"threshold\" : " : "", + s->threshold ? s->strings.threshold : "", + s->threshold && (s->lra || s->sample_peak || s->true_peak) ? ",\n" : "", + s->lra ? "\t\"lra\" : " : "", + s->lra ? s->strings.lra : "", + s->lra && (s->sample_peak || s->true_peak) ? ",\n" : "", + s->sample_peak ? "\t\"max_sample_peak\" : " : "", + s->sample_peak ? s->strings.max_sample_peak : "", + s->sample_peak && s->true_peak ? ",\n" : "", + s->true_peak ? "\t\"max_true_peak\" : " : "", + s->true_peak ? s->strings.max_true_peak : "" + ); + break; + + case SUMMARY: + av_log(ctx, AV_LOG_INFO, "\n" + "Summary:\n\n" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s" + "%s", + s->integrated ? "I: " : "", + s->integrated ? s->strings.integrated : "", + s->integrated ? " LUFS\n" : "", + s->threshold ? "Threshold: " : "", + s->threshold ? s->strings.threshold : "", + s->threshold ? " LUFS\n" : "", + s->lra ? "LRA: " : "", + s->lra ? s->strings.lra : "", + s->lra ? " LU\n" : "", + s->sample_peak ? "Max Sample Peak: " : "", + s->sample_peak ? s->strings.max_sample_peak : "", + s->sample_peak ? " dBFS\n" : "", + s->true_peak ? "Max True Peak: " : "", + s->true_peak ? s->strings.max_true_peak : "", + s->true_peak ? " dBTP\n" : "" + ); + break; + } + +end: + if (s->ebur128) + ff_ebur128_destroy(&s->ebur128); +} + +static int config_input(AVFilterLink *inlink) +{ + AVFilterContext *ctx = inlink->dst; + Ebur128Context *s = ctx->priv; + int mode = 0; + + s->channels = inlink->channels; + + if (s->momentary) + mode |= FF_EBUR128_MODE_M; + if (s->short_term) + mode |= FF_EBUR128_MODE_S; + if (s->integrated || s->threshold) + mode |= FF_EBUR128_MODE_I; + if (s->lra) + mode |= FF_EBUR128_MODE_LRA; + if (s->sample_peak) + mode |= FF_EBUR128_MODE_SAMPLE_PEAK; + if (s->true_peak) + mode |= FF_EBUR128_MODE_TRUE_PEAK; + + if (mode == 0) { + av_log(ctx, AV_LOG_ERROR, "Operation not supported. Specify at least one measurement mode.\n"); + return AVERROR(ENOSYS); + } + + s->ebur128 = ff_ebur128_init(inlink->channels, inlink->sample_rate, 0, mode); + if (!s->ebur128) + return AVERROR(ENOMEM); + + if (inlink->channels == 1 && s->dual_mono) + ff_ebur128_set_channel(s->ebur128, 0, FF_EBUR128_DUAL_MONO); + + if (s->metadata || s->framelog) + inlink->min_samples = + inlink->max_samples = + inlink->partial_buf_size = inlink->sample_rate / 10; + + return 0; +} + +static const AVFilterPad avfilter_af_ebur128_inputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_AUDIO, + .config_props = config_input, + .filter_frame = filter_frame, + }, + { NULL } +}; + +static const AVFilterPad avfilter_af_ebur128_outputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_AUDIO, + }, + { NULL } +}; + +AVFilter ff_af_ebur128 = { + .name = "ebur128", + .description = NULL_IF_CONFIG_SMALL("EBU R128 loudness metering."), + .priv_size = sizeof(Ebur128Context), + .priv_class = &ebur128_class, + .uninit = uninit, + .query_formats = query_formats, + .inputs = avfilter_af_ebur128_inputs, + .outputs = avfilter_af_ebur128_outputs, +}; diff --git a/libavfilter/f_ebur128.c b/libavfilter/f_ebur128.c deleted file mode 100644 index 983c889..0000000 --- a/libavfilter/f_ebur128.c +++ /dev/null @@ -1,950 +0,0 @@ -/* - * Copyright (c) 2012 Clément Bœsch - * - * This file is part of FFmpeg. - * - * FFmpeg is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * FFmpeg is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with FFmpeg; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. - */ - -/** - * @file - * EBU R.128 implementation - * @see http://tech.ebu.ch/loudness - * @see https://www.youtube.com/watch?v=iuEtQqC-Sqo "EBU R128 Introduction - Florian Camerer" - * @todo implement start/stop/reset through filter command injection - * @todo support other frequencies to avoid resampling - */ - -#include - -#include "libavutil/avassert.h" -#include "libavutil/avstring.h" -#include "libavutil/channel_layout.h" -#include "libavutil/dict.h" -#include "libavutil/ffmath.h" -#include "libavutil/xga_font_data.h" -#include "libavutil/opt.h" -#include "libavutil/timestamp.h" -#include "libswresample/swresample.h" -#include "audio.h" -#include "avfilter.h" -#include "formats.h" -#include "internal.h" - -#define MAX_CHANNELS 63 - -/* pre-filter coefficients */ -#define PRE_B0 1.53512485958697 -#define PRE_B1 -2.69169618940638 -#define PRE_B2 1.19839281085285 -#define PRE_A1 -1.69065929318241 -#define PRE_A2 0.73248077421585 - -/* RLB-filter coefficients */ -#define RLB_B0 1.0 -#define RLB_B1 -2.0 -#define RLB_B2 1.0 -#define RLB_A1 -1.99004745483398 -#define RLB_A2 0.99007225036621 - -#define ABS_THRES -70 ///< silence gate: we discard anything below this absolute (LUFS) threshold -#define ABS_UP_THRES 10 ///< upper loud limit to consider (ABS_THRES being the minimum) -#define HIST_GRAIN 100 ///< defines histogram precision -#define HIST_SIZE ((ABS_UP_THRES - ABS_THRES) * HIST_GRAIN + 1) - -/** - * A histogram is an array of HIST_SIZE hist_entry storing all the energies - * recorded (with an accuracy of 1/HIST_GRAIN) of the loudnesses from ABS_THRES - * (at 0) to ABS_UP_THRES (at HIST_SIZE-1). - * This fixed-size system avoids the need of a list of energies growing - * infinitely over the time and is thus more scalable. - */ -struct hist_entry { - int count; ///< how many times the corresponding value occurred - double energy; ///< E = 10^((L + 0.691) / 10) - double loudness; ///< L = -0.691 + 10 * log10(E) -}; - -struct integrator { - double *cache[MAX_CHANNELS]; ///< window of filtered samples (N ms) - int cache_pos; ///< focus on the last added bin in the cache array - double sum[MAX_CHANNELS]; ///< sum of the last N ms filtered samples (cache content) - int filled; ///< 1 if the cache is completely filled, 0 otherwise - double rel_threshold; ///< relative threshold - double sum_kept_powers; ///< sum of the powers (weighted sums) above absolute threshold - int nb_kept_powers; ///< number of sum above absolute threshold - struct hist_entry *histogram; ///< histogram of the powers, used to compute LRA and I -}; - -struct rect { int x, y, w, h; }; - -typedef struct { - const AVClass *class; ///< AVClass context for log and options purpose - - /* peak metering */ - int peak_mode; ///< enabled peak modes - double *true_peaks; ///< true peaks per channel - double *sample_peaks; ///< sample peaks per channel - double *true_peaks_per_frame; ///< true peaks in a frame per channel -#if CONFIG_SWRESAMPLE - SwrContext *swr_ctx; ///< over-sampling context for true peak metering - double *swr_buf; ///< resampled audio data for true peak metering - int swr_linesize; -#endif - - /* video */ - int do_video; ///< 1 if video output enabled, 0 otherwise - int w, h; ///< size of the video output - struct rect text; ///< rectangle for the LU legend on the left - struct rect graph; ///< rectangle for the main graph in the center - struct rect gauge; ///< rectangle for the gauge on the right - AVFrame *outpicref; ///< output picture reference, updated regularly - int meter; ///< select a EBU mode between +9 and +18 - int scale_range; ///< the range of LU values according to the meter - int y_zero_lu; ///< the y value (pixel position) for 0 LU - int *y_line_ref; ///< y reference values for drawing the LU lines in the graph and the gauge - - /* audio */ - int nb_channels; ///< number of channels in the input - double *ch_weighting; ///< channel weighting mapping - int sample_count; ///< sample count used for refresh frequency, reset at refresh - - /* Filter caches. - * The mult by 3 in the following is for X[i], X[i-1] and X[i-2] */ - double x[MAX_CHANNELS * 3]; ///< 3 input samples cache for each channel - double y[MAX_CHANNELS * 3]; ///< 3 pre-filter samples cache for each channel - double z[MAX_CHANNELS * 3]; ///< 3 RLB-filter samples cache for each channel - -#define I400_BINS (48000 * 4 / 10) -#define I3000_BINS (48000 * 3) - struct integrator i400; ///< 400ms integrator, used for Momentary loudness (M), and Integrated loudness (I) - struct integrator i3000; ///< 3s integrator, used for Short term loudness (S), and Loudness Range (LRA) - - /* I and LRA specific */ - double integrated_loudness; ///< integrated loudness in LUFS (I) - double loudness_range; ///< loudness range in LU (LRA) - double lra_low, lra_high; ///< low and high LRA values - - /* misc */ - int loglevel; ///< log level for frame logging - int metadata; ///< whether or not to inject loudness results in frames - int dual_mono; ///< whether or not to treat single channel input files as dual-mono - double pan_law; ///< pan law value used to calculate dual-mono measurements -} EBUR128Context; - -enum { - PEAK_MODE_NONE = 0, - PEAK_MODE_SAMPLES_PEAKS = 1<<1, - PEAK_MODE_TRUE_PEAKS = 1<<2, -}; - -#define OFFSET(x) offsetof(EBUR128Context, x) -#define A AV_OPT_FLAG_AUDIO_PARAM -#define V AV_OPT_FLAG_VIDEO_PARAM -#define F AV_OPT_FLAG_FILTERING_PARAM -static const AVOption ebur128_options[] = { - { "video", "set video output", OFFSET(do_video), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, V|F }, - { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "640x480"}, 0, 0, V|F }, - { "meter", "set scale meter (+9 to +18)", OFFSET(meter), AV_OPT_TYPE_INT, {.i64 = 9}, 9, 18, V|F }, - { "framelog", "force frame logging level", OFFSET(loglevel), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, A|V|F, "level" }, - { "info", "information logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_INFO}, INT_MIN, INT_MAX, A|V|F, "level" }, - { "verbose", "verbose logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_VERBOSE}, INT_MIN, INT_MAX, A|V|F, "level" }, - { "metadata", "inject metadata in the filtergraph", OFFSET(metadata), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, A|V|F }, - { "peak", "set peak mode", OFFSET(peak_mode), AV_OPT_TYPE_FLAGS, {.i64 = PEAK_MODE_NONE}, 0, INT_MAX, A|F, "mode" }, - { "none", "disable any peak mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_NONE}, INT_MIN, INT_MAX, A|F, "mode" }, - { "sample", "enable peak-sample mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_SAMPLES_PEAKS}, INT_MIN, INT_MAX, A|F, "mode" }, - { "true", "enable true-peak mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_TRUE_PEAKS}, INT_MIN, INT_MAX, A|F, "mode" }, - { "dualmono", "treat mono input files as dual-mono", OFFSET(dual_mono), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, A|F }, - { "panlaw", "set a specific pan law for dual-mono files", OFFSET(pan_law), AV_OPT_TYPE_DOUBLE, {.dbl = -3.01029995663978}, -10.0, 0.0, A|F }, - { NULL }, -}; - -AVFILTER_DEFINE_CLASS(ebur128); - -static const uint8_t graph_colors[] = { - 0xdd, 0x66, 0x66, // value above 0LU non reached - 0x66, 0x66, 0xdd, // value below 0LU non reached - 0x96, 0x33, 0x33, // value above 0LU reached - 0x33, 0x33, 0x96, // value below 0LU reached - 0xdd, 0x96, 0x96, // value above 0LU line non reached - 0x96, 0x96, 0xdd, // value below 0LU line non reached - 0xdd, 0x33, 0x33, // value above 0LU line reached - 0x33, 0x33, 0xdd, // value below 0LU line reached -}; - -static const uint8_t *get_graph_color(const EBUR128Context *ebur128, int v, int y) -{ - const int below0 = y > ebur128->y_zero_lu; - const int reached = y >= v; - const int line = ebur128->y_line_ref[y] || y == ebur128->y_zero_lu; - const int colorid = 4*line + 2*reached + below0; - return graph_colors + 3*colorid; -} - -static inline int lu_to_y(const EBUR128Context *ebur128, double v) -{ - v += 2 * ebur128->meter; // make it in range [0;...] - v = av_clipf(v, 0, ebur128->scale_range); // make sure it's in the graph scale - v = ebur128->scale_range - v; // invert value (y=0 is on top) - return v * ebur128->graph.h / ebur128->scale_range; // rescale from scale range to px height -} - -#define FONT8 0 -#define FONT16 1 - -static const uint8_t font_colors[] = { - 0xdd, 0xdd, 0x00, - 0x00, 0x96, 0x96, -}; - -static void drawtext(AVFrame *pic, int x, int y, int ftid, const uint8_t *color, const char *fmt, ...) -{ - int i; - char buf[128] = {0}; - const uint8_t *font; - int font_height; - va_list vl; - - if (ftid == FONT16) font = avpriv_vga16_font, font_height = 16; - else if (ftid == FONT8) font = avpriv_cga_font, font_height = 8; - else return; - - va_start(vl, fmt); - vsnprintf(buf, sizeof(buf), fmt, vl); - va_end(vl); - - for (i = 0; buf[i]; i++) { - int char_y, mask; - uint8_t *p = pic->data[0] + y*pic->linesize[0] + (x + i*8)*3; - - for (char_y = 0; char_y < font_height; char_y++) { - for (mask = 0x80; mask; mask >>= 1) { - if (font[buf[i] * font_height + char_y] & mask) - memcpy(p, color, 3); - else - memcpy(p, "\x00\x00\x00", 3); - p += 3; - } - p += pic->linesize[0] - 8*3; - } - } -} - -static void drawline(AVFrame *pic, int x, int y, int len, int step) -{ - int i; - uint8_t *p = pic->data[0] + y*pic->linesize[0] + x*3; - - for (i = 0; i < len; i++) { - memcpy(p, "\x00\xff\x00", 3); - p += step; - } -} - -static int config_video_output(AVFilterLink *outlink) -{ - int i, x, y; - uint8_t *p; - AVFilterContext *ctx = outlink->src; - EBUR128Context *ebur128 = ctx->priv; - AVFrame *outpicref; - - /* check if there is enough space to represent everything decently */ - if (ebur128->w < 640 || ebur128->h < 480) { - av_log(ctx, AV_LOG_ERROR, "Video size %dx%d is too small, " - "minimum size is 640x480\n", ebur128->w, ebur128->h); - return AVERROR(EINVAL); - } - outlink->w = ebur128->w; - outlink->h = ebur128->h; - -#define PAD 8 - - /* configure text area position and size */ - ebur128->text.x = PAD; - ebur128->text.y = 40; - ebur128->text.w = 3 * 8; // 3 characters - ebur128->text.h = ebur128->h - PAD - ebur128->text.y; - - /* configure gauge position and size */ - ebur128->gauge.w = 20; - ebur128->gauge.h = ebur128->text.h; - ebur128->gauge.x = ebur128->w - PAD - ebur128->gauge.w; - ebur128->gauge.y = ebur128->text.y; - - /* configure graph position and size */ - ebur128->graph.x = ebur128->text.x + ebur128->text.w + PAD; - ebur128->graph.y = ebur128->gauge.y; - ebur128->graph.w = ebur128->gauge.x - ebur128->graph.x - PAD; - ebur128->graph.h = ebur128->gauge.h; - - /* graph and gauge share the LU-to-pixel code */ - av_assert0(ebur128->graph.h == ebur128->gauge.h); - - /* prepare the initial picref buffer */ - av_frame_free(&ebur128->outpicref); - ebur128->outpicref = outpicref = - ff_get_video_buffer(outlink, outlink->w, outlink->h); - if (!outpicref) - return AVERROR(ENOMEM); - outlink->sample_aspect_ratio = (AVRational){1,1}; - - /* init y references values (to draw LU lines) */ - ebur128->y_line_ref = av_calloc(ebur128->graph.h + 1, sizeof(*ebur128->y_line_ref)); - if (!ebur128->y_line_ref) - return AVERROR(ENOMEM); - - /* black background */ - memset(outpicref->data[0], 0, ebur128->h * outpicref->linesize[0]); - - /* draw LU legends */ - drawtext(outpicref, PAD, PAD+16, FONT8, font_colors+3, " LU"); - for (i = ebur128->meter; i >= -ebur128->meter * 2; i--) { - y = lu_to_y(ebur128, i); - x = PAD + (i < 10 && i > -10) * 8; - ebur128->y_line_ref[y] = i; - y -= 4; // -4 to center vertically - drawtext(outpicref, x, y + ebur128->graph.y, FONT8, font_colors+3, - "%c%d", i < 0 ? '-' : i > 0 ? '+' : ' ', FFABS(i)); - } - - /* draw graph */ - ebur128->y_zero_lu = lu_to_y(ebur128, 0); - p = outpicref->data[0] + ebur128->graph.y * outpicref->linesize[0] - + ebur128->graph.x * 3; - for (y = 0; y < ebur128->graph.h; y++) { - const uint8_t *c = get_graph_color(ebur128, INT_MAX, y); - - for (x = 0; x < ebur128->graph.w; x++) - memcpy(p + x*3, c, 3); - p += outpicref->linesize[0]; - } - - /* draw fancy rectangles around the graph and the gauge */ -#define DRAW_RECT(r) do { \ - drawline(outpicref, r.x, r.y - 1, r.w, 3); \ - drawline(outpicref, r.x, r.y + r.h, r.w, 3); \ - drawline(outpicref, r.x - 1, r.y, r.h, outpicref->linesize[0]); \ - drawline(outpicref, r.x + r.w, r.y, r.h, outpicref->linesize[0]); \ -} while (0) - DRAW_RECT(ebur128->graph); - DRAW_RECT(ebur128->gauge); - - return 0; -} - -static int config_audio_input(AVFilterLink *inlink) -{ - AVFilterContext *ctx = inlink->dst; - EBUR128Context *ebur128 = ctx->priv; - - /* Force 100ms framing in case of metadata injection: the frames must have - * a granularity of the window overlap to be accurately exploited. - * As for the true peaks mode, it just simplifies the resampling buffer - * allocation and the lookup in it (since sample buffers differ in size, it - * can be more complex to integrate in the one-sample loop of - * filter_frame()). */ - if (ebur128->metadata || (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS)) - inlink->min_samples = - inlink->max_samples = - inlink->partial_buf_size = inlink->sample_rate / 10; - return 0; -} - -static int config_audio_output(AVFilterLink *outlink) -{ - int i; - AVFilterContext *ctx = outlink->src; - EBUR128Context *ebur128 = ctx->priv; - const int nb_channels = av_get_channel_layout_nb_channels(outlink->channel_layout); - -#define BACK_MASK (AV_CH_BACK_LEFT |AV_CH_BACK_CENTER |AV_CH_BACK_RIGHT| \ - AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_CENTER|AV_CH_TOP_BACK_RIGHT| \ - AV_CH_SIDE_LEFT |AV_CH_SIDE_RIGHT| \ - AV_CH_SURROUND_DIRECT_LEFT |AV_CH_SURROUND_DIRECT_RIGHT) - - ebur128->nb_channels = nb_channels; - ebur128->ch_weighting = av_calloc(nb_channels, sizeof(*ebur128->ch_weighting)); - if (!ebur128->ch_weighting) - return AVERROR(ENOMEM); - - for (i = 0; i < nb_channels; i++) { - /* channel weighting */ - const uint16_t chl = av_channel_layout_extract_channel(outlink->channel_layout, i); - if (chl & (AV_CH_LOW_FREQUENCY|AV_CH_LOW_FREQUENCY_2)) { - ebur128->ch_weighting[i] = 0; - } else if (chl & BACK_MASK) { - ebur128->ch_weighting[i] = 1.41; - } else { - ebur128->ch_weighting[i] = 1.0; - } - - if (!ebur128->ch_weighting[i]) - continue; - - /* bins buffer for the two integration window (400ms and 3s) */ - ebur128->i400.cache[i] = av_calloc(I400_BINS, sizeof(*ebur128->i400.cache[0])); - ebur128->i3000.cache[i] = av_calloc(I3000_BINS, sizeof(*ebur128->i3000.cache[0])); - if (!ebur128->i400.cache[i] || !ebur128->i3000.cache[i]) - return AVERROR(ENOMEM); - } - -#if CONFIG_SWRESAMPLE - if (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS) { - int ret; - - ebur128->swr_buf = av_malloc_array(nb_channels, 19200 * sizeof(double)); - ebur128->true_peaks = av_calloc(nb_channels, sizeof(*ebur128->true_peaks)); - ebur128->true_peaks_per_frame = av_calloc(nb_channels, sizeof(*ebur128->true_peaks_per_frame)); - ebur128->swr_ctx = swr_alloc(); - if (!ebur128->swr_buf || !ebur128->true_peaks || - !ebur128->true_peaks_per_frame || !ebur128->swr_ctx) - return AVERROR(ENOMEM); - - av_opt_set_int(ebur128->swr_ctx, "in_channel_layout", outlink->channel_layout, 0); - av_opt_set_int(ebur128->swr_ctx, "in_sample_rate", outlink->sample_rate, 0); - av_opt_set_sample_fmt(ebur128->swr_ctx, "in_sample_fmt", outlink->format, 0); - - av_opt_set_int(ebur128->swr_ctx, "out_channel_layout", outlink->channel_layout, 0); - av_opt_set_int(ebur128->swr_ctx, "out_sample_rate", 192000, 0); - av_opt_set_sample_fmt(ebur128->swr_ctx, "out_sample_fmt", outlink->format, 0); - - ret = swr_init(ebur128->swr_ctx); - if (ret < 0) - return ret; - } -#endif - - if (ebur128->peak_mode & PEAK_MODE_SAMPLES_PEAKS) { - ebur128->sample_peaks = av_calloc(nb_channels, sizeof(*ebur128->sample_peaks)); - if (!ebur128->sample_peaks) - return AVERROR(ENOMEM); - } - - return 0; -} - -#define ENERGY(loudness) (ff_exp10(((loudness) + 0.691) / 10.)) -#define LOUDNESS(energy) (-0.691 + 10 * log10(energy)) -#define DBFS(energy) (20 * log10(energy)) - -static struct hist_entry *get_histogram(void) -{ - int i; - struct hist_entry *h = av_calloc(HIST_SIZE, sizeof(*h)); - - if (!h) - return NULL; - for (i = 0; i < HIST_SIZE; i++) { - h[i].loudness = i / (double)HIST_GRAIN + ABS_THRES; - h[i].energy = ENERGY(h[i].loudness); - } - return h; -} - -static av_cold int init(AVFilterContext *ctx) -{ - EBUR128Context *ebur128 = ctx->priv; - AVFilterPad pad; - - if (ebur128->loglevel != AV_LOG_INFO && - ebur128->loglevel != AV_LOG_VERBOSE) { - if (ebur128->do_video || ebur128->metadata) - ebur128->loglevel = AV_LOG_VERBOSE; - else - ebur128->loglevel = AV_LOG_INFO; - } - - if (!CONFIG_SWRESAMPLE && (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS)) { - av_log(ctx, AV_LOG_ERROR, - "True-peak mode requires libswresample to be performed\n"); - return AVERROR(EINVAL); - } - - // if meter is +9 scale, scale range is from -18 LU to +9 LU (or 3*9) - // if meter is +18 scale, scale range is from -36 LU to +18 LU (or 3*18) - ebur128->scale_range = 3 * ebur128->meter; - - ebur128->i400.histogram = get_histogram(); - ebur128->i3000.histogram = get_histogram(); - if (!ebur128->i400.histogram || !ebur128->i3000.histogram) - return AVERROR(ENOMEM); - - ebur128->integrated_loudness = ABS_THRES; - ebur128->loudness_range = 0; - - /* insert output pads */ - if (ebur128->do_video) { - pad = (AVFilterPad){ - .name = av_strdup("out0"), - .type = AVMEDIA_TYPE_VIDEO, - .config_props = config_video_output, - }; - if (!pad.name) - return AVERROR(ENOMEM); - ff_insert_outpad(ctx, 0, &pad); - } - pad = (AVFilterPad){ - .name = av_asprintf("out%d", ebur128->do_video), - .type = AVMEDIA_TYPE_AUDIO, - .config_props = config_audio_output, - }; - if (!pad.name) - return AVERROR(ENOMEM); - ff_insert_outpad(ctx, ebur128->do_video, &pad); - - /* summary */ - av_log(ctx, AV_LOG_VERBOSE, "EBU +%d scale\n", ebur128->meter); - - return 0; -} - -#define HIST_POS(power) (int)(((power) - ABS_THRES) * HIST_GRAIN) - -/* loudness and power should be set such as loudness = -0.691 + - * 10*log10(power), we just avoid doing that calculus two times */ -static int gate_update(struct integrator *integ, double power, - double loudness, int gate_thres) -{ - int ipower; - double relative_threshold; - int gate_hist_pos; - - /* update powers histograms by incrementing current power count */ - ipower = av_clip(HIST_POS(loudness), 0, HIST_SIZE - 1); - integ->histogram[ipower].count++; - - /* compute relative threshold and get its position in the histogram */ - integ->sum_kept_powers += power; - integ->nb_kept_powers++; - relative_threshold = integ->sum_kept_powers / integ->nb_kept_powers; - if (!relative_threshold) - relative_threshold = 1e-12; - integ->rel_threshold = LOUDNESS(relative_threshold) + gate_thres; - gate_hist_pos = av_clip(HIST_POS(integ->rel_threshold), 0, HIST_SIZE - 1); - - return gate_hist_pos; -} - -static int filter_frame(AVFilterLink *inlink, AVFrame *insamples) -{ - int i, ch, idx_insample; - AVFilterContext *ctx = inlink->dst; - EBUR128Context *ebur128 = ctx->priv; - const int nb_channels = ebur128->nb_channels; - const int nb_samples = insamples->nb_samples; - const double *samples = (double *)insamples->data[0]; - AVFrame *pic = ebur128->outpicref; - -#if CONFIG_SWRESAMPLE - if (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS) { - const double *swr_samples = ebur128->swr_buf; - int ret = swr_convert(ebur128->swr_ctx, (uint8_t**)&ebur128->swr_buf, 19200, - (const uint8_t **)insamples->data, nb_samples); - if (ret < 0) - return ret; - for (ch = 0; ch < nb_channels; ch++) - ebur128->true_peaks_per_frame[ch] = 0.0; - for (idx_insample = 0; idx_insample < ret; idx_insample++) { - for (ch = 0; ch < nb_channels; ch++) { - ebur128->true_peaks[ch] = FFMAX(ebur128->true_peaks[ch], fabs(*swr_samples)); - ebur128->true_peaks_per_frame[ch] = FFMAX(ebur128->true_peaks_per_frame[ch], - fabs(*swr_samples)); - swr_samples++; - } - } - } -#endif - - for (idx_insample = 0; idx_insample < nb_samples; idx_insample++) { - const int bin_id_400 = ebur128->i400.cache_pos; - const int bin_id_3000 = ebur128->i3000.cache_pos; - -#define MOVE_TO_NEXT_CACHED_ENTRY(time) do { \ - ebur128->i##time.cache_pos++; \ - if (ebur128->i##time.cache_pos == I##time##_BINS) { \ - ebur128->i##time.filled = 1; \ - ebur128->i##time.cache_pos = 0; \ - } \ -} while (0) - - MOVE_TO_NEXT_CACHED_ENTRY(400); - MOVE_TO_NEXT_CACHED_ENTRY(3000); - - for (ch = 0; ch < nb_channels; ch++) { - double bin; - - if (ebur128->peak_mode & PEAK_MODE_SAMPLES_PEAKS) - ebur128->sample_peaks[ch] = FFMAX(ebur128->sample_peaks[ch], fabs(*samples)); - - ebur128->x[ch * 3] = *samples++; // set X[i] - - if (!ebur128->ch_weighting[ch]) - continue; - - /* Y[i] = X[i]*b0 + X[i-1]*b1 + X[i-2]*b2 - Y[i-1]*a1 - Y[i-2]*a2 */ -#define FILTER(Y, X, name) do { \ - double *dst = ebur128->Y + ch*3; \ - double *src = ebur128->X + ch*3; \ - dst[2] = dst[1]; \ - dst[1] = dst[0]; \ - dst[0] = src[0]*name##_B0 + src[1]*name##_B1 + src[2]*name##_B2 \ - - dst[1]*name##_A1 - dst[2]*name##_A2; \ -} while (0) - - // TODO: merge both filters in one? - FILTER(y, x, PRE); // apply pre-filter - ebur128->x[ch * 3 + 2] = ebur128->x[ch * 3 + 1]; - ebur128->x[ch * 3 + 1] = ebur128->x[ch * 3 ]; - FILTER(z, y, RLB); // apply RLB-filter - - bin = ebur128->z[ch * 3] * ebur128->z[ch * 3]; - - /* add the new value, and limit the sum to the cache size (400ms or 3s) - * by removing the oldest one */ - ebur128->i400.sum [ch] = ebur128->i400.sum [ch] + bin - ebur128->i400.cache [ch][bin_id_400]; - ebur128->i3000.sum[ch] = ebur128->i3000.sum[ch] + bin - ebur128->i3000.cache[ch][bin_id_3000]; - - /* override old cache entry with the new value */ - ebur128->i400.cache [ch][bin_id_400 ] = bin; - ebur128->i3000.cache[ch][bin_id_3000] = bin; - } - - /* For integrated loudness, gating blocks are 400ms long with 75% - * overlap (see BS.1770-2 p5), so a re-computation is needed each 100ms - * (4800 samples at 48kHz). */ - if (++ebur128->sample_count == 4800) { - double loudness_400, loudness_3000; - double power_400 = 1e-12, power_3000 = 1e-12; - AVFilterLink *outlink = ctx->outputs[0]; - const int64_t pts = insamples->pts + - av_rescale_q(idx_insample, (AVRational){ 1, inlink->sample_rate }, - outlink->time_base); - - ebur128->sample_count = 0; - -#define COMPUTE_LOUDNESS(m, time) do { \ - if (ebur128->i##time.filled) { \ - /* weighting sum of the last