46 #define MAX_CHANNELS 63
49 #define PRE_B0 1.53512485958697
50 #define PRE_B1 -2.69169618940638
51 #define PRE_B2 1.19839281085285
52 #define PRE_A1 -1.69065929318241
53 #define PRE_A2 0.73248077421585
59 #define RLB_A1 -1.99004745483398
60 #define RLB_A2 0.99007225036621
63 #define ABS_UP_THRES 10
64 #define HIST_GRAIN 100
65 #define HIST_SIZE ((ABS_UP_THRES - ABS_THRES) * HIST_GRAIN + 1)
101 #if CONFIG_SWRESAMPLE
132 #define I400_BINS (48000 * 4 / 10)
133 #define I3000_BINS (48000 * 3)
168 #define OFFSET(x) offsetof(EBUR128Context, x)
169 #define A AV_OPT_FLAG_AUDIO_PARAM
170 #define V AV_OPT_FLAG_VIDEO_PARAM
171 #define F AV_OPT_FLAG_FILTERING_PARAM
176 {
"framelog",
"force frame logging level",
OFFSET(loglevel),
AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX,
A|
V|
F,
"level" },
185 {
"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 },
186 {
"target",
"set a specific target level in LUFS (-23 to 0)",
OFFSET(target),
AV_OPT_TYPE_INT, {.i64 = -23}, -23, 0,
V|
F },
223 const int above_opt_max = y > ebur128->
y_opt_max;
224 const int below_opt_min = y < ebur128->
y_opt_min;
225 const int reached = y >= v;
227 const int colorid = 8*below_opt_min+ 4*
line + 2*reached + above_opt_max;
233 v += 2 * ebur128->
meter;
263 for (
i = 0; buf[
i];
i++) {
267 for (char_y = 0; char_y < font_height; char_y++) {
269 if (font[buf[
i] * font_height + char_y] &
mask)
272 memcpy(p,
"\x00\x00\x00", 3);
285 for (
i = 0;
i <
len;
i++) {
286 memcpy(p,
"\x00\xff\x00", 3);
300 if (ebur128->
w < 640 || ebur128->
h < 480) {
302 "minimum size is 640x480\n", ebur128->
w, ebur128->
h);
305 outlink->
w = ebur128->
w;
306 outlink->
h = ebur128->
h;
313 ebur128->
text.
y = 40;
314 ebur128->
text.
w = 3 * 8;
346 memset(outpicref->
data[0], 0, ebur128->
h * outpicref->
linesize[0]);
352 x =
PAD + (i < 10 && i > -10) * 8;
356 "%c%d", i < 0 ? '-' : i > 0 ?
'+' :
' ',
FFABS(
i));
365 for (y = 0; y < ebur128->
graph.
h; y++) {
368 for (x = 0; x < ebur128->
graph.
w; x++)
369 memcpy(p + x*3,
c, 3);
374 #define DRAW_RECT(r) do { \
375 drawline(outpicref, r.x, r.y - 1, r.w, 3); \
376 drawline(outpicref, r.x, r.y + r.h, r.w, 3); \
377 drawline(outpicref, r.x - 1, r.y, r.h, outpicref->linesize[0]); \
378 drawline(outpicref, r.x + r.w, r.y, r.h, outpicref->linesize[0]); \
411 #define BACK_MASK (AV_CH_BACK_LEFT |AV_CH_BACK_CENTER |AV_CH_BACK_RIGHT| \
412 AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_CENTER|AV_CH_TOP_BACK_RIGHT| \
413 AV_CH_SIDE_LEFT |AV_CH_SIDE_RIGHT| \
414 AV_CH_SURROUND_DIRECT_LEFT |AV_CH_SURROUND_DIRECT_RIGHT)
442 #if CONFIG_SWRESAMPLE
450 if (!ebur128->swr_buf || !ebur128->
true_peaks ||
477 #define ENERGY(loudness) (ff_exp10(((loudness) + 0.691) / 10.))
478 #define LOUDNESS(energy) (-0.691 + 10 * log10(energy))
479 #define DBFS(energy) (20 * log10(energy))
511 "True-peak mode requires libswresample to be performed\n");
553 #define HIST_POS(power) (int)(((power) - ABS_THRES) * HIST_GRAIN)
561 double relative_threshold;
572 if (!relative_threshold)
573 relative_threshold = 1e-12;
577 return gate_hist_pos;
582 int i, ch, idx_insample;
587 const double *samples = (
double *)insamples->
data[0];
592 const double *swr_samples = ebur128->swr_buf;
599 for (idx_insample = 0; idx_insample < ret; idx_insample++) {
610 for (idx_insample = 0; idx_insample < nb_samples; idx_insample++) {
614 #define MOVE_TO_NEXT_CACHED_ENTRY(time) do { \
615 ebur128->i##time.cache_pos++; \
616 if (ebur128->i##time.cache_pos == I##time##_BINS) { \
617 ebur128->i##time.filled = 1; \
618 ebur128->i##time.cache_pos = 0; \
631 ebur128->
x[ch * 3] = *samples++;
637 #define FILTER(Y, X, name) do { \
638 double *dst = ebur128->Y + ch*3; \
639 double *src = ebur128->X + ch*3; \
642 dst[0] = src[0]*name##_B0 + src[1]*name##_B1 + src[2]*name##_B2 \
643 - dst[1]*name##_A1 - dst[2]*name##_A2; \
648 ebur128->
x[ch * 3 + 2] = ebur128->
x[ch * 3 + 1];
649 ebur128->
x[ch * 3 + 1] = ebur128->
x[ch * 3 ];
652 bin = ebur128->
z[ch * 3] * ebur128->
z[ch * 3];
660 ebur128->
i400.
cache [ch][bin_id_400 ] = bin;
668 double loudness_400, loudness_3000;
669 double power_400 = 1e-12, power_3000 = 1e-12;
671 const int64_t
pts = insamples->
pts +
677 #define COMPUTE_LOUDNESS(m, time) do { \
678 if (ebur128->i##time.filled) { \
680 for (ch = 0; ch < nb_channels; ch++) \
681 power_##time += ebur128->ch_weighting[ch] * ebur128->i##time.sum[ch]; \
682 power_##time /= I##time##_BINS; \
684 loudness_##time = LOUDNESS(power_##time); \
691 #define I_GATE_THRES -10
694 double integrated_sum = 0;
695 int nb_integrated = 0;
703 nb_integrated += nb_v;
716 #define LRA_GATE_THRES -20
717 #define LRA_LOWER_PRC 10
718 #define LRA_HIGHER_PRC 95
761 loudness_400 -= ebur128->
pan_law;
762 loudness_3000 -= ebur128->
pan_law;
765 #define LOG_FMT "TARGET:%d LUFS M:%6.1f S:%6.1f I:%6.1f %s LRA:%6.1f LU"
773 int y_loudness_lu_graph, y_loudness_lu_gauge;
776 gauge_value = loudness_400 - ebur128->
target;
778 gauge_value = loudness_3000 - ebur128->
target;
781 y_loudness_lu_graph =
lu_to_y(ebur128, loudness_3000 - ebur128->
target);
782 y_loudness_lu_gauge =
lu_to_y(ebur128, gauge_value);
785 p = pic->data[0] + ebur128->
graph.
y*pic->linesize[0] + ebur128->
graph.
x*3;
786 for (y = 0; y < ebur128->
graph.
h; y++) {
789 memmove(p, p + 3, (ebur128->
graph.
w - 1) * 3);
790 memcpy(p + (ebur128->
graph.
w - 1) * 3,
c, 3);
791 p += pic->linesize[0];
795 p = pic->data[0] + ebur128->
gauge.
y*pic->linesize[0] + ebur128->
gauge.
x*3;
796 for (y = 0; y < ebur128->
gauge.
h; y++) {
799 for (x = 0; x < ebur128->
gauge.
w; x++)
800 memcpy(p + x*3,
c, 3);
801 p += pic->linesize[0];
808 ebur128->
target, loudness_400, loudness_3000,
829 #define META_PREFIX "lavfi.r128."
831 #define SET_META(name, var) do { \
832 snprintf(metabuf, sizeof(metabuf), "%.3f", var); \
833 av_dict_set(&insamples->metadata, name, metabuf, 0); \
836 #define SET_META_PEAK(name, ptype) do { \
837 if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \
839 for (ch = 0; ch < nb_channels; ch++) { \
840 snprintf(key, sizeof(key), \
841 META_PREFIX AV_STRINGIFY(name) "_peaks_ch%d", ch); \
842 SET_META(key, ebur128->name##_peaks[ch]); \
861 ebur128->
target, loudness_400, loudness_3000,
870 #define PRINT_PEAKS(str, sp, ptype) do { \
871 if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \
872 av_log(ctx, ebur128->loglevel, " " str ":"); \
873 for (ch = 0; ch < nb_channels; ch++) \
874 av_log(ctx, ebur128->loglevel, " %5.1f", DBFS(sp[ch])); \
875 av_log(ctx, ebur128->loglevel, " dBFS"); \
899 static const int input_srate[] = {48000, -1};
907 outlink =
ctx->outputs[1];
945 " Integrated loudness:\n"
947 " Threshold: %5.1f LUFS\n\n"
950 " Threshold: %5.1f LUFS\n"
951 " LRA low: %5.1f LUFS\n"
952 " LRA high: %5.1f LUFS",
957 #define PRINT_PEAK_SUMMARY(str, sp, ptype) do { \
961 if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \
962 for (ch = 0; ch < ebur128->nb_channels; ch++) \
963 maxpeak = FFMAX(maxpeak, sp[ch]); \
964 av_log(ctx, AV_LOG_INFO, "\n\n " str " peak:\n" \
965 " Peak: %5.1f dBFS", \
986 #if CONFIG_SWRESAMPLE
1011 .priv_class = &ebur128_class,
static enum AVSampleFormat sample_fmts[]
static const AVFilterPad inputs[]
static const AVFilterPad outputs[]
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Main libavfilter public API header.
#define flags(name, subs,...)
audio channel layout utility functions
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
#define CONFIG_SWRESAMPLE
static __device__ float fabs(float a)
#define FILTER(Y, X, name)
static int gate_update(struct integrator *integ, double power, double loudness, int gate_thres)
static void drawtext(AVFrame *pic, int x, int y, int ftid, const uint8_t *color, const char *fmt,...)
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
static const uint8_t graph_colors[]
#define SET_META_PEAK(name, ptype)
static void drawline(AVFrame *pic, int x, int y, int len, int step)
static const uint8_t font_colors[]
static const AVFilterPad ebur128_inputs[]
#define PRINT_PEAK_SUMMARY(str, sp, ptype)
@ PEAK_MODE_SAMPLES_PEAKS
static int config_audio_output(AVFilterLink *outlink)
static int query_formats(AVFilterContext *ctx)
static struct hist_entry * get_histogram(void)
static const AVOption ebur128_options[]
#define COMPUTE_LOUDNESS(m, time)
#define SET_META(name, var)
AVFILTER_DEFINE_CLASS(ebur128)
static av_cold int init(AVFilterContext *ctx)
#define HIST_GRAIN
defines histogram precision
static av_cold void uninit(AVFilterContext *ctx)
static int config_audio_input(AVFilterLink *inlink)
#define ABS_THRES
silence gate: we discard anything below this absolute (LUFS) threshold
static const uint8_t * get_graph_color(const EBUR128Context *ebur128, int v, int y)
static int config_video_output(AVFilterLink *outlink)
static int lu_to_y(const EBUR128Context *ebur128, double v)
#define MOVE_TO_NEXT_CACHED_ENTRY(time)
#define PRINT_PEAKS(str, sp, ptype)
internal math functions header
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index)
Get the channel with the given index in channel_layout.
#define AV_CH_LOW_FREQUENCY_2
#define AV_CH_LOW_FREQUENCY
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define AV_LOG_VERBOSE
Detailed information.
#define AV_LOG_INFO
Standard information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
AVSampleFormat
Audio sample formats.
@ AV_SAMPLE_FMT_DBL
double
av_cold void swr_free(SwrContext **ss)
Free the given SwrContext and set the pointer to NULL.
av_cold int swr_init(struct SwrContext *s)
Initialize context after user parameters have been set.
av_cold struct SwrContext * swr_alloc(void)
Allocate SwrContext.
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static enum AVPixelFormat pix_fmts[]
static const uint16_t mask[17]
enum MovChannelLayoutTag * layouts
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
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 w
agreed upon image width
int max_samples
Maximum number of samples to filter at once.
int h
agreed upon image height
AVFilterFormatsConfig outcfg
Lists of supported formats / etc.
int partial_buf_size
Size of the partial buffer to allocate.
AVFilterContext * src
source filter
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link.
int sample_rate
samples per second
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
uint64_t channel_layout
channel layout of current buffer (see libavutil/channel_layout.h)
AVFilterContext * dst
dest filter
int format
agreed upon media format
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
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Rational number (pair of numerator and denominator).
int gauge_type
whether gauge shows momentary or short
int y_opt_max
the y value (pixel position) for 1 LU
int peak_mode
enabled peak modes
AVFrame * outpicref
output picture reference, updated regularly
int meter
select a EBU mode between +9 and +18
int h
size of the video output
struct rect gauge
rectangle for the gauge on the right
double lra_high
low and high LRA values
double pan_law
pan law value used to calculate dual-mono measurements
struct integrator i3000
3s integrator, used for Short term loudness (S), and Loudness Range (LRA)
double integrated_loudness
integrated loudness in LUFS (I)
double * true_peaks_per_frame
true peaks in a frame per channel
int loglevel
log level for frame logging
int y_zero_lu
the y value (pixel position) for 0 LU
int metadata
whether or not to inject loudness results in frames
double z[MAX_CHANNELS *3]
3 RLB-filter samples cache for each channel
int scale_range
the range of LU values according to the meter
int do_video
1 if video output enabled, 0 otherwise
int nb_channels
number of channels in the input
double loudness_range
loudness range in LU (LRA)
int dual_mono
whether or not to treat single channel input files as dual-mono
int scale
display scale type of statistics
struct integrator i400
400ms integrator, used for Momentary loudness (M), and Integrated loudness (I)
int y_opt_min
the y value (pixel position) for -1 LU
double * ch_weighting
channel weighting mapping
double * true_peaks
true peaks per channel
struct rect text
rectangle for the LU legend on the left
int * y_line_ref
y reference values for drawing the LU lines in the graph and the gauge
double y[MAX_CHANNELS *3]
3 pre-filter samples cache for each channel
int sample_count
sample count used for refresh frequency, reset at refresh
struct rect graph
rectangle for the main graph in the center
double * sample_peaks
sample peaks per channel
int target
target level in LUFS used to set relative zero LU in visualization
double x[MAX_CHANNELS *3]
3 input samples cache for each channel
The libswresample context.
A histogram is an array of HIST_SIZE hist_entry storing all the energies recorded (with an accuracy o...
double energy
E = 10^((L + 0.691) / 10)
int count
how many times the corresponding value occurred
double loudness
L = -0.691 + 10 * log10(E)
double rel_threshold
relative threshold
struct hist_entry * histogram
histogram of the powers, used to compute LRA and I
int nb_kept_powers
number of sum above absolute threshold
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 sum_kept_powers
sum of the powers (weighted sums) above absolute threshold
double * cache[MAX_CHANNELS]
window of filtered samples (N ms)
int cache_pos
focus on the last added bin in the cache array
int attribute_align_arg swr_convert(struct SwrContext *s, uint8_t *out_arg[SWR_CH_MAX], int out_count, const uint8_t *in_arg[SWR_CH_MAX], int in_count)
libswresample public header
#define av_malloc_array(a, b)
timestamp utils, mostly useful for debugging/logging purposes
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
const uint8_t avpriv_vga16_font[4096]
const uint8_t avpriv_cga_font[2048]
CGA/EGA/VGA ROM font data.