33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/dict.h"
38 #include "libavutil/opt.h"
39 #include "libavutil/timestamp.h"
45 #define MAX_CHANNELS 63
48 #define PRE_B0 1.53512485958697
49 #define PRE_B1 -2.69169618940638
50 #define PRE_B2 1.19839281085285
51 #define PRE_A1 -1.69065929318241
52 #define PRE_A2 0.73248077421585
58 #define RLB_A1 -1.99004745483398
59 #define RLB_A2 0.99007225036621
62 #define ABS_UP_THRES 10
63 #define HIST_GRAIN 100
64 #define HIST_SIZE ((ABS_UP_THRES - ABS_THRES) * HIST_GRAIN + 1)
118 #define I400_BINS (48000 * 4 / 10)
119 #define I3000_BINS (48000 * 3)
133 #define OFFSET(x) offsetof(EBUR128Context, x)
134 #define A AV_OPT_FLAG_AUDIO_PARAM
135 #define V AV_OPT_FLAG_VIDEO_PARAM
136 #define F AV_OPT_FLAG_FILTERING_PARAM
141 {
"framelog",
"force frame logging level",
OFFSET(loglevel),
AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX,
A|
V|
F,
"level" },
163 const int below0 = y > ebur128->
y_zero_lu;
164 const int reached = y >=
v;
166 const int colorid = 4*line + 2*reached + below0;
172 v += 2 * ebur128->
meter;
202 for (i = 0; buf[i]; i++) {
206 for (char_y = 0; char_y < font_height; char_y++) {
207 for (mask = 0x80;
mask; mask >>= 1) {
208 if (font[buf[i] * font_height + char_y] & mask)
211 memcpy(p,
"\x00\x00\x00", 3);
224 for (i = 0; i <
len; i++) {
225 memcpy(p,
"\x00\xff\x00", 3);
239 if (ebur128->
w < 640 || ebur128->
h < 480) {
241 "minimum size is 640x480\n", ebur128->
w, ebur128->
h);
244 outlink->
w = ebur128->
w;
245 outlink->
h = ebur128->
h;
251 ebur128->
text.
y = 40;
252 ebur128->
text.
w = 3 * 8;
284 memset(outpicref->
data[0], 0, ebur128->
h * outpicref->
linesize[0]);
288 for (i = ebur128->
meter; i >= -ebur128->
meter * 2; i--) {
290 x =
PAD + (i < 10 && i > -10) * 8;
294 "%c%d", i < 0 ? '-' : i > 0 ?
'+' :
' ',
FFABS(i));
301 for (y = 0; y < ebur128->
graph.
h; y++) {
304 for (x = 0; x < ebur128->
graph.
w; x++)
305 memcpy(p + x*3, c, 3);
310 #define DRAW_RECT(r) do { \
311 drawline(outpicref, r.x, r.y - 1, r.w, 3); \
312 drawline(outpicref, r.x, r.y + r.h, r.w, 3); \
313 drawline(outpicref, r.x - 1, r.y, r.h, outpicref->linesize[0]); \
314 drawline(outpicref, r.x + r.w, r.y, r.h, outpicref->linesize[0]); \
346 #define BACK_MASK (AV_CH_BACK_LEFT |AV_CH_BACK_CENTER |AV_CH_BACK_RIGHT| \
347 AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_CENTER|AV_CH_TOP_BACK_RIGHT| \
348 AV_CH_SIDE_LEFT |AV_CH_SIDE_RIGHT| \
349 AV_CH_SURROUND_DIRECT_LEFT |AV_CH_SURROUND_DIRECT_RIGHT)
359 while ((outlink->
channel_layout & 1ULL<<idx_bitposn) == 0 && idx_bitposn < 63)
366 }
else if (1ULL<<idx_bitposn &
BACK_MASK) {
389 #define ENERGY(loudness) (pow(10, ((loudness) + 0.691) / 10.))
390 #define LOUDNESS(energy) (-0.691 + 10 * log10(energy))
457 #define HIST_POS(power) (int)(((power) - ABS_THRES) * HIST_GRAIN)
465 double relative_threshold;
476 if (!relative_threshold)
477 relative_threshold = 1e-12;
481 return gate_hist_pos;
486 int i, ch, idx_insample;
491 const double *samples = (
double *)insamples->
data[0];
494 for (idx_insample = 0; idx_insample < nb_samples; idx_insample++) {
498 #define MOVE_TO_NEXT_CACHED_ENTRY(time) do { \
499 ebur128->i##time.cache_pos++; \
500 if (ebur128->i##time.cache_pos == I##time##_BINS) { \
501 ebur128->i##time.filled = 1; \
502 ebur128->i##time.cache_pos = 0; \
512 ebur128->
x[ch * 3] = *samples++;
518 #define FILTER(Y, X, name) do { \
519 double *dst = ebur128->Y + ch*3; \
520 double *src = ebur128->X + ch*3; \
523 dst[0] = src[0]*name##_B0 + src[1]*name##_B1 + src[2]*name##_B2 \
524 - dst[1]*name##_A1 - dst[2]*name##_A2; \
529 ebur128->
x[ch * 3 + 2] = ebur128->
x[ch * 3 + 1];
530 ebur128->
x[ch * 3 + 1] = ebur128->
x[ch * 3 ];
533 bin = ebur128->
z[ch * 3] * ebur128->
z[ch * 3];
541 ebur128->
i400.
cache [ch][bin_id_400 ] = bin;
549 double loudness_400, loudness_3000;
550 double power_400 = 1e-12, power_3000 = 1e-12;
552 const int64_t pts = insamples->
pts +
558 #define COMPUTE_LOUDNESS(m, time) do { \
559 if (ebur128->i##time.filled) { \
561 for (ch = 0; ch < nb_channels; ch++) \
562 power_##time += ebur128->ch_weighting[ch] * ebur128->i##time.sum[ch]; \
563 power_##time /= I##time##_BINS; \
565 loudness_##time = LOUDNESS(power_##time); \
572 #define I_GATE_THRES -10 // initially defined to -8 LU in the first EBU standard
575 double integrated_sum = 0;
576 int nb_integrated = 0;
582 for (i = gate_hist_pos; i <
HIST_SIZE; i++) {
584 nb_integrated += nb_v;
592 #define LRA_GATE_THRES -20
593 #define LRA_LOWER_PRC 10
594 #define LRA_HIGHER_PRC 95
603 for (i = gate_hist_pos; i <
HIST_SIZE; i++)
611 for (i = gate_hist_pos; i <
HIST_SIZE; i++) {
622 for (i = HIST_SIZE - 1; i >= 0; i--) {
635 #define LOG_FMT "M:%6.1f S:%6.1f I:%6.1f LUFS LRA:%6.1f LU"
642 const int y_loudness_lu_graph =
lu_to_y(ebur128, loudness_3000 + 23);
643 const int y_loudness_lu_gauge =
lu_to_y(ebur128, loudness_400 + 23);
646 p = pic->data[0] + ebur128->
graph.
y*pic->linesize[0] + ebur128->
graph.
x*3;
647 for (y = 0; y < ebur128->
graph.
h; y++) {
650 memmove(p, p + 3, (ebur128->
graph.
w - 1) * 3);
651 memcpy(p + (ebur128->
graph.
w - 1) * 3, c, 3);
652 p += pic->linesize[0];
656 p = pic->data[0] + ebur128->
gauge.
y*pic->linesize[0] + ebur128->
gauge.
x*3;
657 for (y = 0; y < ebur128->
gauge.
h; y++) {
660 for (x = 0; x < ebur128->
gauge.
w; x++)
661 memcpy(p + x*3, c, 3);
662 p += pic->linesize[0];
668 loudness_400, loudness_3000,
680 #define SET_META(name, var) do { \
681 snprintf(metabuf, sizeof(metabuf), "%.3f", var); \
682 av_dict_set(&insamples->metadata, "lavfi.r128." name, metabuf, 0); \
694 loudness_400, loudness_3000,
711 static const int input_srate[] = {48000, -1};
753 " Integrated loudness:\n"
755 " Threshold: %5.1f LUFS\n\n"
758 " Threshold: %5.1f LUFS\n"
759 " LRA low: %5.1f LUFS\n"
760 " LRA high: %5.1f LUFS\n",
797 .priv_class = &ebur128_class,
static struct hist_entry * get_histogram(void)
void * av_calloc(size_t nmemb, size_t size) av_malloc_attrib
Allocate a block of nmemb * size bytes with alignment suitable for all memory accesses (including vec...
This structure describes decoded (raw) audio or video data.
int scale_range
the range of LU values according to the meter
static int query_formats(AVFilterContext *ctx)
const char * name
Filter name.
struct hist_entry * histogram
histogram of the powers, used to compute LRA and I
void * priv
private data for use by the filter
static int config_video_output(AVFilterLink *outlink)
static const AVFilterPad outputs[]
int sample_count
sample count used for refresh frequency, reset at refresh
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
int y_zero_lu
the y value (pixel position) for 0 LU
AVFilterFormats * in_samplerates
Lists of channel layouts and sample rates used for automatic negotiation.
char * av_strdup(const char *s) av_malloc_attrib
Duplicate the string s.
int max_samples
Maximum number of samples to filter at once.
static int config_audio_output(AVFilterLink *outlink)
int h
agreed upon image height
static int lu_to_y(const EBUR128Context *ebur128, double v)
#define COMPUTE_LOUDNESS(m, time)
packed RGB 8:8:8, 24bpp, RGBRGB...
static av_cold int init(AVFilterContext *ctx)
int cache_pos
focus on the last added bin in the cache array
#define AV_CH_LOW_FREQUENCY_2
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
const uint8_t avpriv_vga16_font[4096]
int do_video
1 if video output enabled, 0 otherwise
static enum AVSampleFormat formats[]
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
static const AVOption ebur128_options[]
int nb_channels
number of channels in the input
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
if((e=av_dict_get(options,"", NULL, AV_DICT_IGNORE_SUFFIX)))
int metadata
whether or not to inject loudness results in frames
const char * name
Pad name.
#define HIST_GRAIN
defines histogram precision
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
struct AVFilterChannelLayouts * in_channel_layouts
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)
double sum_kept_powers
sum of the powers (weighted sums) above absolute threshold
static void drawline(AVFrame *pic, int x, int y, int len, int step)
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
double * cache[MAX_CHANNELS]
window of filtered samples (N ms)
struct integrator i3000
3s integrator, used for Short term loudness (S), and Loudness Range (LRA)
double integrated_loudness
integrated loudness in LUFS (I)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
static const uint8_t font_colors[]
#define AV_CH_LOW_FREQUENCY
int meter
select a EBU mode between +9 and +18
#define AV_LOG_VERBOSE
Detailed information.
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
A histogram is an array of HIST_SIZE hist_entry storing all the energies recorded (with an accuracy o...
AVFrame * outpicref
output picture reference, updated regularly
A filter pad used for either input or output.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const
Rescale a 64-bit integer by 2 rational numbers.
A link between two filters.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
unsigned flags
Link processing flags.
Frame requests may need to loop in order to be fulfilled.
const uint8_t avpriv_cga_font[2048]
int min_samples
Minimum number of samples to filter at once.
int sample_rate
samples per second
int count
how many times the corresponding value occurred
static const uint16_t mask[17]
unsigned nb_outputs
number of output pads
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link...
AVFilterContext * src
source filter
#define MOVE_TO_NEXT_CACHED_ENTRY(time)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
AVPixelFormat
Pixel format.
struct integrator i400
400ms integrator, used for Momentary loudness (M), and Integrated loudness (I)
int w
agreed upon image width
static av_cold void uninit(AVFilterContext *ctx)
int * y_line_ref
y reference values for drawing the LU lines in the graph and the gauge
struct rect graph
rectangle for the main graph in the center
AVFilter avfilter_af_ebur128
double loudness
L = -0.691 + 10 * log10(E)
double rel_threshold
relative threshold
int partial_buf_size
Size of the partial buffer to allocate.
double loudness_range
loudness range in LU (LRA)
size_t char * av_asprintf(const char *fmt,...) av_printf_format(1
Print arguments following specified format into a large enough auto allocated buffer.
A list of supported channel layouts.
AVFilterFormats * out_samplerates
Main libavfilter public API header.
AVFilterLink ** outputs
array of pointers to output links
AVSampleFormat
Audio Sample Formats.
#define AV_LOG_INFO
Standard information.
#define ABS_THRES
silence gate: we discard anything below this absolute (LUFS) threshold
AVFilterFormats * out_formats
int nb_kept_powers
number of sum above absolute threshold
Describe the class of an AVClass context structure.
static const AVFilterPad inputs[]
AVFilterLink ** inputs
array of pointers to input links
rational number numerator/denominator
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
AVRational sample_aspect_ratio
agreed upon sample aspect ratio
AVFilterContext * dst
dest filter
offset must point to two consecutive integers
enum MovChannelLayoutTag * layouts
struct rect text
rectangle for the LU legend on the left
AVFrame * av_frame_clone(AVFrame *src)
Create a new frame that references the same data as src.
static const AVFilterPad ebur128_inputs[]
int h
size of the video output
struct rect gauge
rectangle for the gauge on the right
uint64_t channel_layout
channel layout of current buffer (see libavutil/channel_layout.h)
static int config_audio_input(AVFilterLink *inlink)
static int gate_update(struct integrator *integ, double power, double loudness, int gate_thres)
int loglevel
log level for frame logging
double x[MAX_CHANNELS *3]
3 input samples cache for each channel
#define FILTER(Y, X, name)
double lra_high
low and high LRA values
#define AVFILTER_DEFINE_CLASS(fname)
AVFilterPad * output_pads
array of output pads
static enum AVSampleFormat sample_fmts[]
double sum[MAX_CHANNELS]
sum of the last N ms filtered samples (cache content)
double z[MAX_CHANNELS *3]
3 RLB-filter samples cache for each channel
struct AVFilterChannelLayouts * out_channel_layouts
#define SET_META(name, var)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
AVFilterFormats * in_formats
Lists of formats and channel layouts supported by the input and output filters respectively.
double * ch_weighting
channel weighting mapping
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
int nb_samples
number of audio samples (per channel) described by this frame
static const uint8_t graph_colors[]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
CGA/EGA/VGA ROM font data.
double energy
E = 10^((L + 0.691) / 10)
int filled
1 if the cache is completely filled, 0 otherwise
static const uint8_t * get_graph_color(const EBUR128Context *ebur128, int v, int y)