FFmpeg
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"
34 #include "libavutil/channel_layout.h"
35 #include "libavutil/dict.h"
36 #include "libavutil/ffmath.h"
37 #include "libavutil/xga_font_data.h"
38 #include "libavutil/opt.h"
39 #include "libavutil/timestamp.h"
40 #include "libswresample/swresample.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
150 } EBUR128Context;
151 
152 enum {
153  PEAK_MODE_NONE = 0,
154  PEAK_MODE_SAMPLES_PEAKS = 1<<1,
155  PEAK_MODE_TRUE_PEAKS = 1<<2,
156 };
157 
158 enum {
159  GAUGE_TYPE_MOMENTARY = 0,
160  GAUGE_TYPE_SHORTTERM = 1,
161 };
162 
163 enum {
164  SCALE_TYPE_ABSOLUTE = 0,
165  SCALE_TYPE_RELATIVE = 1,
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 
200 AVFILTER_DEFINE_CLASS(ebur128);
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;
409  const int nb_channels = av_get_channel_layout_nb_channels(outlink->channel_layout);
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);
424  if (chl & (AV_CH_LOW_FREQUENCY|AV_CH_LOW_FREQUENCY_2)) {
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 
495 static av_cold int init(AVFilterContext *ctx)
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)) {
510  av_log(ctx, AV_LOG_ERROR,
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 = av_strdup("out0"),
531  .type = AVMEDIA_TYPE_VIDEO,
532  .config_props = config_video_output,
533  };
534  if (!pad.name)
535  return AVERROR(ENOMEM);
536  ret = ff_insert_outpad(ctx, 0, &pad);
537  if (ret < 0) {
538  av_freep(&pad.name);
539  return ret;
540  }
541  }
542  pad = (AVFilterPad){
543  .name = av_asprintf("out%d", ebur128->do_video),
544  .type = AVMEDIA_TYPE_AUDIO,
545  .config_props = config_audio_output,
546  };
547  if (!pad.name)
548  return AVERROR(ENOMEM);
549  ret = ff_insert_outpad(ctx, ebur128->do_video, &pad);
550  if (ret < 0) {
551  av_freep(&pad.name);
552  return ret;
553  }
554 
555  /* summary */
556  av_log(ctx, AV_LOG_VERBOSE, "EBU +%d scale\n", ebur128->meter);
557 
558  return 0;
559 }
560 
561 #define HIST_POS(power) (int)(((power) - ABS_THRES) * HIST_GRAIN)
562 
563 /* loudness and power should be set such as loudness = -0.691 +
564  * 10*log10(power), we just avoid doing that calculus two times */
565 static int gate_update(struct integrator *integ, double power,
566  double loudness, int gate_thres)
567 {
568  int ipower;
569  double relative_threshold;
570  int gate_hist_pos;
571 
572  /* update powers histograms by incrementing current power count */
573  ipower = av_clip(HIST_POS(loudness), 0, HIST_SIZE - 1);
574  integ->histogram[ipower].count++;
575 
576  /* compute relative threshold and get its position in the histogram */
577  integ->sum_kept_powers += power;
578  integ->nb_kept_powers++;
579  relative_threshold = integ->sum_kept_powers / integ->nb_kept_powers;
580  if (!relative_threshold)
581  relative_threshold = 1e-12;
582  integ->rel_threshold = LOUDNESS(relative_threshold) + gate_thres;
583  gate_hist_pos = av_clip(HIST_POS(integ->rel_threshold), 0, HIST_SIZE - 1);
584 
585  return gate_hist_pos;
586 }
587 
588 static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
589 {
590  int i, ch, idx_insample;
591  AVFilterContext *ctx = inlink->dst;
592  EBUR128Context *ebur128 = ctx->priv;
593  const int nb_channels = ebur128->nb_channels;
594  const int nb_samples = insamples->nb_samples;
595  const double *samples = (double *)insamples->data[0];
596  AVFrame *pic = ebur128->outpicref;
597 
598 #if CONFIG_SWRESAMPLE
599  if (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS) {
600  const double *swr_samples = ebur128->swr_buf;
601  int ret = swr_convert(ebur128->swr_ctx, (uint8_t**)&ebur128->swr_buf, 19200,
602  (const uint8_t **)insamples->data, nb_samples);
603  if (ret < 0)
604  return ret;
605  for (ch = 0; ch < nb_channels; ch++)
606  ebur128->true_peaks_per_frame[ch] = 0.0;
607  for (idx_insample = 0; idx_insample < ret; idx_insample++) {
608  for (ch = 0; ch < nb_channels; ch++) {
609  ebur128->true_peaks[ch] = FFMAX(ebur128->true_peaks[ch], fabs(*swr_samples));
610  ebur128->true_peaks_per_frame[ch] = FFMAX(ebur128->true_peaks_per_frame[ch],
611  fabs(*swr_samples));
612  swr_samples++;
613  }
614  }
615  }
616 #endif
617 
618  for (idx_insample = 0; idx_insample < nb_samples; idx_insample++) {
619  const int bin_id_400 = ebur128->i400.cache_pos;
620  const int bin_id_3000 = ebur128->i3000.cache_pos;
621 
622 #define MOVE_TO_NEXT_CACHED_ENTRY(time) do { \
623  ebur128->i##time.cache_pos++; \
624  if (ebur128->i##time.cache_pos == I##time##_BINS) { \
625  ebur128->i##time.filled = 1; \
626  ebur128->i##time.cache_pos = 0; \
627  } \
628 } while (0)
629 
630  MOVE_TO_NEXT_CACHED_ENTRY(400);
631  MOVE_TO_NEXT_CACHED_ENTRY(3000);
632 
633  for (ch = 0; ch < nb_channels; ch++) {
634  double bin;
635 
636  if (ebur128->peak_mode & PEAK_MODE_SAMPLES_PEAKS)
637  ebur128->sample_peaks[ch] = FFMAX(ebur128->sample_peaks[ch], fabs(*samples));
638 
639  ebur128->x[ch * 3] = *samples++; // set X[i]
640 
641  if (!ebur128->ch_weighting[ch])
642  continue;
643 
644  /* Y[i] = X[i]*b0 + X[i-1]*b1 + X[i-2]*b2 - Y[i-1]*a1 - Y[i-2]*a2 */
645 #define FILTER(Y, X, name) do { \
646  double *dst = ebur128->Y + ch*3; \
647  double *src = ebur128->X + ch*3; \
648  dst[2] = dst[1]; \
649  dst[1] = dst[0]; \
650  dst[0] = src[0]*name##_B0 + src[1]*name##_B1 + src[2]*name##_B2 \
651  - dst[1]*name##_A1 - dst[2]*name##_A2; \
652 } while (0)
653 
654  // TODO: merge both filters in one?
655  FILTER(y, x, PRE); // apply pre-filter
656  ebur128->x[ch * 3 + 2] = ebur128->x[ch * 3 + 1];
657  ebur128->x[ch * 3 + 1] = ebur128->x[ch * 3 ];
658  FILTER(z, y, RLB); // apply RLB-filter
659 
660  bin = ebur128->z[ch * 3] * ebur128->z[ch * 3];
661 
662  /* add the new value, and limit the sum to the cache size (400ms or 3s)
663  * by removing the oldest one */
664  ebur128->i400.sum [ch] = ebur128->i400.sum [ch] + bin - ebur128->i400.cache [ch][bin_id_400];
665  ebur128->i3000.sum[ch] = ebur128->i3000.sum[ch] + bin - ebur128->i3000.cache[ch][bin_id_3000];
666 
667  /* override old cache entry with the new value */
668  ebur128->i400.cache [ch][bin_id_400 ] = bin;
669  ebur128->i3000.cache[ch][bin_id_3000] = bin;
670  }
671 
672  /* For integrated loudness, gating blocks are 400ms long with 75%
673  * overlap (see BS.1770-2 p5), so a re-computation is needed each 100ms
674  * (4800 samples at 48kHz). */
675  if (++ebur128->sample_count == 4800) {
676  double loudness_400, loudness_3000;
677  double power_400 = 1e-12, power_3000 = 1e-12;
678  AVFilterLink *outlink = ctx->outputs[0];
679  const int64_t pts = insamples->pts +
680  av_rescale_q(idx_insample, (AVRational){ 1, inlink->sample_rate },
681  outlink->time_base);
682 
683  ebur128->sample_count = 0;
684 
685 #define COMPUTE_LOUDNESS(m, time) do { \
686  if (ebur128->i##time.filled) { \
687  /* weighting sum of the last <time> ms */ \
688  for (ch = 0; ch < nb_channels; ch++) \
689  power_##time += ebur128->ch_weighting[ch] * ebur128->i##time.sum[ch]; \
690  power_##time /= I##time##_BINS; \
691  } \
692  loudness_##time = LOUDNESS(power_##time); \
693 } while (0)
694 
695  COMPUTE_LOUDNESS(M, 400);
696  COMPUTE_LOUDNESS(S, 3000);
697 
698  /* Integrated loudness */
699 #define I_GATE_THRES -10 // initially defined to -8 LU in the first EBU standard
700 
701  if (loudness_400 >= ABS_THRES) {
702  double integrated_sum = 0;
703  int nb_integrated = 0;
704  int gate_hist_pos = gate_update(&ebur128->i400, power_400,
705  loudness_400, I_GATE_THRES);
706 
707  /* compute integrated loudness by summing the histogram values
708  * above the relative threshold */
709  for (i = gate_hist_pos; i < HIST_SIZE; i++) {
710  const int nb_v = ebur128->i400.histogram[i].count;
711  nb_integrated += nb_v;
712  integrated_sum += nb_v * ebur128->i400.histogram[i].energy;
713  }
714  if (nb_integrated) {
715  ebur128->integrated_loudness = LOUDNESS(integrated_sum / nb_integrated);
716  /* dual-mono correction */
717  if (nb_channels == 1 && ebur128->dual_mono) {
718  ebur128->integrated_loudness -= ebur128->pan_law;
719  }
720  }
721  }
722 
723  /* LRA */
724 #define LRA_GATE_THRES -20
725 #define LRA_LOWER_PRC 10
726 #define LRA_HIGHER_PRC 95
727 
728  /* XXX: example code in EBU 3342 is ">=" but formula in BS.1770
729  * specs is ">" */
730  if (loudness_3000 >= ABS_THRES) {
731  int nb_powers = 0;
732  int gate_hist_pos = gate_update(&ebur128->i3000, power_3000,
733  loudness_3000, LRA_GATE_THRES);
734 
735  for (i = gate_hist_pos; i < HIST_SIZE; i++)
736  nb_powers += ebur128->i3000.histogram[i].count;
737  if (nb_powers) {
738  int n, nb_pow;
739 
740  /* get lower loudness to consider */
741  n = 0;
742  nb_pow = LRA_LOWER_PRC * nb_powers / 100. + 0.5;
743  for (i = gate_hist_pos; i < HIST_SIZE; i++) {
744  n += ebur128->i3000.histogram[i].count;
745  if (n >= nb_pow) {
746  ebur128->lra_low = ebur128->i3000.histogram[i].loudness;
747  break;
748  }
749  }
750 
751  /* get higher loudness to consider */
752  n = nb_powers;
753  nb_pow = LRA_HIGHER_PRC * nb_powers / 100. + 0.5;
754  for (i = HIST_SIZE - 1; i >= 0; i--) {
755  n -= ebur128->i3000.histogram[i].count;
756  if (n < nb_pow) {
757  ebur128->lra_high = ebur128->i3000.histogram[i].loudness;
758  break;
759  }
760  }
761 
762  // XXX: show low & high on the graph?
763  ebur128->loudness_range = ebur128->lra_high - ebur128->lra_low;
764  }
765  }
766 
767  /* dual-mono correction */
768  if (nb_channels == 1 && ebur128->dual_mono) {
769  loudness_400 -= ebur128->pan_law;
770  loudness_3000 -= ebur128->pan_law;
771  }
772 
773 #define LOG_FMT "TARGET:%d LUFS M:%6.1f S:%6.1f I:%6.1f %s LRA:%6.1f LU"
774 
775  /* push one video frame */
776  if (ebur128->do_video) {
777  int x, y, ret;
778  uint8_t *p;
779  double gauge_value;
780  int y_loudness_lu_graph, y_loudness_lu_gauge;
781 
782  if (ebur128->gauge_type == GAUGE_TYPE_MOMENTARY) {
783  gauge_value = loudness_400 - ebur128->target;
784  } else {
785  gauge_value = loudness_3000 - ebur128->target;
786  }
787 
788  y_loudness_lu_graph = lu_to_y(ebur128, loudness_3000 - ebur128->target);
789  y_loudness_lu_gauge = lu_to_y(ebur128, gauge_value);
790 
791  /* draw the graph using the short-term loudness */
792  p = pic->data[0] + ebur128->graph.y*pic->linesize[0] + ebur128->graph.x*3;
793  for (y = 0; y < ebur128->graph.h; y++) {
794  const uint8_t *c = get_graph_color(ebur128, y_loudness_lu_graph, y);
795 
796  memmove(p, p + 3, (ebur128->graph.w - 1) * 3);
797  memcpy(p + (ebur128->graph.w - 1) * 3, c, 3);
798  p += pic->linesize[0];
799  }
800 
801  /* draw the gauge using either momentary or short-term loudness */
802  p = pic->data[0] + ebur128->gauge.y*pic->linesize[0] + ebur128->gauge.x*3;
803  for (y = 0; y < ebur128->gauge.h; y++) {
804  const uint8_t *c = get_graph_color(ebur128, y_loudness_lu_gauge, y);
805 
806  for (x = 0; x < ebur128->gauge.w; x++)
807  memcpy(p + x*3, c, 3);
808  p += pic->linesize[0];
809  }
810 
811  /* draw textual info */
812  if (ebur128->scale == SCALE_TYPE_ABSOLUTE) {
813  drawtext(pic, PAD, PAD - PAD/2, FONT16, font_colors,
814  LOG_FMT " ", // padding to erase trailing characters
815  ebur128->target, loudness_400, loudness_3000,
816  ebur128->integrated_loudness, "LUFS", ebur128->loudness_range);
817  } else {
818  drawtext(pic, PAD, PAD - PAD/2, FONT16, font_colors,
819  LOG_FMT " ", // padding to erase trailing characters
820  ebur128->target, loudness_400-ebur128->target, loudness_3000-ebur128->target,
821  ebur128->integrated_loudness-ebur128->target, "LU", ebur128->loudness_range);
822  }
823 
824  /* set pts and push frame */
825  pic->pts = pts;
826  ret = ff_filter_frame(outlink, av_frame_clone(pic));
827  if (ret < 0)
828  return ret;
829  }
830 
831  if (ebur128->metadata) { /* happens only once per filter_frame call */
832  char metabuf[128];
833 #define META_PREFIX "lavfi.r128."
834 
835 #define SET_META(name, var) do { \
836  snprintf(metabuf, sizeof(metabuf), "%.3f", var); \
837  av_dict_set(&insamples->metadata, name, metabuf, 0); \
838 } while (0)
839 
840 #define SET_META_PEAK(name, ptype) do { \
841  if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \
842  char key[64]; \
843  for (ch = 0; ch < nb_channels; ch++) { \
844  snprintf(key, sizeof(key), \
845  META_PREFIX AV_STRINGIFY(name) "_peaks_ch%d", ch); \
846  SET_META(key, ebur128->name##_peaks[ch]); \
847  } \
848  } \
849 } while (0)
850 
851  SET_META(META_PREFIX "M", loudness_400);
852  SET_META(META_PREFIX "S", loudness_3000);
853  SET_META(META_PREFIX "I", ebur128->integrated_loudness);
854  SET_META(META_PREFIX "LRA", ebur128->loudness_range);
855  SET_META(META_PREFIX "LRA.low", ebur128->lra_low);
856  SET_META(META_PREFIX "LRA.high", ebur128->lra_high);
857 
858  SET_META_PEAK(sample, SAMPLES);
859  SET_META_PEAK(true, TRUE);
860  }
861 
862  if (ebur128->scale == SCALE_TYPE_ABSOLUTE) {
863  av_log(ctx, ebur128->loglevel, "t: %-10s " LOG_FMT,
864  av_ts2timestr(pts, &outlink->time_base),
865  ebur128->target, loudness_400, loudness_3000,
866  ebur128->integrated_loudness, "LUFS", ebur128->loudness_range);
867  } else {
868  av_log(ctx, ebur128->loglevel, "t: %-10s " LOG_FMT,
869  av_ts2timestr(pts, &outlink->time_base),
870  ebur128->target, loudness_400-ebur128->target, loudness_3000-ebur128->target,
871  ebur128->integrated_loudness-ebur128->target, "LU", ebur128->loudness_range);
872  }
873 
874 #define PRINT_PEAKS(str, sp, ptype) do { \
875  if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \
876  av_log(ctx, ebur128->loglevel, " " str ":"); \
877  for (ch = 0; ch < nb_channels; ch++) \
878  av_log(ctx, ebur128->loglevel, " %5.1f", DBFS(sp[ch])); \
879  av_log(ctx, ebur128->loglevel, " dBFS"); \
880  } \
881 } while (0)
882 
883  PRINT_PEAKS("SPK", ebur128->sample_peaks, SAMPLES);
884  PRINT_PEAKS("FTPK", ebur128->true_peaks_per_frame, TRUE);
885  PRINT_PEAKS("TPK", ebur128->true_peaks, TRUE);
886  av_log(ctx, ebur128->loglevel, "\n");
887  }
888  }
889 
890  return ff_filter_frame(ctx->outputs[ebur128->do_video], insamples);
891 }
892 
893 static int query_formats(AVFilterContext *ctx)
894 {
895  EBUR128Context *ebur128 = ctx->priv;
896  AVFilterFormats *formats;
897  AVFilterChannelLayouts *layouts;
898  AVFilterLink *inlink = ctx->inputs[0];
899  AVFilterLink *outlink = ctx->outputs[0];
900  int ret;
901 
902  static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_NONE };
903  static const int input_srate[] = {48000, -1}; // ITU-R BS.1770 provides coeff only for 48kHz
904  static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE };
905 
906  /* set optional output video format */
907  if (ebur128->do_video) {
908  formats = ff_make_format_list(pix_fmts);
909  if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
910  return ret;
911  outlink = ctx->outputs[1];
912  }
913 
914  /* set input and output audio formats
915  * Note: ff_set_common_* functions are not used because they affect all the
916  * links, and thus break the video format negotiation */
917  formats = ff_make_format_list(sample_fmts);
918  if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0 ||
919  (ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
920  return ret;
921 
922  layouts = ff_all_channel_layouts();
923  if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0 ||
924  (ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts)) < 0)
925  return ret;
926 
927  formats = ff_make_format_list(input_srate);
928  if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0 ||
929  (ret = ff_formats_ref(formats, &outlink->in_samplerates)) < 0)
930  return ret;
931 
932  return 0;
933 }
934 
935 static av_cold void uninit(AVFilterContext *ctx)
936 {
937  int i;
938  EBUR128Context *ebur128 = ctx->priv;
939 
940  /* dual-mono correction */
941  if (ebur128->nb_channels == 1 && ebur128->dual_mono) {
942  ebur128->i400.rel_threshold -= ebur128->pan_law;
943  ebur128->i3000.rel_threshold -= ebur128->pan_law;
944  ebur128->lra_low -= ebur128->pan_law;
945  ebur128->lra_high -= ebur128->pan_law;
946  }
947 
948  av_log(ctx, AV_LOG_INFO, "Summary:\n\n"
949  " Integrated loudness:\n"
950  " I: %5.1f LUFS\n"
951  " Threshold: %5.1f LUFS\n\n"
952  " Loudness range:\n"
953  " LRA: %5.1f LU\n"
954  " Threshold: %5.1f LUFS\n"
955  " LRA low: %5.1f LUFS\n"
956  " LRA high: %5.1f LUFS",
957  ebur128->integrated_loudness, ebur128->i400.rel_threshold,
958  ebur128->loudness_range, ebur128->i3000.rel_threshold,
959  ebur128->lra_low, ebur128->lra_high);
960 
961 #define PRINT_PEAK_SUMMARY(str, sp, ptype) do { \
962  int ch; \
963  double maxpeak; \
964  maxpeak = 0.0; \
965  if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \
966  for (ch = 0; ch < ebur128->nb_channels; ch++) \
967  maxpeak = FFMAX(maxpeak, sp[ch]); \
968  av_log(ctx, AV_LOG_INFO, "\n\n " str " peak:\n" \
969  " Peak: %5.1f dBFS", \
970  DBFS(maxpeak)); \
971  } \
972 } while (0)
973 
974  PRINT_PEAK_SUMMARY("Sample", ebur128->sample_peaks, SAMPLES);
975  PRINT_PEAK_SUMMARY("True", ebur128->true_peaks, TRUE);
976  av_log(ctx, AV_LOG_INFO, "\n");
977 
978  av_freep(&ebur128->y_line_ref);
979  av_freep(&ebur128->ch_weighting);
980  av_freep(&ebur128->true_peaks);
981  av_freep(&ebur128->sample_peaks);
982  av_freep(&ebur128->true_peaks_per_frame);
983  av_freep(&ebur128->i400.histogram);
984  av_freep(&ebur128->i3000.histogram);
985  for (i = 0; i < ebur128->nb_channels; i++) {
986  av_freep(&ebur128->i400.cache[i]);
987  av_freep(&ebur128->i3000.cache[i]);
988  }
989  for (i = 0; i < ctx->nb_outputs; i++)
990  av_freep(&ctx->output_pads[i].name);
991  av_frame_free(&ebur128->outpicref);
992 #if CONFIG_SWRESAMPLE
993  av_freep(&ebur128->swr_buf);
994  swr_free(&ebur128->swr_ctx);
995 #endif
996 }
997 
998 static const AVFilterPad ebur128_inputs[] = {
999  {
1000  .name = "default",
1001  .type = AVMEDIA_TYPE_AUDIO,
1002  .filter_frame = filter_frame,
1003  .config_props = config_audio_input,
1004  },
1005  { NULL }
1006 };
1007 
1008 AVFilter ff_af_ebur128 = {
1009  .name = "ebur128",
1010  .description = NULL_IF_CONFIG_SMALL("EBU R128 scanner."),
1011  .priv_size = sizeof(EBUR128Context),
1012  .init = init,
1013  .uninit = uninit,
1014  .query_formats = query_formats,
1015  .inputs = ebur128_inputs,
1016  .outputs = NULL,
1017  .priv_class = &ebur128_class,
1018  .flags = AVFILTER_FLAG_DYNAMIC_OUTPUTS,
1019 };
M
#define M(a, b)
Definition: vp3dsp.c:45
formats
formats
Definition: signature.h:48
rect::w
int w
Definition: f_ebur128.c:91
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:99
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
EBUR128Context::dual_mono
int dual_mono
whether or not to treat single channel input files as dual-mono
Definition: f_ebur128.c:145
V
#define V
Definition: f_ebur128.c:170
EBUR128Context::ch_weighting
double * ch_weighting
channel weighting mapping
Definition: f_ebur128.c:123
EBUR128Context::y_opt_min
int y_opt_min
the y value (pixel position) for -1 LU
Definition: f_ebur128.c:118
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
integrator::filled
int filled
1 if the cache is completely filled, 0 otherwise
Definition: f_ebur128.c:84
integrator
Definition: f_ebur128.c:80
EBUR128Context::gauge_type
int gauge_type
whether gauge shows momentary or short
Definition: f_ebur128.c:148
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
EBUR128Context::y_opt_max
int y_opt_max
the y value (pixel position) for 1 LU
Definition: f_ebur128.c:117
SET_META_PEAK
#define SET_META_PEAK(name, ptype)
PEAK_MODE_NONE
@ PEAK_MODE_NONE
Definition: f_ebur128.c:153
PRINT_PEAKS
#define PRINT_PEAKS(str, sp, ptype)
get_graph_color
static const uint8_t * get_graph_color(const EBUR128Context *ebur128, int v, int y)
Definition: f_ebur128.c:221
A
#define A
Definition: f_ebur128.c:169
color
Definition: vf_paletteuse.c:588
AV_CH_LOW_FREQUENCY_2
#define AV_CH_LOW_FREQUENCY_2
Definition: channel_layout.h:73
n
int n
Definition: avisynth_c.h:760
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:686
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:435
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
EBUR128Context::do_video
int do_video
1 if video output enabled, 0 otherwise
Definition: f_ebur128.c:108
rect
Definition: f_ebur128.c:91
HIST_SIZE
#define HIST_SIZE
Definition: f_ebur128.c:65
ch
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
EBUR128Context::sample_count
int sample_count
sample count used for refresh frequency, reset at refresh
Definition: f_ebur128.c:124
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
ff_af_ebur128
AVFilter ff_af_ebur128
Definition: f_ebur128.c:1008
hist_entry::count
int count
how many times the corresponding value occurred
Definition: f_ebur128.c:75
rect::y
int y
Definition: f_ebur128.c:91
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:246
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(ebur128)
I_GATE_THRES
#define I_GATE_THRES
ebur128_options
static const AVOption ebur128_options[]
Definition: f_ebur128.c:172
F
#define F
Definition: f_ebur128.c:171
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
init
static av_cold int init(AVFilterContext *ctx)
Definition: f_ebur128.c:495
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:148
config_audio_output
static int config_audio_output(AVFilterLink *outlink)
Definition: f_ebur128.c:404
integrator::sum_kept_powers
double sum_kept_powers
sum of the powers (weighted sums) above absolute threshold
Definition: f_ebur128.c:86
EBUR128Context::z
double z[MAX_CHANNELS *3]
3 RLB-filter samples cache for each channel
Definition: f_ebur128.c:130
LRA_HIGHER_PRC
#define LRA_HIGHER_PRC
GAUGE_TYPE_MOMENTARY
@ GAUGE_TYPE_MOMENTARY
Definition: f_ebur128.c:159
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
formats.h
integrator::cache
double * cache[MAX_CHANNELS]
window of filtered samples (N ms)
Definition: f_ebur128.c:81
S
#define S(s, c, i)
Definition: flacdsp_template.c:46
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: f_ebur128.c:935
FONT8
#define FONT8
Definition: f_ebur128.c:239
EBUR128Context::pan_law
double pan_law
pan law value used to calculate dual-mono measurements
Definition: f_ebur128.c:146
fmt
const char * fmt
Definition: avisynth_c.h:861
drawline
static void drawline(AVFrame *pic, int x, int y, int len, int step)
Definition: f_ebur128.c:280
get_histogram
static struct hist_entry * get_histogram(void)
Definition: f_ebur128.c:481
EBUR128Context::scale
int scale
display scale type of statistics
Definition: f_ebur128.c:149
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: f_ebur128.c:893
LRA_GATE_THRES
#define LRA_GATE_THRES
pts
static int64_t pts
Definition: transcode_aac.c:647
integrator::cache_pos
int cache_pos
focus on the last added bin in the cache array
Definition: f_ebur128.c:82
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
font_colors
static const uint8_t font_colors[]
Definition: f_ebur128.c:242
avassert.h
EBUR128Context::metadata
int metadata
whether or not to inject loudness results in frames
Definition: f_ebur128.c:144
PEAK_MODE_SAMPLES_PEAKS
@ PEAK_MODE_SAMPLES_PEAKS
Definition: f_ebur128.c:154
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
MOVE_TO_NEXT_CACHED_ENTRY
#define MOVE_TO_NEXT_CACHED_ENTRY(time)
buf
void * buf
Definition: avisynth_c.h:766
av_cold
#define av_cold
Definition: attributes.h:84
EBUR128Context::graph
struct rect graph
rectangle for the main graph in the center
Definition: f_ebur128.c:111
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
Definition: f_ebur128.c:588
OFFSET
#define OFFSET(x)
Definition: f_ebur128.c:168
swr_init
av_cold int swr_init(struct SwrContext *s)
Initialize context after user parameters have been set.
Definition: swresample.c:152
AV_CH_LOW_FREQUENCY
#define AV_CH_LOW_FREQUENCY
Definition: channel_layout.h:52
config_video_output
static int config_video_output(AVFilterLink *outlink)
Definition: f_ebur128.c:291
mask
static const uint16_t mask[17]
Definition: lzw.c:38
EBUR128Context::integrated_loudness
double integrated_loudness
integrated loudness in LUFS (I)
Definition: f_ebur128.c:138
EBUR128Context::w
int w
Definition: f_ebur128.c:109
FONT16
#define FONT16
Definition: f_ebur128.c:240
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:225
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:440
EBUR128Context::target
int target
target level in LUFS used to set relative zero LU in visualization
Definition: f_ebur128.c:147
swr_alloc
av_cold struct SwrContext * swr_alloc(void)
Allocate SwrContext.
Definition: options.c:149
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
swr_convert
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
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:540
av_rescale_q
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
I3000_BINS
#define I3000_BINS
Definition: f_ebur128.c:133
drawtext
static void drawtext(AVFrame *pic, int x, int y, int ftid, const uint8_t *color, const char *fmt,...)
Definition: f_ebur128.c:247
SwrContext
The libswresample context.
Definition: swresample_internal.h:95
PEAK_MODE_TRUE_PEAKS
@ PEAK_MODE_TRUE_PEAKS
Definition: f_ebur128.c:155
hist_entry::loudness
double loudness
L = -0.691 + 10 * log10(E)
Definition: f_ebur128.c:77
EBUR128Context::true_peaks_per_frame
double * true_peaks_per_frame
true peaks in a frame per channel
Definition: f_ebur128.c:100
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
if
if(ret)
Definition: filter_design.txt:179
EBUR128Context::sample_peaks
double * sample_peaks
sample peaks per channel
Definition: f_ebur128.c:99
HIST_GRAIN
#define HIST_GRAIN
defines histogram precision
Definition: f_ebur128.c:64
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
EBUR128Context::peak_mode
int peak_mode
enabled peak modes
Definition: f_ebur128.c:97
HIST_POS
#define HIST_POS(power)
Definition: f_ebur128.c:561
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_OPT_TYPE_IMAGE_SIZE
@ AV_OPT_TYPE_IMAGE_SIZE
offset must point to two consecutive integers
Definition: opt.h:233
LOG_FMT
#define LOG_FMT
EBUR128Context::gauge
struct rect gauge
rectangle for the gauge on the right
Definition: f_ebur128.c:112
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
swresample.h
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
av_get_channel_layout_nb_channels
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
Definition: channel_layout.c:220
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:568
EBUR128Context
Definition: f_ebur128.c:93
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
AVFILTER_FLAG_DYNAMIC_OUTPUTS
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:111
EBUR128Context::y_zero_lu
int y_zero_lu
the y value (pixel position) for 0 LU
Definition: f_ebur128.c:116
EBUR128Context::i3000
struct integrator i3000
3s integrator, used for Short term loudness (S), and Loudness Range (LRA)
Definition: f_ebur128.c:135
ENERGY
#define ENERGY(loudness)
Definition: f_ebur128.c:477
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
av_ts2timestr
#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
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
TRUE
#define TRUE
Definition: windows2linux.h:33
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
sample
#define sample
Definition: flacdsp_template.c:44
SCALE_TYPE_RELATIVE
@ SCALE_TYPE_RELATIVE
Definition: f_ebur128.c:165
rect::h
int h
Definition: f_ebur128.c:91
swr_free
av_cold void swr_free(SwrContext **ss)
Free the given SwrContext and set the pointer to NULL.
Definition: swresample.c:137
MAX_CHANNELS
#define MAX_CHANNELS
Definition: f_ebur128.c:46
EBUR128Context::outpicref
AVFrame * outpicref
output picture reference, updated regularly
Definition: f_ebur128.c:113
line
Definition: graph2dot.c:48
xga_font_data.h
EBUR128Context::y
double y[MAX_CHANNELS *3]
3 pre-filter samples cache for each channel
Definition: f_ebur128.c:129
ff_all_channel_layouts
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (w...
Definition: formats.c:401
rect::x
int x
Definition: f_ebur128.c:91
EBUR128Context::h
int h
size of the video output
Definition: f_ebur128.c:109
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
internal.h
PRINT_PEAK_SUMMARY
#define PRINT_PEAK_SUMMARY(str, sp, ptype)
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
avpriv_vga16_font
const uint8_t avpriv_vga16_font[4096]
Definition: xga_font_data.c:160
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
EBUR128Context::text
struct rect text
rectangle for the LU legend on the left
Definition: f_ebur128.c:110
av_channel_layout_extract_channel
uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index)
Get the channel with the given index in channel_layout.
Definition: channel_layout.c:265
EBUR128Context::y_line_ref
int * y_line_ref
y reference values for drawing the LU lines in the graph and the gauge
Definition: f_ebur128.c:119
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
vsnprintf
#define vsnprintf
Definition: snprintf.h:36
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
uint8_t
uint8_t
Definition: audio_convert.c:194
integrator::rel_threshold
double rel_threshold
relative threshold
Definition: f_ebur128.c:85
ABS_THRES
#define ABS_THRES
silence gate: we discard anything below this absolute (LUFS) threshold
Definition: f_ebur128.c:62
len
int len
Definition: vorbis_enc_data.h:452
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
integrator::nb_kept_powers
int nb_kept_powers
number of sum above absolute threshold
Definition: f_ebur128.c:87
EBUR128Context::true_peaks
double * true_peaks
true peaks per channel
Definition: f_ebur128.c:98
EBUR128Context::loudness_range
double loudness_range
loudness range in LU (LRA)
Definition: f_ebur128.c:139
AVFilter
Filter definition.
Definition: avfilter.h:144
hist_entry::energy
double energy
E = 10^((L + 0.691) / 10)
Definition: f_ebur128.c:76
graph_colors
static const uint8_t graph_colors[]
Definition: f_ebur128.c:202
ret
ret
Definition: filter_design.txt:187
EBUR128Context::lra_low
double lra_low
Definition: f_ebur128.c:140
LRA_LOWER_PRC
#define LRA_LOWER_PRC
dict.h
EBUR128Context::lra_high
double lra_high
low and high LRA values
Definition: f_ebur128.c:140
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:383
EBUR128Context::scale_range
int scale_range
the range of LU values according to the meter
Definition: f_ebur128.c:115
SCALE_TYPE_ABSOLUTE
@ SCALE_TYPE_ABSOLUTE
Definition: f_ebur128.c:164
META_PREFIX
#define META_PREFIX
SET_META
#define SET_META(name, var)
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
channel_layout.h
SAMPLES
#define SAMPLES
LOUDNESS
#define LOUDNESS(energy)
Definition: f_ebur128.c:478
EBUR128Context::meter
int meter
select a EBU mode between +9 and +18
Definition: f_ebur128.c:114
PAD
#define PAD
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
ff_insert_outpad
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
Definition: internal.h:285
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
avfilter.h
normalize.loudness
int loudness
Definition: normalize.py:20
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
ffmath.h
AVFilterContext
An instance of a filter.
Definition: avfilter.h:338
FILTER
#define FILTER(Y, X, name)
GAUGE_TYPE_SHORTTERM
@ GAUGE_TYPE_SHORTTERM
Definition: f_ebur128.c:160
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
audio.h
ebur128_inputs
static const AVFilterPad ebur128_inputs[]
Definition: f_ebur128.c:998
avpriv_cga_font
const uint8_t avpriv_cga_font[2048]
Definition: xga_font_data.c:29
DRAW_RECT
#define DRAW_RECT(r)
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:240
EBUR128Context::nb_channels
int nb_channels
number of channels in the input
Definition: f_ebur128.c:122
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
EBUR128Context::i400
struct integrator i400
400ms integrator, used for Momentary loudness (M), and Integrated loudness (I)
Definition: f_ebur128.c:134
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:222
timestamp.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
config_audio_input
static int config_audio_input(AVFilterLink *inlink)
Definition: f_ebur128.c:386
integrator::histogram
struct hist_entry * histogram
histogram of the powers, used to compute LRA and I
Definition: f_ebur128.c:88
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
h
h
Definition: vp9dsp_template.c:2038
BACK_MASK
#define BACK_MASK
AV_SAMPLE_FMT_DBL
@ AV_SAMPLE_FMT_DBL
double
Definition: samplefmt.h:64
avstring.h
lu_to_y
static int lu_to_y(const EBUR128Context *ebur128, double v)
Definition: f_ebur128.c:231
av_opt_set_sample_fmt
int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
Definition: opt.c:686
I400_BINS
#define I400_BINS
Definition: f_ebur128.c:132
integrator::sum
double sum[MAX_CHANNELS]
sum of the last N ms filtered samples (cache content)
Definition: f_ebur128.c:83
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:232
EBUR128Context::loglevel
int loglevel
log level for frame logging
Definition: f_ebur128.c:143
EBUR128Context::x
double x[MAX_CHANNELS *3]
3 input samples cache for each channel
Definition: f_ebur128.c:128
gate_update
static int gate_update(struct integrator *integ, double power, double loudness, int gate_thres)
Definition: f_ebur128.c:565
COMPUTE_LOUDNESS
#define COMPUTE_LOUDNESS(m, time)
nb_channels
int nb_channels
Definition: channel_layout.c:76
hist_entry
A histogram is an array of HIST_SIZE hist_entry storing all the energies recorded (with an accuracy o...
Definition: f_ebur128.c:74
Generated on Wed Aug 24 2022 21:27:11 for FFmpeg by   doxygen 1.8.17