From 005d058f4230f3207ebcf1131df7426d4f57392f Mon Sep 17 00:00:00 2001 From: Marton Balint Date: Sat, 15 Oct 2016 19:21:22 +0200 Subject: lavfi/loudnorm: add an internal libebur128 library Also contains the following changes to the library: - add ff_ prefix to functions - remove cplusplus defines. - add FF_ prefix to contants and some structs - remove true peak calculation feature, since it uses its own resampler, and af_loudnorm does not need it. - remove version info and some fprintf(stderr) functions - convert to use av_malloc - always use histogram mode for LRA calculation, otherwise LRA data is slowly consuming memory making af_loudnorm unfit for 24/7 operation. It also uses a BSD style linked list implementation which is probably not available on all platforms. So let's just remove the classic mode which not uses histogram. - add ff_thread_once for calculating static histogram tables - convert some functions to void which cannot fail - remove intrinsics and some unused headers - add support for planar audio - remove channel / sample rate changer function, in ffmpeg usually we simply alloc a new context - convert some static variables to defines - declare static histogram variables as aligned - convert some initalizations to mallocz - add window size parameter to init function and remove window size setter function - convert return codes to AVERROR - fix indentation Signed-off-by: Marton Balint --- libavfilter/ebur128.h | 296 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 296 insertions(+) create mode 100644 libavfilter/ebur128.h (limited to 'libavfilter/ebur128.h') diff --git a/libavfilter/ebur128.h b/libavfilter/ebur128.h new file mode 100644 index 0000000000..c39c80d6ec --- /dev/null +++ b/libavfilter/ebur128.h @@ -0,0 +1,296 @@ +/* + * Copyright (c) 2011 Jan Kokemüller + * + * 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 + * + * This file is based on libebur128 which is available at + * https://github.com/jiixyj/libebur128/ + * +*/ + +#ifndef AVFILTER_EBUR128_H +#define AVFILTER_EBUR128_H + +/** \file ebur128.h + * \brief libebur128 - a library for loudness measurement according to + * the EBU R128 standard. + */ + +#include /* for size_t */ + +/** \enum channel + * Use these values when setting the channel map with ebur128_set_channel(). + * See definitions in ITU R-REC-BS 1770-4 + */ +enum channel { + FF_EBUR128_UNUSED = 0, /**< unused channel (for example LFE channel) */ + FF_EBUR128_LEFT, + FF_EBUR128_Mp030 = 1, /**< itu M+030 */ + FF_EBUR128_RIGHT, + FF_EBUR128_Mm030 = 2, /**< itu M-030 */ + FF_EBUR128_CENTER, + FF_EBUR128_Mp000 = 3, /**< itu M+000 */ + FF_EBUR128_LEFT_SURROUND, + FF_EBUR128_Mp110 = 4, /**< itu M+110 */ + FF_EBUR128_RIGHT_SURROUND, + FF_EBUR128_Mm110 = 5, /**< itu M-110 */ + FF_EBUR128_DUAL_MONO, /**< a channel that is counted twice */ + FF_EBUR128_MpSC, /**< itu M+SC */ + FF_EBUR128_MmSC, /**< itu M-SC */ + FF_EBUR128_Mp060, /**< itu M+060 */ + FF_EBUR128_Mm060, /**< itu M-060 */ + FF_EBUR128_Mp090, /**< itu M+090 */ + FF_EBUR128_Mm090, /**< itu M-090 */ + FF_EBUR128_Mp135, /**< itu M+135 */ + FF_EBUR128_Mm135, /**< itu M-135 */ + FF_EBUR128_Mp180, /**< itu M+180 */ + FF_EBUR128_Up000, /**< itu U+000 */ + FF_EBUR128_Up030, /**< itu U+030 */ + FF_EBUR128_Um030, /**< itu U-030 */ + FF_EBUR128_Up045, /**< itu U+045 */ + FF_EBUR128_Um045, /**< itu U-030 */ + FF_EBUR128_Up090, /**< itu U+090 */ + FF_EBUR128_Um090, /**< itu U-090 */ + FF_EBUR128_Up110, /**< itu U+110 */ + FF_EBUR128_Um110, /**< itu U-110 */ + FF_EBUR128_Up135, /**< itu U+135 */ + FF_EBUR128_Um135, /**< itu U-135 */ + FF_EBUR128_Up180, /**< itu U+180 */ + FF_EBUR128_Tp000, /**< itu T+000 */ + FF_EBUR128_Bp000, /**< itu B+000 */ + FF_EBUR128_Bp045, /**< itu B+045 */ + FF_EBUR128_Bm045 /**< itu B-045 */ +}; + +/** \enum mode + * Use these values in ebur128_init (or'ed). Try to use the lowest possible + * modes that suit your needs, as performance will be better. + */ +enum mode { + /** can call ebur128_loudness_momentary */ + FF_EBUR128_MODE_M = (1 << 0), + /** can call ebur128_loudness_shortterm */ + FF_EBUR128_MODE_S = (1 << 1) | FF_EBUR128_MODE_M, + /** can call ebur128_loudness_global_* and ebur128_relative_threshold */ + FF_EBUR128_MODE_I = (1 << 2) | FF_EBUR128_MODE_M, + /** can call ebur128_loudness_range */ + FF_EBUR128_MODE_LRA = (1 << 3) | FF_EBUR128_MODE_S, + /** can call ebur128_sample_peak */ + FF_EBUR128_MODE_SAMPLE_PEAK = (1 << 4) | FF_EBUR128_MODE_M, +}; + +/** forward declaration of FFEBUR128StateInternal */ +struct FFEBUR128StateInternal; + +/** \brief Contains information about the state of a loudness measurement. + * + * You should not need to modify this struct directly. + */ +typedef struct { + int mode; /**< The current mode. */ + unsigned int channels; /**< The number of channels. */ + unsigned long samplerate; /**< The sample rate. */ + struct FFEBUR128StateInternal *d; /**< Internal state. */ +} FFEBUR128State; + +/** \brief Initialize library state. + * + * @param channels the number of channels. + * @param samplerate the sample rate. + * @param window set the maximum window size in ms, set to 0 for auto. + * @param mode see the mode enum for possible values. + * @return an initialized library state. + */ +FFEBUR128State *ff_ebur128_init(unsigned int channels, + unsigned long samplerate, + unsigned long window, int mode); + +/** \brief Destroy library state. + * + * @param st pointer to a library state. + */ +void ff_ebur128_destroy(FFEBUR128State ** st); + +/** \brief Set channel type. + * + * The default is: + * - 0 -> FF_EBUR128_LEFT + * - 1 -> FF_EBUR128_RIGHT + * - 2 -> FF_EBUR128_CENTER + * - 3 -> FF_EBUR128_UNUSED + * - 4 -> FF_EBUR128_LEFT_SURROUND + * - 5 -> FF_EBUR128_RIGHT_SURROUND + * + * @param st library state. + * @param channel_number zero based channel index. + * @param value channel type from the "channel" enum. + * @return + * - 0 on success. + * - AVERROR(EINVAL) if invalid channel index. + */ +int ff_ebur128_set_channel(FFEBUR128State * st, + unsigned int channel_number, int value); + +/** \brief Add frames to be processed. + * + * @param st library state. + * @param src array of source frames. Channels must be interleaved. + * @param frames number of frames. Not number of samples! + */ +void ff_ebur128_add_frames_short(FFEBUR128State * st, + const short *src, size_t frames); +/** \brief See \ref ebur128_add_frames_short */ +void ff_ebur128_add_frames_int(FFEBUR128State * st, + const int *src, size_t frames); +/** \brief See \ref ebur128_add_frames_short */ +void ff_ebur128_add_frames_float(FFEBUR128State * st, + const float *src, size_t frames); +/** \brief See \ref ebur128_add_frames_short */ +void ff_ebur128_add_frames_double(FFEBUR128State * st, + const double *src, size_t frames); + +/** \brief Add frames to be processed. + * + * @param st library state. + * @param srcs array of source frame channel data pointers + * @param frames number of frames. Not number of samples! + * @param stride number of samples to skip to for the next sample of the same channel + */ +void ff_ebur128_add_frames_planar_short(FFEBUR128State * st, + const short **srcs, + size_t frames, int stride); +/** \brief See \ref ebur128_add_frames_planar_short */ +void ff_ebur128_add_frames_planar_int(FFEBUR128State * st, + const int **srcs, + size_t frames, int stride); +/** \brief See \ref ebur128_add_frames_planar_short */ +void ff_ebur128_add_frames_planar_float(FFEBUR128State * st, + const float **srcs, + size_t frames, int stride); +/** \brief See \ref ebur128_add_frames_planar_short */ +void ff_ebur128_add_frames_planar_double(FFEBUR128State * st, + const double **srcs, + size_t frames, int stride); + +/** \brief Get global integrated loudness in LUFS. + * + * @param st library state. + * @param out integrated loudness in LUFS. -HUGE_VAL if result is negative + * infinity. + * @return + * - 0 on success. + * - AVERROR(EINVAL) if mode "FF_EBUR128_MODE_I" has not been set. + */ +int ff_ebur128_loudness_global(FFEBUR128State * st, double *out); +/** \brief Get global integrated loudness in LUFS across multiple instances. + * + * @param sts array of library states. + * @param size length of sts + * @param out integrated loudness in LUFS. -HUGE_VAL if result is negative + * infinity. + * @return + * - 0 on success. + * - AVERROR(EINVAL) if mode "FF_EBUR128_MODE_I" has not been set. + */ +int ff_ebur128_loudness_global_multiple(FFEBUR128State ** sts, + size_t size, double *out); + +/** \brief Get momentary loudness (last 400ms) in LUFS. + * + * @param st library state. + * @param out momentary loudness in LUFS. -HUGE_VAL if result is negative + * infinity. + * @return + * - 0 on success. + */ +int ff_ebur128_loudness_momentary(FFEBUR128State * st, double *out); +/** \brief Get short-term loudness (last 3s) in LUFS. + * + * @param st library state. + * @param out short-term loudness in LUFS. -HUGE_VAL if result is negative + * infinity. + * @return + * - 0 on success. + * - AVERROR(EINVAL) if mode "FF_EBUR128_MODE_S" has not been set. + */ +int ff_ebur128_loudness_shortterm(FFEBUR128State * st, double *out); + +/** \brief Get loudness of the specified window in LUFS. + * + * window must not be larger than the current window set in st. + * + * @param st library state. + * @param window window in ms to calculate loudness. + * @param out loudness in LUFS. -HUGE_VAL if result is negative infinity. + * @return + * - 0 on success. + * - AVERROR(EINVAL) if window larger than current window in st. + */ +int ff_ebur128_loudness_window(FFEBUR128State * st, + unsigned long window, double *out); + +/** \brief Get loudness range (LRA) of programme in LU. + * + * Calculates loudness range according to EBU 3342. + * + * @param st library state. + * @param out loudness range (LRA) in LU. Will not be changed in case of + * error. AVERROR(EINVAL) will be returned in this case. + * @return + * - 0 on success. + * - AVERROR(EINVAL) if mode "FF_EBUR128_MODE_LRA" has not been set. + */ +int ff_ebur128_loudness_range(FFEBUR128State * st, double *out); +/** \brief Get loudness range (LRA) in LU across multiple instances. + * + * Calculates loudness range according to EBU 3342. + * + * @param sts array of library states. + * @param size length of sts + * @param out loudness range (LRA) in LU. Will not be changed in case of + * error. AVERROR(EINVAL) will be returned in this case. + * @return + * - 0 on success. + * - AVERROR(EINVAL) if mode "FF_EBUR128_MODE_LRA" has not been set. + */ +int ff_ebur128_loudness_range_multiple(FFEBUR128State ** sts, + size_t size, double *out); + +/** \brief Get maximum sample peak of selected channel in float format. + * + * @param st library state + * @param channel_number channel to analyse + * @param out maximum sample peak in float format (1.0 is 0 dBFS) + * @return + * - 0 on success. + * - AVERROR(EINVAL) if mode "FF_EBUR128_MODE_SAMPLE_PEAK" has not been set. + * - AVERROR(EINVAL) if invalid channel index. + */ +int ff_ebur128_sample_peak(FFEBUR128State * st, + unsigned int channel_number, double *out); + +/** \brief Get relative threshold in LUFS. + * + * @param st library state + * @param out relative threshold in LUFS. + * @return + * - 0 on success. + * - AVERROR(EINVAL) if mode "FF_EBUR128_MODE_I" has not been set. + */ +int ff_ebur128_relative_threshold(FFEBUR128State * st, double *out); + +#endif /* AVFILTER_EBUR128_H */ -- cgit v1.2.3