FFmpeg  4.4.6
f_ebur128.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012 Clément Bœsch
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * EBU R.128 implementation
24  * @see http://tech.ebu.ch/loudness
25  * @see https://www.youtube.com/watch?v=iuEtQqC-Sqo "EBU R128 Introduction - Florian Camerer"
26  * @todo implement start/stop/reset through filter command injection
27  * @todo support other frequencies to avoid resampling
28  */
29 
30 #include <math.h>
31 
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
35 #include "libavutil/dict.h"
36 #include "libavutil/ffmath.h"
38 #include "libavutil/opt.h"
39 #include "libavutil/timestamp.h"
41 #include "audio.h"
42 #include "avfilter.h"
43 #include "formats.h"
44 #include "internal.h"
45 
46 #define MAX_CHANNELS 63
47 
48 /* pre-filter coefficients */
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
54 
55 /* RLB-filter coefficients */
56 #define RLB_B0 1.0
57 #define RLB_B1 -2.0
58 #define RLB_B2 1.0
59 #define RLB_A1 -1.99004745483398
60 #define RLB_A2 0.99007225036621
61 
62 #define ABS_THRES -70 ///< silence gate: we discard anything below this absolute (LUFS) threshold
63 #define ABS_UP_THRES 10 ///< upper loud limit to consider (ABS_THRES being the minimum)
64 #define HIST_GRAIN 100 ///< defines histogram precision
65 #define HIST_SIZE ((ABS_UP_THRES - ABS_THRES) * HIST_GRAIN + 1)
66 
67 /**
68  * A histogram is an array of HIST_SIZE hist_entry storing all the energies
69  * recorded (with an accuracy of 1/HIST_GRAIN) of the loudnesses from ABS_THRES
70  * (at 0) to ABS_UP_THRES (at HIST_SIZE-1).
71  * This fixed-size system avoids the need of a list of energies growing
72  * infinitely over the time and is thus more scalable.
73  */
74 struct hist_entry {
75  int count; ///< how many times the corresponding value occurred
76  double energy; ///< E = 10^((L + 0.691) / 10)
77  double loudness; ///< L = -0.691 + 10 * log10(E)
78 };
79 
80 struct integrator {
81  double *cache[MAX_CHANNELS]; ///< window of filtered samples (N ms)
82  int cache_pos; ///< focus on the last added bin in the cache array
83  double sum[MAX_CHANNELS]; ///< sum of the last N ms filtered samples (cache content)
84  int filled; ///< 1 if the cache is completely filled, 0 otherwise
85  double rel_threshold; ///< relative threshold
86  double sum_kept_powers; ///< sum of the powers (weighted sums) above absolute threshold
87  int nb_kept_powers; ///< number of sum above absolute threshold
88  struct hist_entry *histogram; ///< histogram of the powers, used to compute LRA and I
89 };
90 
91 struct rect { int x, y, w, h; };
92 
93 typedef struct EBUR128Context {
94  const AVClass *class; ///< AVClass context for log and options purpose
95 
96  /* peak metering */
97  int peak_mode; ///< enabled peak modes
98  double *true_peaks; ///< true peaks per channel
99  double *sample_peaks; ///< sample peaks per channel
100  double *true_peaks_per_frame; ///< true peaks in a frame per channel
101 #if CONFIG_SWRESAMPLE
102  SwrContext *swr_ctx; ///< over-sampling context for true peak metering
103  double *swr_buf; ///< resampled audio data for true peak metering
104  int swr_linesize;
105 #endif
106 
107  /* video */
108  int do_video; ///< 1 if video output enabled, 0 otherwise
109  int w, h; ///< size of the video output
110  struct rect text; ///< rectangle for the LU legend on the left
111  struct rect graph; ///< rectangle for the main graph in the center
112  struct rect gauge; ///< rectangle for the gauge on the right
113  AVFrame *outpicref; ///< output picture reference, updated regularly
114  int meter; ///< select a EBU mode between +9 and +18
115  int scale_range; ///< the range of LU values according to the meter
116  int y_zero_lu; ///< the y value (pixel position) for 0 LU
117  int y_opt_max; ///< the y value (pixel position) for 1 LU
118  int y_opt_min; ///< the y value (pixel position) for -1 LU
119  int *y_line_ref; ///< y reference values for drawing the LU lines in the graph and the gauge
120 
121  /* audio */
122  int nb_channels; ///< number of channels in the input
123  double *ch_weighting; ///< channel weighting mapping
124  int sample_count; ///< sample count used for refresh frequency, reset at refresh
125 
126  /* Filter caches.
127  * The mult by 3 in the following is for X[i], X[i-1] and X[i-2] */
128  double x[MAX_CHANNELS * 3]; ///< 3 input samples cache for each channel
129  double y[MAX_CHANNELS * 3]; ///< 3 pre-filter samples cache for each channel
130  double z[MAX_CHANNELS * 3]; ///< 3 RLB-filter samples cache for each channel
131 
132 #define I400_BINS (48000 * 4 / 10)
133 #define I3000_BINS (48000 * 3)
134  struct integrator i400; ///< 400ms integrator, used for Momentary loudness (M), and Integrated loudness (I)
135  struct integrator i3000; ///< 3s integrator, used for Short term loudness (S), and Loudness Range (LRA)
136 
137  /* I and LRA specific */
138  double integrated_loudness; ///< integrated loudness in LUFS (I)
139  double loudness_range; ///< loudness range in LU (LRA)
140  double lra_low, lra_high; ///< low and high LRA values
141 
142  /* misc */
143  int loglevel; ///< log level for frame logging
144  int metadata; ///< whether or not to inject loudness results in frames
145  int dual_mono; ///< whether or not to treat single channel input files as dual-mono
146  double pan_law; ///< pan law value used to calculate dual-mono measurements
147  int target; ///< target level in LUFS used to set relative zero LU in visualization
148  int gauge_type; ///< whether gauge shows momentary or short
149  int scale; ///< display scale type of statistics
151 
152 enum {
156 };
157 
158 enum {
161 };
162 
163 enum {
166 };
167 
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
172 static const AVOption ebur128_options[] = {
173  { "video", "set video output", OFFSET(do_video), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, V|F },
174  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "640x480"}, 0, 0, V|F },
175  { "meter", "set scale meter (+9 to +18)", OFFSET(meter), AV_OPT_TYPE_INT, {.i64 = 9}, 9, 18, V|F },
176  { "framelog", "force frame logging level", OFFSET(loglevel), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, A|V|F, "level" },
177  { "info", "information logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_INFO}, INT_MIN, INT_MAX, A|V|F, "level" },
178  { "verbose", "verbose logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_VERBOSE}, INT_MIN, INT_MAX, A|V|F, "level" },
179  { "metadata", "inject metadata in the filtergraph", OFFSET(metadata), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, A|V|F },
180  { "peak", "set peak mode", OFFSET(peak_mode), AV_OPT_TYPE_FLAGS, {.i64 = PEAK_MODE_NONE}, 0, INT_MAX, A|F, "mode" },
181  { "none", "disable any peak mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_NONE}, INT_MIN, INT_MAX, A|F, "mode" },
182  { "sample", "enable peak-sample mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_SAMPLES_PEAKS}, INT_MIN, INT_MAX, A|F, "mode" },
183  { "true", "enable true-peak mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_TRUE_PEAKS}, INT_MIN, INT_MAX, A|F, "mode" },
184  { "dualmono", "treat mono input files as dual-mono", OFFSET(dual_mono), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, A|F },
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 },
187  { "gauge", "set gauge display type", OFFSET(gauge_type), AV_OPT_TYPE_INT, {.i64 = 0 }, GAUGE_TYPE_MOMENTARY, GAUGE_TYPE_SHORTTERM, V|F, "gaugetype" },
188  { "momentary", "display momentary value", 0, AV_OPT_TYPE_CONST, {.i64 = GAUGE_TYPE_MOMENTARY}, INT_MIN, INT_MAX, V|F, "gaugetype" },
189  { "m", "display momentary value", 0, AV_OPT_TYPE_CONST, {.i64 = GAUGE_TYPE_MOMENTARY}, INT_MIN, INT_MAX, V|F, "gaugetype" },
190  { "shortterm", "display short-term value", 0, AV_OPT_TYPE_CONST, {.i64 = GAUGE_TYPE_SHORTTERM}, INT_MIN, INT_MAX, V|F, "gaugetype" },
191  { "s", "display short-term value", 0, AV_OPT_TYPE_CONST, {.i64 = GAUGE_TYPE_SHORTTERM}, INT_MIN, INT_MAX, V|F, "gaugetype" },
192  { "scale", "sets display method for the stats", OFFSET(scale), AV_OPT_TYPE_INT, {.i64 = 0}, SCALE_TYPE_ABSOLUTE, SCALE_TYPE_RELATIVE, V|F, "scaletype" },
193  { "absolute", "display absolute values (LUFS)", 0, AV_OPT_TYPE_CONST, {.i64 = SCALE_TYPE_ABSOLUTE}, INT_MIN, INT_MAX, V|F, "scaletype" },
194  { "LUFS", "display absolute values (LUFS)", 0, AV_OPT_TYPE_CONST, {.i64 = SCALE_TYPE_ABSOLUTE}, INT_MIN, INT_MAX, V|F, "scaletype" },
195  { "relative", "display values relative to target (LU)", 0, AV_OPT_TYPE_CONST, {.i64 = SCALE_TYPE_RELATIVE}, INT_MIN, INT_MAX, V|F, "scaletype" },
196  { "LU", "display values relative to target (LU)", 0, AV_OPT_TYPE_CONST, {.i64 = SCALE_TYPE_RELATIVE}, INT_MIN, INT_MAX, V|F, "scaletype" },
197  { NULL },
198 };
199 
201 
202 static const uint8_t graph_colors[] = {
203  0xdd, 0x66, 0x66, // value above 1LU non reached below -1LU (impossible)
204  0x66, 0x66, 0xdd, // value below 1LU non reached below -1LU
205  0x96, 0x33, 0x33, // value above 1LU reached below -1LU (impossible)
206  0x33, 0x33, 0x96, // value below 1LU reached below -1LU
207  0xdd, 0x96, 0x96, // value above 1LU line non reached below -1LU (impossible)
208  0x96, 0x96, 0xdd, // value below 1LU line non reached below -1LU
209  0xdd, 0x33, 0x33, // value above 1LU line reached below -1LU (impossible)
210  0x33, 0x33, 0xdd, // value below 1LU line reached below -1LU
211  0xdd, 0x66, 0x66, // value above 1LU non reached above -1LU
212  0x66, 0xdd, 0x66, // value below 1LU non reached above -1LU
213  0x96, 0x33, 0x33, // value above 1LU reached above -1LU
214  0x33, 0x96, 0x33, // value below 1LU reached above -1LU
215  0xdd, 0x96, 0x96, // value above 1LU line non reached above -1LU
216  0x96, 0xdd, 0x96, // value below 1LU line non reached above -1LU
217  0xdd, 0x33, 0x33, // value above 1LU line reached above -1LU
218  0x33, 0xdd, 0x33, // value below 1LU line reached above -1LU
219 };
220 
221 static const uint8_t *get_graph_color(const EBUR128Context *ebur128, int v, int y)
222 {
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;
226  const int line = ebur128->y_line_ref[y] || y == ebur128->y_zero_lu;
227  const int colorid = 8*below_opt_min+ 4*line + 2*reached + above_opt_max;
228  return graph_colors + 3*colorid;
229 }
230 
231 static inline int lu_to_y(const EBUR128Context *ebur128, double v)
232 {
233  v += 2 * ebur128->meter; // make it in range [0;...]
234  v = av_clipf(v, 0, ebur128->scale_range); // make sure it's in the graph scale
235  v = ebur128->scale_range - v; // invert value (y=0 is on top)
236  return v * ebur128->graph.h / ebur128->scale_range; // rescale from scale range to px height
237 }
238 
239 #define FONT8 0
240 #define FONT16 1
241 
242 static const uint8_t font_colors[] = {
243  0xdd, 0xdd, 0x00,
244  0x00, 0x96, 0x96,
245 };
246 
247 static void drawtext(AVFrame *pic, int x, int y, int ftid, const uint8_t *color, const char *fmt, ...)
248 {
249  int i;
250  char buf[128] = {0};
251  const uint8_t *font;
252  int font_height;
253  va_list vl;
254 
255  if (ftid == FONT16) font = avpriv_vga16_font, font_height = 16;
256  else if (ftid == FONT8) font = avpriv_cga_font, font_height = 8;
257  else return;
258 
259  va_start(vl, fmt);
260  vsnprintf(buf, sizeof(buf), fmt, vl);
261  va_end(vl);
262 
263  for (i = 0; buf[i]; i++) {
264  int char_y, mask;
265  uint8_t *p = pic->data[0] + y*pic->linesize[0] + (x + i*8)*3;
266 
267  for (char_y = 0; char_y < font_height; char_y++) {
268  for (mask = 0x80; mask; mask >>= 1) {
269  if (font[buf[i] * font_height + char_y] & mask)
270  memcpy(p, color, 3);
271  else
272  memcpy(p, "\x00\x00\x00", 3);
273  p += 3;
274  }
275  p += pic->linesize[0] - 8*3;
276  }
277  }
278 }
279 
280 static void drawline(AVFrame *pic, int x, int y, int len, int step)
281 {
282  int i;
283  uint8_t *p = pic->data[0] + y*pic->linesize[0] + x*3;
284 
285  for (i = 0; i < len; i++) {
286  memcpy(p, "\x00\xff\x00", 3);
287  p += step;
288  }
289 }
290 
291 static int config_video_output(AVFilterLink *outlink)
292 {
293  int i, x, y;
294  uint8_t *p;
295  AVFilterContext *ctx = outlink->src;
296  EBUR128Context *ebur128 = ctx->priv;
297  AVFrame *outpicref;
298 
299  /* check if there is enough space to represent everything decently */
300  if (ebur128->w < 640 || ebur128->h < 480) {
301  av_log(ctx, AV_LOG_ERROR, "Video size %dx%d is too small, "
302  "minimum size is 640x480\n", ebur128->w, ebur128->h);
303  return AVERROR(EINVAL);
304  }
305  outlink->w = ebur128->w;
306  outlink->h = ebur128->h;
307  outlink->sample_aspect_ratio = (AVRational){1,1};
308 
309 #define PAD 8
310 
311  /* configure text area position and size */
312  ebur128->text.x = PAD;
313  ebur128->text.y = 40;
314  ebur128->text.w = 3 * 8; // 3 characters
315  ebur128->text.h = ebur128->h - PAD - ebur128->text.y;
316 
317  /* configure gauge position and size */
318  ebur128->gauge.w = 20;
319  ebur128->gauge.h = ebur128->text.h;
320  ebur128->gauge.x = ebur128->w - PAD - ebur128->gauge.w;
321  ebur128->gauge.y = ebur128->text.y;
322 
323  /* configure graph position and size */
324  ebur128->graph.x = ebur128->text.x + ebur128->text.w + PAD;
325  ebur128->graph.y = ebur128->gauge.y;
326  ebur128->graph.w = ebur128->gauge.x - ebur128->graph.x - PAD;
327  ebur128->graph.h = ebur128->gauge.h;
328 
329  /* graph and gauge share the LU-to-pixel code */
330  av_assert0(ebur128->graph.h == ebur128->gauge.h);
331 
332  /* prepare the initial picref buffer */
333  av_frame_free(&ebur128->outpicref);
334  ebur128->outpicref = outpicref =
335  ff_get_video_buffer(outlink, outlink->w, outlink->h);
336  if (!outpicref)
337  return AVERROR(ENOMEM);
338  outpicref->sample_aspect_ratio = (AVRational){1,1};
339 
340  /* init y references values (to draw LU lines) */
341  ebur128->y_line_ref = av_calloc(ebur128->graph.h + 1, sizeof(*ebur128->y_line_ref));
342  if (!ebur128->y_line_ref)
343  return AVERROR(ENOMEM);
344 
345  /* black background */
346  memset(outpicref->data[0], 0, ebur128->h * outpicref->linesize[0]);
347 
348  /* draw LU legends */
349  drawtext(outpicref, PAD, PAD+16, FONT8, font_colors+3, " LU");
350  for (i = ebur128->meter; i >= -ebur128->meter * 2; i--) {
351  y = lu_to_y(ebur128, i);
352  x = PAD + (i < 10 && i > -10) * 8;
353  ebur128->y_line_ref[y] = i;
354  y -= 4; // -4 to center vertically
355  drawtext(outpicref, x, y + ebur128->graph.y, FONT8, font_colors+3,
356  "%c%d", i < 0 ? '-' : i > 0 ? '+' : ' ', FFABS(i));
357  }
358 
359  /* draw graph */
360  ebur128->y_zero_lu = lu_to_y(ebur128, 0);
361  ebur128->y_opt_max = lu_to_y(ebur128, 1);
362  ebur128->y_opt_min = lu_to_y(ebur128, -1);
363  p = outpicref->data[0] + ebur128->graph.y * outpicref->linesize[0]
364  + ebur128->graph.x * 3;
365  for (y = 0; y < ebur128->graph.h; y++) {
366  const uint8_t *c = get_graph_color(ebur128, INT_MAX, y);
367 
368  for (x = 0; x < ebur128->graph.w; x++)
369  memcpy(p + x*3, c, 3);
370  p += outpicref->linesize[0];
371  }
372 
373  /* draw fancy rectangles around the graph and the gauge */
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]); \
379 } while (0)
380  DRAW_RECT(ebur128->graph);
381  DRAW_RECT(ebur128->gauge);
382 
383  return 0;
384 }
385 
386 static int config_audio_input(AVFilterLink *inlink)
387 {
388  AVFilterContext *ctx = inlink->dst;
389  EBUR128Context *ebur128 = ctx->priv;
390 
391  /* Force 100ms framing in case of metadata injection: the frames must have
392  * a granularity of the window overlap to be accurately exploited.
393  * As for the true peaks mode, it just simplifies the resampling buffer
394  * allocation and the lookup in it (since sample buffers differ in size, it
395  * can be more complex to integrate in the one-sample loop of
396  * filter_frame()). */
397  if (ebur128->metadata || (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS))
398  inlink->min_samples =
399  inlink->max_samples =
400  inlink->partial_buf_size = inlink->sample_rate / 10;
401  return 0;
402 }
403 
404 static int config_audio_output(AVFilterLink *outlink)
405 {
406  int i;
407  AVFilterContext *ctx = outlink->src;
408  EBUR128Context *ebur128 = ctx->priv;
410 
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)
415 
416  ebur128->nb_channels = nb_channels;
417  ebur128->ch_weighting = av_calloc(nb_channels, sizeof(*ebur128->ch_weighting));
418  if (!ebur128->ch_weighting)
419  return AVERROR(ENOMEM);
420 
421  for (i = 0; i < nb_channels; i++) {
422  /* channel weighting */
423  const uint64_t chl = av_channel_layout_extract_channel(outlink->channel_layout, i);
425  ebur128->ch_weighting[i] = 0;
426  } else if (chl & BACK_MASK) {
427  ebur128->ch_weighting[i] = 1.41;
428  } else {
429  ebur128->ch_weighting[i] = 1.0;
430  }
431 
432  if (!ebur128->ch_weighting[i])
433  continue;
434 
435  /* bins buffer for the two integration window (400ms and 3s) */
436  ebur128->i400.cache[i] = av_calloc(I400_BINS, sizeof(*ebur128->i400.cache[0]));
437  ebur128->i3000.cache[i] = av_calloc(I3000_BINS, sizeof(*ebur128->i3000.cache[0]));
438  if (!ebur128->i400.cache[i] || !ebur128->i3000.cache[i])
439  return AVERROR(ENOMEM);
440  }
441 
442 #if CONFIG_SWRESAMPLE
443  if (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS) {
444  int ret;
445 
446  ebur128->swr_buf = av_malloc_array(nb_channels, 19200 * sizeof(double));
447  ebur128->true_peaks = av_calloc(nb_channels, sizeof(*ebur128->true_peaks));
448  ebur128->true_peaks_per_frame = av_calloc(nb_channels, sizeof(*ebur128->true_peaks_per_frame));
449  ebur128->swr_ctx = swr_alloc();
450  if (!ebur128->swr_buf || !ebur128->true_peaks ||
451  !ebur128->true_peaks_per_frame || !ebur128->swr_ctx)
452  return AVERROR(ENOMEM);
453 
454  av_opt_set_int(ebur128->swr_ctx, "in_channel_layout", outlink->channel_layout, 0);
455  av_opt_set_int(ebur128->swr_ctx, "in_sample_rate", outlink->sample_rate, 0);
456  av_opt_set_sample_fmt(ebur128->swr_ctx, "in_sample_fmt", outlink->format, 0);
457 
458  av_opt_set_int(ebur128->swr_ctx, "out_channel_layout", outlink->channel_layout, 0);
459  av_opt_set_int(ebur128->swr_ctx, "out_sample_rate", 192000, 0);
460  av_opt_set_sample_fmt(ebur128->swr_ctx, "out_sample_fmt", outlink->format, 0);
461 
462  ret = swr_init(ebur128->swr_ctx);
463  if (ret < 0)
464  return ret;
465  }
466 #endif
467 
468  if (ebur128->peak_mode & PEAK_MODE_SAMPLES_PEAKS) {
469  ebur128->sample_peaks = av_calloc(nb_channels, sizeof(*ebur128->sample_peaks));
470  if (!ebur128->sample_peaks)
471  return AVERROR(ENOMEM);
472  }
473 
474  return 0;
475 }
476 
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))
480 
481 static struct hist_entry *get_histogram(void)
482 {
483  int i;
484  struct hist_entry *h = av_calloc(HIST_SIZE, sizeof(*h));
485 
486  if (!h)
487  return NULL;
488  for (i = 0; i < HIST_SIZE; i++) {
489  h[i].loudness = i / (double)HIST_GRAIN + ABS_THRES;
490  h[i].energy = ENERGY(h[i].loudness);
491  }
492  return h;
493 }
494 
496 {
497  EBUR128Context *ebur128 = ctx->priv;
498  AVFilterPad pad;
499  int ret;
500 
501  if (ebur128->loglevel != AV_LOG_INFO &&
502  ebur128->loglevel != AV_LOG_VERBOSE) {
503  if (ebur128->do_video || ebur128->metadata)
504  ebur128->loglevel = AV_LOG_VERBOSE;
505  else
506  ebur128->loglevel = AV_LOG_INFO;
507  }
508 
509  if (!CONFIG_SWRESAMPLE && (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS)) {
511  "True-peak mode requires libswresample to be performed\n");
512  return AVERROR(EINVAL);
513  }
514 
515  // if meter is +9 scale, scale range is from -18 LU to +9 LU (or 3*9)
516  // if meter is +18 scale, scale range is from -36 LU to +18 LU (or 3*18)
517  ebur128->scale_range = 3 * ebur128->meter;
518 
519  ebur128->i400.histogram = get_histogram();
520  ebur128->i3000.histogram = get_histogram();
521  if (!ebur128->i400.histogram || !ebur128->i3000.histogram)
522  return AVERROR(ENOMEM);
523 
524  ebur128->integrated_loudness = ABS_THRES;
525  ebur128->loudness_range = 0;
526 
527  /* insert output pads */
528  if (ebur128->do_video) {
529  pad = (AVFilterPad){
530  .name = "out0",
531  .type = AVMEDIA_TYPE_VIDEO,
532  .config_props = config_video_output,
533  };
534  ret = ff_insert_outpad(ctx, 0, &pad);
535  if (ret < 0)
536  return ret;
537  }
538  pad = (AVFilterPad){
539  .name = ebur128->do_video ? "out1" : "out0",
540  .type = AVMEDIA_TYPE_AUDIO,
541  .config_props = config_audio_output,
542  };
543  ret = ff_insert_outpad(ctx, ebur128->do_video, &pad);
544  if (ret < 0)
545  return ret;
546 
547  /* summary */
548  av_log(ctx, AV_LOG_VERBOSE, "EBU +%d scale\n", ebur128->meter);
549 
550  return 0;
551 }
552 
553 #define HIST_POS(power) (int)(((power) - ABS_THRES) * HIST_GRAIN)
554 
555 /* loudness and power should be set such as loudness = -0.691 +
556  * 10*log10(power), we just avoid doing that calculus two times */
557 static int gate_update(struct integrator *integ, double power,
558  double loudness, int gate_thres)
559 {
560  int ipower;
561  double relative_threshold;
562  int gate_hist_pos;
563 
564  /* update powers histograms by incrementing current power count */
565  ipower = av_clip(HIST_POS(loudness), 0, HIST_SIZE - 1);
566  integ->histogram[ipower].count++;
567 
568  /* compute relative threshold and get its position in the histogram */
569  integ->sum_kept_powers += power;
570  integ->nb_kept_powers++;
571  relative_threshold = integ->sum_kept_powers / integ->nb_kept_powers;
572  if (!relative_threshold)
573  relative_threshold = 1e-12;
574  integ->rel_threshold = LOUDNESS(relative_threshold) + gate_thres;
575  gate_hist_pos = av_clip(HIST_POS(integ->rel_threshold), 0, HIST_SIZE - 1);
576 
577  return gate_hist_pos;
578 }
579 
580 static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
581 {
582  int i, ch, idx_insample;
583  AVFilterContext *ctx = inlink->dst;
584  EBUR128Context *ebur128 = ctx->priv;
585  const int nb_channels = ebur128->nb_channels;
586  const int nb_samples = insamples->nb_samples;
587  const double *samples = (double *)insamples->data[0];
588  AVFrame *pic = ebur128->outpicref;
589 
591  if (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS) {
592  const double *swr_samples = ebur128->swr_buf;
593  int ret = swr_convert(ebur128->swr_ctx, (uint8_t**)&ebur128->swr_buf, 19200,
594  (const uint8_t **)insamples->data, nb_samples);
595  if (ret < 0)
596  return ret;
597  for (ch = 0; ch < nb_channels; ch++)
598  ebur128->true_peaks_per_frame[ch] = 0.0;
599  for (idx_insample = 0; idx_insample < ret; idx_insample++) {
600  for (ch = 0; ch < nb_channels; ch++) {
601  ebur128->true_peaks[ch] = FFMAX(ebur128->true_peaks[ch], fabs(*swr_samples));
602  ebur128->true_peaks_per_frame[ch] = FFMAX(ebur128->true_peaks_per_frame[ch],
603  fabs(*swr_samples));
604  swr_samples++;
605  }
606  }
607  }
608 #endif
609 
610  for (idx_insample = 0; idx_insample < nb_samples; idx_insample++) {
611  const int bin_id_400 = ebur128->i400.cache_pos;
612  const int bin_id_3000 = ebur128->i3000.cache_pos;
613 
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; \
619  } \
620 } while (0)
621 
624 
625  for (ch = 0; ch < nb_channels; ch++) {
626  double bin;
627 
628  if (ebur128->peak_mode & PEAK_MODE_SAMPLES_PEAKS)
629  ebur128->sample_peaks[ch] = FFMAX(ebur128->sample_peaks[ch], fabs(*samples));
630 
631  ebur128->x[ch * 3] = *samples++; // set X[i]
632 
633  if (!ebur128->ch_weighting[ch])
634  continue;
635 
636  /* Y[i] = X[i]*b0 + X[i-1]*b1 + X[i-2]*b2 - Y[i-1]*a1 - Y[i-2]*a2 */
637 #define FILTER(Y, X, name) do { \
638  double *dst = ebur128->Y + ch*3; \
639  double *src = ebur128->X + ch*3; \
640  dst[2] = dst[1]; \
641  dst[1] = dst[0]; \
642  dst[0] = src[0]*name##_B0 + src[1]*name##_B1 + src[2]*name##_B2 \
643  - dst[1]*name##_A1 - dst[2]*name##_A2; \
644 } while (0)
645 
646  // TODO: merge both filters in one?
647  FILTER(y, x, PRE); // apply pre-filter
648  ebur128->x[ch * 3 + 2] = ebur128->x[ch * 3 + 1];
649  ebur128->x[ch * 3 + 1] = ebur128->x[ch * 3 ];
650  FILTER(z, y, RLB); // apply RLB-filter
651 
652  bin = ebur128->z[ch * 3] * ebur128->z[ch * 3];
653 
654  /* add the new value, and limit the sum to the cache size (400ms or 3s)
655  * by removing the oldest one */
656  ebur128->i400.sum [ch] = ebur128->i400.sum [ch] + bin - ebur128->i400.cache [ch][bin_id_400];
657  ebur128->i3000.sum[ch] = ebur128->i3000.sum[ch] + bin - ebur128->i3000.cache[ch][bin_id_3000];
658 
659  /* override old cache entry with the new value */
660  ebur128->i400.cache [ch][bin_id_400 ] = bin;
661  ebur128->i3000.cache[ch][bin_id_3000] = bin;
662  }
663 
664  /* For integrated loudness, gating blocks are 400ms long with 75%
665  * overlap (see BS.1770-2 p5), so a re-computation is needed each 100ms
666  * (4800 samples at 48kHz). */
667  if (++ebur128->sample_count == 4800) {
668  double loudness_400, loudness_3000;
669  double power_400 = 1e-12, power_3000 = 1e-12;
670  AVFilterLink *outlink = ctx->outputs[0];
671  const int64_t pts = insamples->pts +
672  av_rescale_q(idx_insample, (AVRational){ 1, inlink->sample_rate },
673  outlink->time_base);
674 
675  ebur128->sample_count = 0;
676 
677 #define COMPUTE_LOUDNESS(m, time) do { \
678  if (ebur128->i##time.filled) { \
679  /* weighting sum of the last <time> ms */ \
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; \
683  } \
684  loudness_##time = LOUDNESS(power_##time); \
685 } while (0)
686 
687  COMPUTE_LOUDNESS(M, 400);
688  COMPUTE_LOUDNESS(S, 3000);
689 
690  /* Integrated loudness */
691 #define I_GATE_THRES -10 // initially defined to -8 LU in the first EBU standard
692 
693  if (loudness_400 >= ABS_THRES) {
694  double integrated_sum = 0;
695  int nb_integrated = 0;
696  int gate_hist_pos = gate_update(&ebur128->i400, power_400,
697  loudness_400, I_GATE_THRES);
698 
699  /* compute integrated loudness by summing the histogram values
700  * above the relative threshold */
701  for (i = gate_hist_pos; i < HIST_SIZE; i++) {
702  const int nb_v = ebur128->i400.histogram[i].count;
703  nb_integrated += nb_v;
704  integrated_sum += nb_v * ebur128->i400.histogram[i].energy;
705  }
706  if (nb_integrated) {
707  ebur128->integrated_loudness = LOUDNESS(integrated_sum / nb_integrated);
708  /* dual-mono correction */
709  if (nb_channels == 1 && ebur128->dual_mono) {
710  ebur128->integrated_loudness -= ebur128->pan_law;
711  }
712  }
713  }
714 
715  /* LRA */
716 #define LRA_GATE_THRES -20
717 #define LRA_LOWER_PRC 10
718 #define LRA_HIGHER_PRC 95
719 
720  /* XXX: example code in EBU 3342 is ">=" but formula in BS.1770
721  * specs is ">" */
722  if (loudness_3000 >= ABS_THRES) {
723  int nb_powers = 0;
724  int gate_hist_pos = gate_update(&ebur128->i3000, power_3000,
725  loudness_3000, LRA_GATE_THRES);
726 
727  for (i = gate_hist_pos; i < HIST_SIZE; i++)
728  nb_powers += ebur128->i3000.histogram[i].count;
729  if (nb_powers) {
730  int n, nb_pow;
731 
732  /* get lower loudness to consider */
733  n = 0;
734  nb_pow = LRA_LOWER_PRC * nb_powers / 100. + 0.5;
735  for (i = gate_hist_pos; i < HIST_SIZE; i++) {
736  n += ebur128->i3000.histogram[i].count;
737  if (n >= nb_pow) {
738  ebur128->lra_low = ebur128->i3000.histogram[i].loudness;
739  break;
740  }
741  }
742 
743  /* get higher loudness to consider */
744  n = nb_powers;
745  nb_pow = LRA_HIGHER_PRC * nb_powers / 100. + 0.5;
746  for (i = HIST_SIZE - 1; i >= 0; i--) {
747  n -= ebur128->i3000.histogram[i].count;
748  if (n < nb_pow) {
749  ebur128->lra_high = ebur128->i3000.histogram[i].loudness;
750  break;
751  }
752  }
753 
754  // XXX: show low & high on the graph?
755  ebur128->loudness_range = ebur128->lra_high - ebur128->lra_low;
756  }
757  }
758 
759  /* dual-mono correction */
760  if (nb_channels == 1 && ebur128->dual_mono) {
761  loudness_400 -= ebur128->pan_law;
762  loudness_3000 -= ebur128->pan_law;
763  }
764 
765 #define LOG_FMT "TARGET:%d LUFS M:%6.1f S:%6.1f I:%6.1f %s LRA:%6.1f LU"
766 
767  /* push one video frame */
768  if (ebur128->do_video) {
769  AVFrame *clone;
770  int x, y, ret;
771  uint8_t *p;
772  double gauge_value;
773  int y_loudness_lu_graph, y_loudness_lu_gauge;
774 
775  if (ebur128->gauge_type == GAUGE_TYPE_MOMENTARY) {
776  gauge_value = loudness_400 - ebur128->target;
777  } else {
778  gauge_value = loudness_3000 - ebur128->target;
779  }
780 
781  y_loudness_lu_graph = lu_to_y(ebur128, loudness_3000 - ebur128->target);
782  y_loudness_lu_gauge = lu_to_y(ebur128, gauge_value);
783 
784  /* draw the graph using the short-term loudness */
785  p = pic->data[0] + ebur128->graph.y*pic->linesize[0] + ebur128->graph.x*3;
786  for (y = 0; y < ebur128->graph.h; y++) {
787  const uint8_t *c = get_graph_color(ebur128, y_loudness_lu_graph, y);
788 
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];
792  }
793 
794  /* draw the gauge using either momentary or short-term loudness */
795  p = pic->data[0] + ebur128->gauge.y*pic->linesize[0] + ebur128->gauge.x*3;
796  for (y = 0; y < ebur128->gauge.h; y++) {
797  const uint8_t *c = get_graph_color(ebur128, y_loudness_lu_gauge, y);
798 
799  for (x = 0; x < ebur128->gauge.w; x++)
800  memcpy(p + x*3, c, 3);
801  p += pic->linesize[0];
802  }
803 
804  /* draw textual info */
805  if (ebur128->scale == SCALE_TYPE_ABSOLUTE) {
806  drawtext(pic, PAD, PAD - PAD/2, FONT16, font_colors,
807  LOG_FMT " ", // padding to erase trailing characters
808  ebur128->target, loudness_400, loudness_3000,
809  ebur128->integrated_loudness, "LUFS", ebur128->loudness_range);
810  } else {
811  drawtext(pic, PAD, PAD - PAD/2, FONT16, font_colors,
812  LOG_FMT " ", // padding to erase trailing characters
813  ebur128->target, loudness_400-ebur128->target, loudness_3000-ebur128->target,
814  ebur128->integrated_loudness-ebur128->target, "LU", ebur128->loudness_range);
815  }
816 
817  /* set pts and push frame */
818  pic->pts = pts;
819  clone = av_frame_clone(pic);
820  if (!clone)
821  return AVERROR(ENOMEM);
822  ret = ff_filter_frame(outlink, clone);
823  if (ret < 0)
824  return ret;
825  }
826 
827  if (ebur128->metadata) { /* happens only once per filter_frame call */
828  char metabuf[128];
829 #define META_PREFIX "lavfi.r128."
830 
831 #define SET_META(name, var) do { \
832  snprintf(metabuf, sizeof(metabuf), "%.3f", var); \
833  av_dict_set(&insamples->metadata, name, metabuf, 0); \
834 } while (0)
835 
836 #define SET_META_PEAK(name, ptype) do { \
837  if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \
838  char key[64]; \
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]); \
843  } \
844  } \
845 } while (0)
846 
847  SET_META(META_PREFIX "M", loudness_400);
848  SET_META(META_PREFIX "S", loudness_3000);
850  SET_META(META_PREFIX "LRA", ebur128->loudness_range);
851  SET_META(META_PREFIX "LRA.low", ebur128->lra_low);
852  SET_META(META_PREFIX "LRA.high", ebur128->lra_high);
853 
855  SET_META_PEAK(true, TRUE);
856  }
857 
858  if (ebur128->scale == SCALE_TYPE_ABSOLUTE) {
859  av_log(ctx, ebur128->loglevel, "t: %-10s " LOG_FMT,
860  av_ts2timestr(pts, &outlink->time_base),
861  ebur128->target, loudness_400, loudness_3000,
862  ebur128->integrated_loudness, "LUFS", ebur128->loudness_range);
863  } else {
864  av_log(ctx, ebur128->loglevel, "t: %-10s " LOG_FMT,
865  av_ts2timestr(pts, &outlink->time_base),
866  ebur128->target, loudness_400-ebur128->target, loudness_3000-ebur128->target,
867  ebur128->integrated_loudness-ebur128->target, "LU", ebur128->loudness_range);
868  }
869 
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"); \
876  } \
877 } while (0)
878 
879  PRINT_PEAKS("SPK", ebur128->sample_peaks, SAMPLES);
880  PRINT_PEAKS("FTPK", ebur128->true_peaks_per_frame, TRUE);
881  PRINT_PEAKS("TPK", ebur128->true_peaks, TRUE);
882  av_log(ctx, ebur128->loglevel, "\n");
883  }
884  }
885 
886  return ff_filter_frame(ctx->outputs[ebur128->do_video], insamples);
887 }
888 
890 {
891  EBUR128Context *ebur128 = ctx->priv;
894  AVFilterLink *inlink = ctx->inputs[0];
895  AVFilterLink *outlink = ctx->outputs[0];
896  int ret;
897 
899  static const int input_srate[] = {48000, -1}; // ITU-R BS.1770 provides coeff only for 48kHz
900  static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE };
901 
902  /* set optional output video format */
903  if (ebur128->do_video) {
905  if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
906  return ret;
907  outlink = ctx->outputs[1];
908  }
909 
910  /* set input and output audio formats
911  * Note: ff_set_common_* functions are not used because they affect all the
912  * links, and thus break the video format negotiation */
914  if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0 ||
915  (ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
916  return ret;
917 
919  if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0 ||
920  (ret = ff_channel_layouts_ref(layouts, &outlink->incfg.channel_layouts)) < 0)
921  return ret;
922 
923  formats = ff_make_format_list(input_srate);
924  if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0 ||
925  (ret = ff_formats_ref(formats, &outlink->incfg.samplerates)) < 0)
926  return ret;
927 
928  return 0;
929 }
930 
932 {
933  int i;
934  EBUR128Context *ebur128 = ctx->priv;
935 
936  /* dual-mono correction */
937  if (ebur128->nb_channels == 1 && ebur128->dual_mono) {
938  ebur128->i400.rel_threshold -= ebur128->pan_law;
939  ebur128->i3000.rel_threshold -= ebur128->pan_law;
940  ebur128->lra_low -= ebur128->pan_law;
941  ebur128->lra_high -= ebur128->pan_law;
942  }
943 
944  av_log(ctx, AV_LOG_INFO, "Summary:\n\n"
945  " Integrated loudness:\n"
946  " I: %5.1f LUFS\n"
947  " Threshold: %5.1f LUFS\n\n"
948  " Loudness range:\n"
949  " LRA: %5.1f LU\n"
950  " Threshold: %5.1f LUFS\n"
951  " LRA low: %5.1f LUFS\n"
952  " LRA high: %5.1f LUFS",
953  ebur128->integrated_loudness, ebur128->i400.rel_threshold,
954  ebur128->loudness_range, ebur128->i3000.rel_threshold,
955  ebur128->lra_low, ebur128->lra_high);
956 
957 #define PRINT_PEAK_SUMMARY(str, sp, ptype) do { \
958  int ch; \
959  double maxpeak; \
960  maxpeak = 0.0; \
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", \
966  DBFS(maxpeak)); \
967  } \
968 } while (0)
969 
970  PRINT_PEAK_SUMMARY("Sample", ebur128->sample_peaks, SAMPLES);
971  PRINT_PEAK_SUMMARY("True", ebur128->true_peaks, TRUE);
972  av_log(ctx, AV_LOG_INFO, "\n");
973 
974  av_freep(&ebur128->y_line_ref);
975  av_freep(&ebur128->ch_weighting);
976  av_freep(&ebur128->true_peaks);
977  av_freep(&ebur128->sample_peaks);
978  av_freep(&ebur128->true_peaks_per_frame);
979  av_freep(&ebur128->i400.histogram);
980  av_freep(&ebur128->i3000.histogram);
981  for (i = 0; i < ebur128->nb_channels; i++) {
982  av_freep(&ebur128->i400.cache[i]);
983  av_freep(&ebur128->i3000.cache[i]);
984  }
985  av_frame_free(&ebur128->outpicref);
986 #if CONFIG_SWRESAMPLE
987  av_freep(&ebur128->swr_buf);
988  swr_free(&ebur128->swr_ctx);
989 #endif
990 }
991 
992 static const AVFilterPad ebur128_inputs[] = {
993  {
994  .name = "default",
995  .type = AVMEDIA_TYPE_AUDIO,
996  .filter_frame = filter_frame,
997  .config_props = config_audio_input,
998  },
999  { NULL }
1000 };
1001 
1003  .name = "ebur128",
1004  .description = NULL_IF_CONFIG_SMALL("EBU R128 scanner."),
1005  .priv_size = sizeof(EBUR128Context),
1006  .init = init,
1007  .uninit = uninit,
1010  .outputs = NULL,
1011  .priv_class = &ebur128_class,
1013 };
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:925
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
#define av_cold
Definition: attributes.h:88
uint8_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1096
Main libavfilter public API header.
#define flags(name, subs,...)
Definition: cbs_av1.c:572
int nb_channels
audio channel layout utility functions
#define av_clip
Definition: common.h:122
#define FFMAX(a, b)
Definition: common.h:103
#define av_clipf
Definition: common.h:170
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define CONFIG_SWRESAMPLE
Definition: config.h:578
#define NULL
Definition: coverity.c:32
long long int64_t
Definition: coverity.c:34
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
Public dictionary API.
#define FILTER(Y, X, name)
@ SCALE_TYPE_ABSOLUTE
Definition: f_ebur128.c:164
@ SCALE_TYPE_RELATIVE
Definition: f_ebur128.c:165
#define META_PREFIX
static int gate_update(struct integrator *integ, double power, double loudness, int gate_thres)
Definition: f_ebur128.c:557
static void drawtext(AVFrame *pic, int x, int y, int ftid, const uint8_t *color, const char *fmt,...)
Definition: f_ebur128.c:247
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
Definition: f_ebur128.c:580
static const uint8_t graph_colors[]
Definition: f_ebur128.c:202
#define SET_META_PEAK(name, ptype)
static void drawline(AVFrame *pic, int x, int y, int len, int step)
Definition: f_ebur128.c:280
static const uint8_t font_colors[]
Definition: f_ebur128.c:242
static const AVFilterPad ebur128_inputs[]
Definition: f_ebur128.c:992
#define PAD
#define DRAW_RECT(r)
#define PRINT_PEAK_SUMMARY(str, sp, ptype)
#define F
Definition: f_ebur128.c:171
#define HIST_POS(power)
Definition: f_ebur128.c:553
#define BACK_MASK
@ PEAK_MODE_NONE
Definition: f_ebur128.c:153
@ PEAK_MODE_SAMPLES_PEAKS
Definition: f_ebur128.c:154
@ PEAK_MODE_TRUE_PEAKS
Definition: f_ebur128.c:155
#define I_GATE_THRES
static int config_audio_output(AVFilterLink *outlink)
Definition: f_ebur128.c:404
static int query_formats(AVFilterContext *ctx)
Definition: f_ebur128.c:889
#define LRA_HIGHER_PRC
static struct hist_entry * get_histogram(void)
Definition: f_ebur128.c:481
#define I400_BINS
Definition: f_ebur128.c:132
#define ENERGY(loudness)
Definition: f_ebur128.c:477
#define HIST_SIZE
Definition: f_ebur128.c:65
static const AVOption ebur128_options[]
Definition: f_ebur128.c:172
#define COMPUTE_LOUDNESS(m, time)
#define SET_META(name, var)
AVFILTER_DEFINE_CLASS(ebur128)
#define A
Definition: f_ebur128.c:169
#define FONT8
Definition: f_ebur128.c:239
#define LOUDNESS(energy)
Definition: f_ebur128.c:478
#define I3000_BINS
Definition: f_ebur128.c:133
AVFilter ff_af_ebur128
Definition: f_ebur128.c:1002
static av_cold int init(AVFilterContext *ctx)
Definition: f_ebur128.c:495
#define HIST_GRAIN
defines histogram precision
Definition: f_ebur128.c:64
@ GAUGE_TYPE_SHORTTERM
Definition: f_ebur128.c:160
@ GAUGE_TYPE_MOMENTARY
Definition: f_ebur128.c:159
static av_cold void uninit(AVFilterContext *ctx)
Definition: f_ebur128.c:931
#define LRA_GATE_THRES
#define LOG_FMT
static int config_audio_input(AVFilterLink *inlink)
Definition: f_ebur128.c:386
#define MAX_CHANNELS
Definition: f_ebur128.c:46
#define OFFSET(x)
Definition: f_ebur128.c:168
#define ABS_THRES
silence gate: we discard anything below this absolute (LUFS) threshold
Definition: f_ebur128.c:62
static const uint8_t * get_graph_color(const EBUR128Context *ebur128, int v, int y)
Definition: f_ebur128.c:221
static int config_video_output(AVFilterLink *outlink)
Definition: f_ebur128.c:291
static int lu_to_y(const EBUR128Context *ebur128, double v)
Definition: f_ebur128.c:231
#define LRA_LOWER_PRC
#define V
Definition: f_ebur128.c:170
#define MOVE_TO_NEXT_CACHED_ENTRY(time)
#define PRINT_PEAKS(str, sp, ptype)
#define FONT16
Definition: f_ebur128.c:240
internal math functions header
#define S(s, c, i)
#define sample
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add ref as a new reference to formats.
Definition: formats.c:466
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:286
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (w...
Definition: formats.c:427
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:461
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:235
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:224
@ AV_OPT_TYPE_INT
Definition: opt.h:225
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:227
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
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.
Definition: avfilter.h:112
#define AVERROR(e)
Definition: error.h:43
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:540
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
@ AV_SAMPLE_FMT_DBL
double
Definition: samplefmt.h:64
av_cold void swr_free(SwrContext **ss)
Free the given SwrContext and set the pointer to NULL.
Definition: swresample.c:137
av_cold int swr_init(struct SwrContext *s)
Initialize context after user parameters have been set.
Definition: swresample.c:152
av_cold struct SwrContext * swr_alloc(void)
Allocate SwrContext.
Definition: options.c:149
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:586
int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
Definition: opt.c:704
for(j=16;j >0;--j)
int i
Definition: input.c:407
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
Definition: internal.h:248
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:309
uint8_t w
Definition: llviddspenc.c:39
static const uint16_t mask[17]
Definition: lzw.c:38
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
int loudness
Definition: normalize.py:20
AVOptions.
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
formats
Definition: signature.h:48
#define vsnprintf
Definition: snprintf.h:36
Describe the class of an AVClass context structure.
Definition: log.h:67
A list of supported channel layouts.
Definition: formats.h:86
An instance of a filter.
Definition: avfilter.h:341
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:445
AVFilterChannelLayouts * channel_layouts
Lists of supported channel layouts, only for audio.
Definition: avfilter.h:455
AVFilterFormats * samplerates
Lists of supported sample rates, only for audio.
Definition: avfilter.h:450
A list of supported formats for one end of a filter link.
Definition: formats.h:65
A filter pad used for either input or output.
Definition: internal.h:54
const char * name
Pad name.
Definition: internal.h:60
Filter definition.
Definition: avfilter.h:145
const char * name
Filter name.
Definition: avfilter.h:149
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:411
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:406
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
AVOption.
Definition: opt.h:248
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int gauge_type
whether gauge shows momentary or short
Definition: f_ebur128.c:148
int y_opt_max
the y value (pixel position) for 1 LU
Definition: f_ebur128.c:117
int peak_mode
enabled peak modes
Definition: f_ebur128.c:97
AVFrame * outpicref
output picture reference, updated regularly
Definition: f_ebur128.c:113
int meter
select a EBU mode between +9 and +18
Definition: f_ebur128.c:114
int h
size of the video output
Definition: f_ebur128.c:109
struct rect gauge
rectangle for the gauge on the right
Definition: f_ebur128.c:112
double lra_high
low and high LRA values
Definition: f_ebur128.c:140
double pan_law
pan law value used to calculate dual-mono measurements
Definition: f_ebur128.c:146
struct integrator i3000
3s integrator, used for Short term loudness (S), and Loudness Range (LRA)
Definition: f_ebur128.c:135
double integrated_loudness
integrated loudness in LUFS (I)
Definition: f_ebur128.c:138
double lra_low
Definition: f_ebur128.c:140
double * true_peaks_per_frame
true peaks in a frame per channel
Definition: f_ebur128.c:100
int loglevel
log level for frame logging
Definition: f_ebur128.c:143
int y_zero_lu
the y value (pixel position) for 0 LU
Definition: f_ebur128.c:116
int metadata
whether or not to inject loudness results in frames
Definition: f_ebur128.c:144
double z[MAX_CHANNELS *3]
3 RLB-filter samples cache for each channel
Definition: f_ebur128.c:130
int scale_range
the range of LU values according to the meter
Definition: f_ebur128.c:115
int do_video
1 if video output enabled, 0 otherwise
Definition: f_ebur128.c:108
int nb_channels
number of channels in the input
Definition: f_ebur128.c:122
double loudness_range
loudness range in LU (LRA)
Definition: f_ebur128.c:139
int dual_mono
whether or not to treat single channel input files as dual-mono
Definition: f_ebur128.c:145
int scale
display scale type of statistics
Definition: f_ebur128.c:149
struct integrator i400
400ms integrator, used for Momentary loudness (M), and Integrated loudness (I)
Definition: f_ebur128.c:134
int y_opt_min
the y value (pixel position) for -1 LU
Definition: f_ebur128.c:118
double * ch_weighting
channel weighting mapping
Definition: f_ebur128.c:123
double * true_peaks
true peaks per channel
Definition: f_ebur128.c:98
struct rect text
rectangle for the LU legend on the left
Definition: f_ebur128.c:110
int * y_line_ref
y reference values for drawing the LU lines in the graph and the gauge
Definition: f_ebur128.c:119
double y[MAX_CHANNELS *3]
3 pre-filter samples cache for each channel
Definition: f_ebur128.c:129
int sample_count
sample count used for refresh frequency, reset at refresh
Definition: f_ebur128.c:124
struct rect graph
rectangle for the main graph in the center
Definition: f_ebur128.c:111
double * sample_peaks
sample peaks per channel
Definition: f_ebur128.c:99
int target
target level in LUFS used to set relative zero LU in visualization
Definition: f_ebur128.c:147
double x[MAX_CHANNELS *3]
3 input samples cache for each channel
Definition: f_ebur128.c:128
The libswresample context.
A histogram is an array of HIST_SIZE hist_entry storing all the energies recorded (with an accuracy o...
Definition: f_ebur128.c:74
double energy
E = 10^((L + 0.691) / 10)
Definition: f_ebur128.c:76
int count
how many times the corresponding value occurred
Definition: f_ebur128.c:75
double loudness
L = -0.691 + 10 * log10(E)
Definition: f_ebur128.c:77
double rel_threshold
relative threshold
Definition: f_ebur128.c:85
struct hist_entry * histogram
histogram of the powers, used to compute LRA and I
Definition: f_ebur128.c:88
int nb_kept_powers
number of sum above absolute threshold
Definition: f_ebur128.c:87
double sum[MAX_CHANNELS]
sum of the last N ms filtered samples (cache content)
Definition: f_ebur128.c:83
int filled
1 if the cache is completely filled, 0 otherwise
Definition: f_ebur128.c:84
double sum_kept_powers
sum of the powers (weighted sums) above absolute threshold
Definition: f_ebur128.c:86
double * cache[MAX_CHANNELS]
window of filtered samples (N ms)
Definition: f_ebur128.c:81
int cache_pos
focus on the last added bin in the cache array
Definition: f_ebur128.c:82
Definition: graph2dot.c:48
Definition: f_ebur128.c:91
int w
Definition: f_ebur128.c:91
int y
Definition: f_ebur128.c:91
int h
Definition: f_ebur128.c:91
int x
Definition: f_ebur128.c:91
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)
Definition: swresample.c:714
libswresample public header
#define av_malloc_array(a, b)
#define av_freep(p)
#define av_log(a,...)
AVFormatContext * ctx
Definition: movenc.c:48
#define SAMPLES
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...
Definition: timestamp.h:76
static int64_t pts
if(ret< 0)
Definition: vf_mcdeint.c:282
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:104
int len
#define M(a, b)
Definition: vp3dsp.c:45
static double c[64]
const uint8_t avpriv_vga16_font[4096]
const uint8_t avpriv_cga_font[2048]
Definition: xga_font_data.c:29
CGA/EGA/VGA ROM font data.