FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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_line_ref; ///< y reference values for drawing the LU lines in the graph and the gauge
118 
119  /* audio */
120  int nb_channels; ///< number of channels in the input
121  double *ch_weighting; ///< channel weighting mapping
122  int sample_count; ///< sample count used for refresh frequency, reset at refresh
123 
124  /* Filter caches.
125  * The mult by 3 in the following is for X[i], X[i-1] and X[i-2] */
126  double x[MAX_CHANNELS * 3]; ///< 3 input samples cache for each channel
127  double y[MAX_CHANNELS * 3]; ///< 3 pre-filter samples cache for each channel
128  double z[MAX_CHANNELS * 3]; ///< 3 RLB-filter samples cache for each channel
129 
130 #define I400_BINS (48000 * 4 / 10)
131 #define I3000_BINS (48000 * 3)
132  struct integrator i400; ///< 400ms integrator, used for Momentary loudness (M), and Integrated loudness (I)
133  struct integrator i3000; ///< 3s integrator, used for Short term loudness (S), and Loudness Range (LRA)
134 
135  /* I and LRA specific */
136  double integrated_loudness; ///< integrated loudness in LUFS (I)
137  double loudness_range; ///< loudness range in LU (LRA)
138  double lra_low, lra_high; ///< low and high LRA values
139 
140  /* misc */
141  int loglevel; ///< log level for frame logging
142  int metadata; ///< whether or not to inject loudness results in frames
143  int dual_mono; ///< whether or not to treat single channel input files as dual-mono
144  double pan_law; ///< pan law value used to calculate dual-mono measurements
146 
147 enum {
151 };
152 
153 #define OFFSET(x) offsetof(EBUR128Context, x)
154 #define A AV_OPT_FLAG_AUDIO_PARAM
155 #define V AV_OPT_FLAG_VIDEO_PARAM
156 #define F AV_OPT_FLAG_FILTERING_PARAM
157 static const AVOption ebur128_options[] = {
158  { "video", "set video output", OFFSET(do_video), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, V|F },
159  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "640x480"}, 0, 0, V|F },
160  { "meter", "set scale meter (+9 to +18)", OFFSET(meter), AV_OPT_TYPE_INT, {.i64 = 9}, 9, 18, V|F },
161  { "framelog", "force frame logging level", OFFSET(loglevel), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, A|V|F, "level" },
162  { "info", "information logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_INFO}, INT_MIN, INT_MAX, A|V|F, "level" },
163  { "verbose", "verbose logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_VERBOSE}, INT_MIN, INT_MAX, A|V|F, "level" },
164  { "metadata", "inject metadata in the filtergraph", OFFSET(metadata), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, A|V|F },
165  { "peak", "set peak mode", OFFSET(peak_mode), AV_OPT_TYPE_FLAGS, {.i64 = PEAK_MODE_NONE}, 0, INT_MAX, A|F, "mode" },
166  { "none", "disable any peak mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_NONE}, INT_MIN, INT_MAX, A|F, "mode" },
167  { "sample", "enable peak-sample mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_SAMPLES_PEAKS}, INT_MIN, INT_MAX, A|F, "mode" },
168  { "true", "enable true-peak mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_TRUE_PEAKS}, INT_MIN, INT_MAX, A|F, "mode" },
169  { "dualmono", "treat mono input files as dual-mono", OFFSET(dual_mono), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, A|F },
170  { "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 },
171  { NULL },
172 };
173 
174 AVFILTER_DEFINE_CLASS(ebur128);
175 
176 static const uint8_t graph_colors[] = {
177  0xdd, 0x66, 0x66, // value above 0LU non reached
178  0x66, 0x66, 0xdd, // value below 0LU non reached
179  0x96, 0x33, 0x33, // value above 0LU reached
180  0x33, 0x33, 0x96, // value below 0LU reached
181  0xdd, 0x96, 0x96, // value above 0LU line non reached
182  0x96, 0x96, 0xdd, // value below 0LU line non reached
183  0xdd, 0x33, 0x33, // value above 0LU line reached
184  0x33, 0x33, 0xdd, // value below 0LU line reached
185 };
186 
187 static const uint8_t *get_graph_color(const EBUR128Context *ebur128, int v, int y)
188 {
189  const int below0 = y > ebur128->y_zero_lu;
190  const int reached = y >= v;
191  const int line = ebur128->y_line_ref[y] || y == ebur128->y_zero_lu;
192  const int colorid = 4*line + 2*reached + below0;
193  return graph_colors + 3*colorid;
194 }
195 
196 static inline int lu_to_y(const EBUR128Context *ebur128, double v)
197 {
198  v += 2 * ebur128->meter; // make it in range [0;...]
199  v = av_clipf(v, 0, ebur128->scale_range); // make sure it's in the graph scale
200  v = ebur128->scale_range - v; // invert value (y=0 is on top)
201  return v * ebur128->graph.h / ebur128->scale_range; // rescale from scale range to px height
202 }
203 
204 #define FONT8 0
205 #define FONT16 1
206 
207 static const uint8_t font_colors[] = {
208  0xdd, 0xdd, 0x00,
209  0x00, 0x96, 0x96,
210 };
211 
212 static void drawtext(AVFrame *pic, int x, int y, int ftid, const uint8_t *color, const char *fmt, ...)
213 {
214  int i;
215  char buf[128] = {0};
216  const uint8_t *font;
217  int font_height;
218  va_list vl;
219 
220  if (ftid == FONT16) font = avpriv_vga16_font, font_height = 16;
221  else if (ftid == FONT8) font = avpriv_cga_font, font_height = 8;
222  else return;
223 
224  va_start(vl, fmt);
225  vsnprintf(buf, sizeof(buf), fmt, vl);
226  va_end(vl);
227 
228  for (i = 0; buf[i]; i++) {
229  int char_y, mask;
230  uint8_t *p = pic->data[0] + y*pic->linesize[0] + (x + i*8)*3;
231 
232  for (char_y = 0; char_y < font_height; char_y++) {
233  for (mask = 0x80; mask; mask >>= 1) {
234  if (font[buf[i] * font_height + char_y] & mask)
235  memcpy(p, color, 3);
236  else
237  memcpy(p, "\x00\x00\x00", 3);
238  p += 3;
239  }
240  p += pic->linesize[0] - 8*3;
241  }
242  }
243 }
244 
245 static void drawline(AVFrame *pic, int x, int y, int len, int step)
246 {
247  int i;
248  uint8_t *p = pic->data[0] + y*pic->linesize[0] + x*3;
249 
250  for (i = 0; i < len; i++) {
251  memcpy(p, "\x00\xff\x00", 3);
252  p += step;
253  }
254 }
255 
256 static int config_video_output(AVFilterLink *outlink)
257 {
258  int i, x, y;
259  uint8_t *p;
260  AVFilterContext *ctx = outlink->src;
261  EBUR128Context *ebur128 = ctx->priv;
262  AVFrame *outpicref;
263 
264  /* check if there is enough space to represent everything decently */
265  if (ebur128->w < 640 || ebur128->h < 480) {
266  av_log(ctx, AV_LOG_ERROR, "Video size %dx%d is too small, "
267  "minimum size is 640x480\n", ebur128->w, ebur128->h);
268  return AVERROR(EINVAL);
269  }
270  outlink->w = ebur128->w;
271  outlink->h = ebur128->h;
272  outlink->sample_aspect_ratio = (AVRational){1,1};
273 
274 #define PAD 8
275 
276  /* configure text area position and size */
277  ebur128->text.x = PAD;
278  ebur128->text.y = 40;
279  ebur128->text.w = 3 * 8; // 3 characters
280  ebur128->text.h = ebur128->h - PAD - ebur128->text.y;
281 
282  /* configure gauge position and size */
283  ebur128->gauge.w = 20;
284  ebur128->gauge.h = ebur128->text.h;
285  ebur128->gauge.x = ebur128->w - PAD - ebur128->gauge.w;
286  ebur128->gauge.y = ebur128->text.y;
287 
288  /* configure graph position and size */
289  ebur128->graph.x = ebur128->text.x + ebur128->text.w + PAD;
290  ebur128->graph.y = ebur128->gauge.y;
291  ebur128->graph.w = ebur128->gauge.x - ebur128->graph.x - PAD;
292  ebur128->graph.h = ebur128->gauge.h;
293 
294  /* graph and gauge share the LU-to-pixel code */
295  av_assert0(ebur128->graph.h == ebur128->gauge.h);
296 
297  /* prepare the initial picref buffer */
298  av_frame_free(&ebur128->outpicref);
299  ebur128->outpicref = outpicref =
300  ff_get_video_buffer(outlink, outlink->w, outlink->h);
301  if (!outpicref)
302  return AVERROR(ENOMEM);
303  outpicref->sample_aspect_ratio = (AVRational){1,1};
304 
305  /* init y references values (to draw LU lines) */
306  ebur128->y_line_ref = av_calloc(ebur128->graph.h + 1, sizeof(*ebur128->y_line_ref));
307  if (!ebur128->y_line_ref)
308  return AVERROR(ENOMEM);
309 
310  /* black background */
311  memset(outpicref->data[0], 0, ebur128->h * outpicref->linesize[0]);
312 
313  /* draw LU legends */
314  drawtext(outpicref, PAD, PAD+16, FONT8, font_colors+3, " LU");
315  for (i = ebur128->meter; i >= -ebur128->meter * 2; i--) {
316  y = lu_to_y(ebur128, i);
317  x = PAD + (i < 10 && i > -10) * 8;
318  ebur128->y_line_ref[y] = i;
319  y -= 4; // -4 to center vertically
320  drawtext(outpicref, x, y + ebur128->graph.y, FONT8, font_colors+3,
321  "%c%d", i < 0 ? '-' : i > 0 ? '+' : ' ', FFABS(i));
322  }
323 
324  /* draw graph */
325  ebur128->y_zero_lu = lu_to_y(ebur128, 0);
326  p = outpicref->data[0] + ebur128->graph.y * outpicref->linesize[0]
327  + ebur128->graph.x * 3;
328  for (y = 0; y < ebur128->graph.h; y++) {
329  const uint8_t *c = get_graph_color(ebur128, INT_MAX, y);
330 
331  for (x = 0; x < ebur128->graph.w; x++)
332  memcpy(p + x*3, c, 3);
333  p += outpicref->linesize[0];
334  }
335 
336  /* draw fancy rectangles around the graph and the gauge */
337 #define DRAW_RECT(r) do { \
338  drawline(outpicref, r.x, r.y - 1, r.w, 3); \
339  drawline(outpicref, r.x, r.y + r.h, r.w, 3); \
340  drawline(outpicref, r.x - 1, r.y, r.h, outpicref->linesize[0]); \
341  drawline(outpicref, r.x + r.w, r.y, r.h, outpicref->linesize[0]); \
342 } while (0)
343  DRAW_RECT(ebur128->graph);
344  DRAW_RECT(ebur128->gauge);
345 
346  return 0;
347 }
348 
349 static int config_audio_input(AVFilterLink *inlink)
350 {
351  AVFilterContext *ctx = inlink->dst;
352  EBUR128Context *ebur128 = ctx->priv;
353 
354  /* Force 100ms framing in case of metadata injection: the frames must have
355  * a granularity of the window overlap to be accurately exploited.
356  * As for the true peaks mode, it just simplifies the resampling buffer
357  * allocation and the lookup in it (since sample buffers differ in size, it
358  * can be more complex to integrate in the one-sample loop of
359  * filter_frame()). */
360  if (ebur128->metadata || (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS))
361  inlink->min_samples =
362  inlink->max_samples =
363  inlink->partial_buf_size = inlink->sample_rate / 10;
364  return 0;
365 }
366 
367 static int config_audio_output(AVFilterLink *outlink)
368 {
369  int i;
370  AVFilterContext *ctx = outlink->src;
371  EBUR128Context *ebur128 = ctx->priv;
373 
374 #define BACK_MASK (AV_CH_BACK_LEFT |AV_CH_BACK_CENTER |AV_CH_BACK_RIGHT| \
375  AV_CH_TOP_BACK_LEFT|AV_CH_TOP_BACK_CENTER|AV_CH_TOP_BACK_RIGHT| \
376  AV_CH_SIDE_LEFT |AV_CH_SIDE_RIGHT| \
377  AV_CH_SURROUND_DIRECT_LEFT |AV_CH_SURROUND_DIRECT_RIGHT)
378 
379  ebur128->nb_channels = nb_channels;
380  ebur128->ch_weighting = av_calloc(nb_channels, sizeof(*ebur128->ch_weighting));
381  if (!ebur128->ch_weighting)
382  return AVERROR(ENOMEM);
383 
384  for (i = 0; i < nb_channels; i++) {
385  /* channel weighting */
386  const uint16_t chl = av_channel_layout_extract_channel(outlink->channel_layout, i);
388  ebur128->ch_weighting[i] = 0;
389  } else if (chl & BACK_MASK) {
390  ebur128->ch_weighting[i] = 1.41;
391  } else {
392  ebur128->ch_weighting[i] = 1.0;
393  }
394 
395  if (!ebur128->ch_weighting[i])
396  continue;
397 
398  /* bins buffer for the two integration window (400ms and 3s) */
399  ebur128->i400.cache[i] = av_calloc(I400_BINS, sizeof(*ebur128->i400.cache[0]));
400  ebur128->i3000.cache[i] = av_calloc(I3000_BINS, sizeof(*ebur128->i3000.cache[0]));
401  if (!ebur128->i400.cache[i] || !ebur128->i3000.cache[i])
402  return AVERROR(ENOMEM);
403  }
404 
405 #if CONFIG_SWRESAMPLE
406  if (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS) {
407  int ret;
408 
409  ebur128->swr_buf = av_malloc_array(nb_channels, 19200 * sizeof(double));
410  ebur128->true_peaks = av_calloc(nb_channels, sizeof(*ebur128->true_peaks));
411  ebur128->true_peaks_per_frame = av_calloc(nb_channels, sizeof(*ebur128->true_peaks_per_frame));
412  ebur128->swr_ctx = swr_alloc();
413  if (!ebur128->swr_buf || !ebur128->true_peaks ||
414  !ebur128->true_peaks_per_frame || !ebur128->swr_ctx)
415  return AVERROR(ENOMEM);
416 
417  av_opt_set_int(ebur128->swr_ctx, "in_channel_layout", outlink->channel_layout, 0);
418  av_opt_set_int(ebur128->swr_ctx, "in_sample_rate", outlink->sample_rate, 0);
419  av_opt_set_sample_fmt(ebur128->swr_ctx, "in_sample_fmt", outlink->format, 0);
420 
421  av_opt_set_int(ebur128->swr_ctx, "out_channel_layout", outlink->channel_layout, 0);
422  av_opt_set_int(ebur128->swr_ctx, "out_sample_rate", 192000, 0);
423  av_opt_set_sample_fmt(ebur128->swr_ctx, "out_sample_fmt", outlink->format, 0);
424 
425  ret = swr_init(ebur128->swr_ctx);
426  if (ret < 0)
427  return ret;
428  }
429 #endif
430 
431  if (ebur128->peak_mode & PEAK_MODE_SAMPLES_PEAKS) {
432  ebur128->sample_peaks = av_calloc(nb_channels, sizeof(*ebur128->sample_peaks));
433  if (!ebur128->sample_peaks)
434  return AVERROR(ENOMEM);
435  }
436 
437  return 0;
438 }
439 
440 #define ENERGY(loudness) (ff_exp10(((loudness) + 0.691) / 10.))
441 #define LOUDNESS(energy) (-0.691 + 10 * log10(energy))
442 #define DBFS(energy) (20 * log10(energy))
443 
444 static struct hist_entry *get_histogram(void)
445 {
446  int i;
447  struct hist_entry *h = av_calloc(HIST_SIZE, sizeof(*h));
448 
449  if (!h)
450  return NULL;
451  for (i = 0; i < HIST_SIZE; i++) {
452  h[i].loudness = i / (double)HIST_GRAIN + ABS_THRES;
453  h[i].energy = ENERGY(h[i].loudness);
454  }
455  return h;
456 }
457 
459 {
460  EBUR128Context *ebur128 = ctx->priv;
461  AVFilterPad pad;
462 
463  if (ebur128->loglevel != AV_LOG_INFO &&
464  ebur128->loglevel != AV_LOG_VERBOSE) {
465  if (ebur128->do_video || ebur128->metadata)
466  ebur128->loglevel = AV_LOG_VERBOSE;
467  else
468  ebur128->loglevel = AV_LOG_INFO;
469  }
470 
471  if (!CONFIG_SWRESAMPLE && (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS)) {
472  av_log(ctx, AV_LOG_ERROR,
473  "True-peak mode requires libswresample to be performed\n");
474  return AVERROR(EINVAL);
475  }
476 
477  // if meter is +9 scale, scale range is from -18 LU to +9 LU (or 3*9)
478  // if meter is +18 scale, scale range is from -36 LU to +18 LU (or 3*18)
479  ebur128->scale_range = 3 * ebur128->meter;
480 
481  ebur128->i400.histogram = get_histogram();
482  ebur128->i3000.histogram = get_histogram();
483  if (!ebur128->i400.histogram || !ebur128->i3000.histogram)
484  return AVERROR(ENOMEM);
485 
486  ebur128->integrated_loudness = ABS_THRES;
487  ebur128->loudness_range = 0;
488 
489  /* insert output pads */
490  if (ebur128->do_video) {
491  pad = (AVFilterPad){
492  .name = av_strdup("out0"),
493  .type = AVMEDIA_TYPE_VIDEO,
494  .config_props = config_video_output,
495  };
496  if (!pad.name)
497  return AVERROR(ENOMEM);
498  ff_insert_outpad(ctx, 0, &pad);
499  }
500  pad = (AVFilterPad){
501  .name = av_asprintf("out%d", ebur128->do_video),
502  .type = AVMEDIA_TYPE_AUDIO,
503  .config_props = config_audio_output,
504  };
505  if (!pad.name)
506  return AVERROR(ENOMEM);
507  ff_insert_outpad(ctx, ebur128->do_video, &pad);
508 
509  /* summary */
510  av_log(ctx, AV_LOG_VERBOSE, "EBU +%d scale\n", ebur128->meter);
511 
512  return 0;
513 }
514 
515 #define HIST_POS(power) (int)(((power) - ABS_THRES) * HIST_GRAIN)
516 
517 /* loudness and power should be set such as loudness = -0.691 +
518  * 10*log10(power), we just avoid doing that calculus two times */
519 static int gate_update(struct integrator *integ, double power,
520  double loudness, int gate_thres)
521 {
522  int ipower;
523  double relative_threshold;
524  int gate_hist_pos;
525 
526  /* update powers histograms by incrementing current power count */
527  ipower = av_clip(HIST_POS(loudness), 0, HIST_SIZE - 1);
528  integ->histogram[ipower].count++;
529 
530  /* compute relative threshold and get its position in the histogram */
531  integ->sum_kept_powers += power;
532  integ->nb_kept_powers++;
533  relative_threshold = integ->sum_kept_powers / integ->nb_kept_powers;
534  if (!relative_threshold)
535  relative_threshold = 1e-12;
536  integ->rel_threshold = LOUDNESS(relative_threshold) + gate_thres;
537  gate_hist_pos = av_clip(HIST_POS(integ->rel_threshold), 0, HIST_SIZE - 1);
538 
539  return gate_hist_pos;
540 }
541 
542 static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
543 {
544  int i, ch, idx_insample;
545  AVFilterContext *ctx = inlink->dst;
546  EBUR128Context *ebur128 = ctx->priv;
547  const int nb_channels = ebur128->nb_channels;
548  const int nb_samples = insamples->nb_samples;
549  const double *samples = (double *)insamples->data[0];
550  AVFrame *pic = ebur128->outpicref;
551 
552 #if CONFIG_SWRESAMPLE
553  if (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS) {
554  const double *swr_samples = ebur128->swr_buf;
555  int ret = swr_convert(ebur128->swr_ctx, (uint8_t**)&ebur128->swr_buf, 19200,
556  (const uint8_t **)insamples->data, nb_samples);
557  if (ret < 0)
558  return ret;
559  for (ch = 0; ch < nb_channels; ch++)
560  ebur128->true_peaks_per_frame[ch] = 0.0;
561  for (idx_insample = 0; idx_insample < ret; idx_insample++) {
562  for (ch = 0; ch < nb_channels; ch++) {
563  ebur128->true_peaks[ch] = FFMAX(ebur128->true_peaks[ch], fabs(*swr_samples));
564  ebur128->true_peaks_per_frame[ch] = FFMAX(ebur128->true_peaks_per_frame[ch],
565  fabs(*swr_samples));
566  swr_samples++;
567  }
568  }
569  }
570 #endif
571 
572  for (idx_insample = 0; idx_insample < nb_samples; idx_insample++) {
573  const int bin_id_400 = ebur128->i400.cache_pos;
574  const int bin_id_3000 = ebur128->i3000.cache_pos;
575 
576 #define MOVE_TO_NEXT_CACHED_ENTRY(time) do { \
577  ebur128->i##time.cache_pos++; \
578  if (ebur128->i##time.cache_pos == I##time##_BINS) { \
579  ebur128->i##time.filled = 1; \
580  ebur128->i##time.cache_pos = 0; \
581  } \
582 } while (0)
583 
586 
587  for (ch = 0; ch < nb_channels; ch++) {
588  double bin;
589 
590  if (ebur128->peak_mode & PEAK_MODE_SAMPLES_PEAKS)
591  ebur128->sample_peaks[ch] = FFMAX(ebur128->sample_peaks[ch], fabs(*samples));
592 
593  ebur128->x[ch * 3] = *samples++; // set X[i]
594 
595  if (!ebur128->ch_weighting[ch])
596  continue;
597 
598  /* Y[i] = X[i]*b0 + X[i-1]*b1 + X[i-2]*b2 - Y[i-1]*a1 - Y[i-2]*a2 */
599 #define FILTER(Y, X, name) do { \
600  double *dst = ebur128->Y + ch*3; \
601  double *src = ebur128->X + ch*3; \
602  dst[2] = dst[1]; \
603  dst[1] = dst[0]; \
604  dst[0] = src[0]*name##_B0 + src[1]*name##_B1 + src[2]*name##_B2 \
605  - dst[1]*name##_A1 - dst[2]*name##_A2; \
606 } while (0)
607 
608  // TODO: merge both filters in one?
609  FILTER(y, x, PRE); // apply pre-filter
610  ebur128->x[ch * 3 + 2] = ebur128->x[ch * 3 + 1];
611  ebur128->x[ch * 3 + 1] = ebur128->x[ch * 3 ];
612  FILTER(z, y, RLB); // apply RLB-filter
613 
614  bin = ebur128->z[ch * 3] * ebur128->z[ch * 3];
615 
616  /* add the new value, and limit the sum to the cache size (400ms or 3s)
617  * by removing the oldest one */
618  ebur128->i400.sum [ch] = ebur128->i400.sum [ch] + bin - ebur128->i400.cache [ch][bin_id_400];
619  ebur128->i3000.sum[ch] = ebur128->i3000.sum[ch] + bin - ebur128->i3000.cache[ch][bin_id_3000];
620 
621  /* override old cache entry with the new value */
622  ebur128->i400.cache [ch][bin_id_400 ] = bin;
623  ebur128->i3000.cache[ch][bin_id_3000] = bin;
624  }
625 
626  /* For integrated loudness, gating blocks are 400ms long with 75%
627  * overlap (see BS.1770-2 p5), so a re-computation is needed each 100ms
628  * (4800 samples at 48kHz). */
629  if (++ebur128->sample_count == 4800) {
630  double loudness_400, loudness_3000;
631  double power_400 = 1e-12, power_3000 = 1e-12;
632  AVFilterLink *outlink = ctx->outputs[0];
633  const int64_t pts = insamples->pts +
634  av_rescale_q(idx_insample, (AVRational){ 1, inlink->sample_rate },
635  outlink->time_base);
636 
637  ebur128->sample_count = 0;
638 
639 #define COMPUTE_LOUDNESS(m, time) do { \
640  if (ebur128->i##time.filled) { \
641  /* weighting sum of the last <time> ms */ \
642  for (ch = 0; ch < nb_channels; ch++) \
643  power_##time += ebur128->ch_weighting[ch] * ebur128->i##time.sum[ch]; \
644  power_##time /= I##time##_BINS; \
645  } \
646  loudness_##time = LOUDNESS(power_##time); \
647 } while (0)
648 
649  COMPUTE_LOUDNESS(M, 400);
650  COMPUTE_LOUDNESS(S, 3000);
651 
652  /* Integrated loudness */
653 #define I_GATE_THRES -10 // initially defined to -8 LU in the first EBU standard
654 
655  if (loudness_400 >= ABS_THRES) {
656  double integrated_sum = 0;
657  int nb_integrated = 0;
658  int gate_hist_pos = gate_update(&ebur128->i400, power_400,
659  loudness_400, I_GATE_THRES);
660 
661  /* compute integrated loudness by summing the histogram values
662  * above the relative threshold */
663  for (i = gate_hist_pos; i < HIST_SIZE; i++) {
664  const int nb_v = ebur128->i400.histogram[i].count;
665  nb_integrated += nb_v;
666  integrated_sum += nb_v * ebur128->i400.histogram[i].energy;
667  }
668  if (nb_integrated) {
669  ebur128->integrated_loudness = LOUDNESS(integrated_sum / nb_integrated);
670  /* dual-mono correction */
671  if (nb_channels == 1 && ebur128->dual_mono) {
672  ebur128->integrated_loudness -= ebur128->pan_law;
673  }
674  }
675  }
676 
677  /* LRA */
678 #define LRA_GATE_THRES -20
679 #define LRA_LOWER_PRC 10
680 #define LRA_HIGHER_PRC 95
681 
682  /* XXX: example code in EBU 3342 is ">=" but formula in BS.1770
683  * specs is ">" */
684  if (loudness_3000 >= ABS_THRES) {
685  int nb_powers = 0;
686  int gate_hist_pos = gate_update(&ebur128->i3000, power_3000,
687  loudness_3000, LRA_GATE_THRES);
688 
689  for (i = gate_hist_pos; i < HIST_SIZE; i++)
690  nb_powers += ebur128->i3000.histogram[i].count;
691  if (nb_powers) {
692  int n, nb_pow;
693 
694  /* get lower loudness to consider */
695  n = 0;
696  nb_pow = LRA_LOWER_PRC * nb_powers / 100. + 0.5;
697  for (i = gate_hist_pos; i < HIST_SIZE; i++) {
698  n += ebur128->i3000.histogram[i].count;
699  if (n >= nb_pow) {
700  ebur128->lra_low = ebur128->i3000.histogram[i].loudness;
701  break;
702  }
703  }
704 
705  /* get higher loudness to consider */
706  n = nb_powers;
707  nb_pow = LRA_HIGHER_PRC * nb_powers / 100. + 0.5;
708  for (i = HIST_SIZE - 1; i >= 0; i--) {
709  n -= ebur128->i3000.histogram[i].count;
710  if (n < nb_pow) {
711  ebur128->lra_high = ebur128->i3000.histogram[i].loudness;
712  break;
713  }
714  }
715 
716  // XXX: show low & high on the graph?
717  ebur128->loudness_range = ebur128->lra_high - ebur128->lra_low;
718  }
719  }
720 
721  /* dual-mono correction */
722  if (nb_channels == 1 && ebur128->dual_mono) {
723  loudness_400 -= ebur128->pan_law;
724  loudness_3000 -= ebur128->pan_law;
725  }
726 
727 #define LOG_FMT "M:%6.1f S:%6.1f I:%6.1f LUFS LRA:%6.1f LU"
728 
729  /* push one video frame */
730  if (ebur128->do_video) {
731  int x, y, ret;
732  uint8_t *p;
733 
734  const int y_loudness_lu_graph = lu_to_y(ebur128, loudness_3000 + 23);
735  const int y_loudness_lu_gauge = lu_to_y(ebur128, loudness_400 + 23);
736 
737  /* draw the graph using the short-term loudness */
738  p = pic->data[0] + ebur128->graph.y*pic->linesize[0] + ebur128->graph.x*3;
739  for (y = 0; y < ebur128->graph.h; y++) {
740  const uint8_t *c = get_graph_color(ebur128, y_loudness_lu_graph, y);
741 
742  memmove(p, p + 3, (ebur128->graph.w - 1) * 3);
743  memcpy(p + (ebur128->graph.w - 1) * 3, c, 3);
744  p += pic->linesize[0];
745  }
746 
747  /* draw the gauge using the momentary loudness */
748  p = pic->data[0] + ebur128->gauge.y*pic->linesize[0] + ebur128->gauge.x*3;
749  for (y = 0; y < ebur128->gauge.h; y++) {
750  const uint8_t *c = get_graph_color(ebur128, y_loudness_lu_gauge, y);
751 
752  for (x = 0; x < ebur128->gauge.w; x++)
753  memcpy(p + x*3, c, 3);
754  p += pic->linesize[0];
755  }
756 
757  /* draw textual info */
758  drawtext(pic, PAD, PAD - PAD/2, FONT16, font_colors,
759  LOG_FMT " ", // padding to erase trailing characters
760  loudness_400, loudness_3000,
761  ebur128->integrated_loudness, ebur128->loudness_range);
762 
763  /* set pts and push frame */
764  pic->pts = pts;
765  ret = ff_filter_frame(outlink, av_frame_clone(pic));
766  if (ret < 0)
767  return ret;
768  }
769 
770  if (ebur128->metadata) { /* happens only once per filter_frame call */
771  char metabuf[128];
772 #define META_PREFIX "lavfi.r128."
773 
774 #define SET_META(name, var) do { \
775  snprintf(metabuf, sizeof(metabuf), "%.3f", var); \
776  av_dict_set(&insamples->metadata, name, metabuf, 0); \
777 } while (0)
778 
779 #define SET_META_PEAK(name, ptype) do { \
780  if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \
781  char key[64]; \
782  for (ch = 0; ch < nb_channels; ch++) { \
783  snprintf(key, sizeof(key), \
784  META_PREFIX AV_STRINGIFY(name) "_peaks_ch%d", ch); \
785  SET_META(key, ebur128->name##_peaks[ch]); \
786  } \
787  } \
788 } while (0)
789 
790  SET_META(META_PREFIX "M", loudness_400);
791  SET_META(META_PREFIX "S", loudness_3000);
793  SET_META(META_PREFIX "LRA", ebur128->loudness_range);
794  SET_META(META_PREFIX "LRA.low", ebur128->lra_low);
795  SET_META(META_PREFIX "LRA.high", ebur128->lra_high);
796 
798  SET_META_PEAK(true, TRUE);
799  }
800 
801  av_log(ctx, ebur128->loglevel, "t: %-10s " LOG_FMT,
802  av_ts2timestr(pts, &outlink->time_base),
803  loudness_400, loudness_3000,
804  ebur128->integrated_loudness, ebur128->loudness_range);
805 
806 #define PRINT_PEAKS(str, sp, ptype) do { \
807  if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \
808  av_log(ctx, ebur128->loglevel, " " str ":"); \
809  for (ch = 0; ch < nb_channels; ch++) \
810  av_log(ctx, ebur128->loglevel, " %5.1f", DBFS(sp[ch])); \
811  av_log(ctx, ebur128->loglevel, " dBFS"); \
812  } \
813 } while (0)
814 
815  PRINT_PEAKS("SPK", ebur128->sample_peaks, SAMPLES);
816  PRINT_PEAKS("FTPK", ebur128->true_peaks_per_frame, TRUE);
817  PRINT_PEAKS("TPK", ebur128->true_peaks, TRUE);
818  av_log(ctx, ebur128->loglevel, "\n");
819  }
820  }
821 
822  return ff_filter_frame(ctx->outputs[ebur128->do_video], insamples);
823 }
824 
826 {
827  EBUR128Context *ebur128 = ctx->priv;
830  AVFilterLink *inlink = ctx->inputs[0];
831  AVFilterLink *outlink = ctx->outputs[0];
832  int ret;
833 
835  static const int input_srate[] = {48000, -1}; // ITU-R BS.1770 provides coeff only for 48kHz
836  static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE };
837 
838  /* set optional output video format */
839  if (ebur128->do_video) {
840  formats = ff_make_format_list(pix_fmts);
841  if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
842  return ret;
843  outlink = ctx->outputs[1];
844  }
845 
846  /* set input and output audio formats
847  * Note: ff_set_common_* functions are not used because they affect all the
848  * links, and thus break the video format negotiation */
849  formats = ff_make_format_list(sample_fmts);
850  if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0 ||
851  (ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
852  return ret;
853 
854  layouts = ff_all_channel_layouts();
855  if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0 ||
856  (ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts)) < 0)
857  return ret;
858 
859  formats = ff_make_format_list(input_srate);
860  if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0 ||
861  (ret = ff_formats_ref(formats, &outlink->in_samplerates)) < 0)
862  return ret;
863 
864  return 0;
865 }
866 
868 {
869  int i;
870  EBUR128Context *ebur128 = ctx->priv;
871 
872  /* dual-mono correction */
873  if (ebur128->nb_channels == 1 && ebur128->dual_mono) {
874  ebur128->i400.rel_threshold -= ebur128->pan_law;
875  ebur128->i3000.rel_threshold -= ebur128->pan_law;
876  ebur128->lra_low -= ebur128->pan_law;
877  ebur128->lra_high -= ebur128->pan_law;
878  }
879 
880  av_log(ctx, AV_LOG_INFO, "Summary:\n\n"
881  " Integrated loudness:\n"
882  " I: %5.1f LUFS\n"
883  " Threshold: %5.1f LUFS\n\n"
884  " Loudness range:\n"
885  " LRA: %5.1f LU\n"
886  " Threshold: %5.1f LUFS\n"
887  " LRA low: %5.1f LUFS\n"
888  " LRA high: %5.1f LUFS",
889  ebur128->integrated_loudness, ebur128->i400.rel_threshold,
890  ebur128->loudness_range, ebur128->i3000.rel_threshold,
891  ebur128->lra_low, ebur128->lra_high);
892 
893 #define PRINT_PEAK_SUMMARY(str, sp, ptype) do { \
894  int ch; \
895  double maxpeak; \
896  maxpeak = 0.0; \
897  if (ebur128->peak_mode & PEAK_MODE_ ## ptype ## _PEAKS) { \
898  for (ch = 0; ch < ebur128->nb_channels; ch++) \
899  maxpeak = FFMAX(maxpeak, sp[ch]); \
900  av_log(ctx, AV_LOG_INFO, "\n\n " str " peak:\n" \
901  " Peak: %5.1f dBFS", \
902  DBFS(maxpeak)); \
903  } \
904 } while (0)
905 
906  PRINT_PEAK_SUMMARY("Sample", ebur128->sample_peaks, SAMPLES);
907  PRINT_PEAK_SUMMARY("True", ebur128->true_peaks, TRUE);
908  av_log(ctx, AV_LOG_INFO, "\n");
909 
910  av_freep(&ebur128->y_line_ref);
911  av_freep(&ebur128->ch_weighting);
912  av_freep(&ebur128->true_peaks);
913  av_freep(&ebur128->sample_peaks);
914  av_freep(&ebur128->true_peaks_per_frame);
915  av_freep(&ebur128->i400.histogram);
916  av_freep(&ebur128->i3000.histogram);
917  for (i = 0; i < ebur128->nb_channels; i++) {
918  av_freep(&ebur128->i400.cache[i]);
919  av_freep(&ebur128->i3000.cache[i]);
920  }
921  for (i = 0; i < ctx->nb_outputs; i++)
922  av_freep(&ctx->output_pads[i].name);
923  av_frame_free(&ebur128->outpicref);
924 #if CONFIG_SWRESAMPLE
925  av_freep(&ebur128->swr_buf);
926  swr_free(&ebur128->swr_ctx);
927 #endif
928 }
929 
930 static const AVFilterPad ebur128_inputs[] = {
931  {
932  .name = "default",
933  .type = AVMEDIA_TYPE_AUDIO,
934  .filter_frame = filter_frame,
935  .config_props = config_audio_input,
936  },
937  { NULL }
938 };
939 
941  .name = "ebur128",
942  .description = NULL_IF_CONFIG_SMALL("EBU R128 scanner."),
943  .priv_size = sizeof(EBUR128Context),
944  .init = init,
945  .uninit = uninit,
947  .inputs = ebur128_inputs,
948  .outputs = NULL,
949  .priv_class = &ebur128_class,
951 };
#define NULL
Definition: coverity.c:32
static struct hist_entry * get_histogram(void)
Definition: f_ebur128.c:444
This structure describes decoded (raw) audio or video data.
Definition: frame.h:194
int scale_range
the range of LU values according to the meter
Definition: f_ebur128.c:115
static int query_formats(AVFilterContext *ctx)
Definition: f_ebur128.c:825
double lra_low
Definition: f_ebur128.c:138
AVOption.
Definition: opt.h:246
double * true_peaks_per_frame
true peaks in a frame per channel
Definition: f_ebur128.c:100
const char * fmt
Definition: avisynth_c.h:769
#define LRA_HIGHER_PRC
struct hist_entry * histogram
histogram of the powers, used to compute LRA and I
Definition: f_ebur128.c:88
static int config_video_output(AVFilterLink *outlink)
Definition: f_ebur128.c:256
int sample_count
sample count used for refresh frequency, reset at refresh
Definition: f_ebur128.c:122
#define I_GATE_THRES
Main libavfilter public API header.
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:64
int y_zero_lu
the y value (pixel position) for 0 LU
Definition: f_ebur128.c:116
static int config_audio_output(AVFilterLink *outlink)
Definition: f_ebur128.c:367
static int lu_to_y(const EBUR128Context *ebur128, double v)
Definition: f_ebur128.c:196
#define COMPUTE_LOUDNESS(m, time)
static av_cold int init(AVFilterContext *ctx)
Definition: f_ebur128.c:458
int cache_pos
focus on the last added bin in the cache array
Definition: f_ebur128.c:82
#define SET_META_PEAK(name, ptype)
double y[MAX_CHANNELS *3]
3 pre-filter samples cache for each channel
Definition: f_ebur128.c:127
#define vsnprintf
Definition: snprintf.h:36
AVFilter ff_af_ebur128
Definition: f_ebur128.c:940
#define AV_CH_LOW_FREQUENCY_2
const uint8_t avpriv_vga16_font[4096]
int do_video
1 if video output enabled, 0 otherwise
Definition: f_ebur128.c:108
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:92
static const AVOption ebur128_options[]
Definition: f_ebur128.c:157
#define HIST_SIZE
Definition: f_ebur128.c:65
#define sample
#define PRINT_PEAKS(str, sp, ptype)
int nb_channels
number of channels in the input
Definition: f_ebur128.c:120
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:230
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define F
Definition: f_ebur128.c:156
#define FONT16
Definition: f_ebur128.c:205
AVFILTER_DEFINE_CLASS(ebur128)
int metadata
whether or not to inject loudness results in frames
Definition: f_ebur128.c:142
const char * name
Pad name.
Definition: internal.h:60
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:331
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define HIST_GRAIN
defines histogram precision
Definition: f_ebur128.c:64
Public dictionary API.
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:435
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1125
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:334
#define M(a, b)
Definition: vp3dsp.c:44
int loudness
Definition: normalize.py:20
uint8_t
av_cold struct SwrContext * swr_alloc(void)
Allocate SwrContext.
Definition: options.c:149
#define av_cold
Definition: attributes.h:82
static void drawtext(AVFrame *pic, int x, int y, int ftid, const uint8_t *color, const char *fmt,...)
Definition: f_ebur128.c:212
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
Definition: f_ebur128.c:542
AVOptions.
double sum_kept_powers
sum of the powers (weighted sums) above absolute threshold
Definition: f_ebur128.c:86
timestamp utils, mostly useful for debugging/logging purposes
static void drawline(AVFrame *pic, int x, int y, int len, int step)
Definition: f_ebur128.c:245
double * cache[MAX_CHANNELS]
window of filtered samples (N ms)
Definition: f_ebur128.c:81
struct integrator i3000
3s integrator, used for Short term loudness (S), and Loudness Range (LRA)
Definition: f_ebur128.c:133
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_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),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){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) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;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)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8: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);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
int y
Definition: f_ebur128.c:91
double integrated_loudness
integrated loudness in LUFS (I)
Definition: f_ebur128.c:136
double * true_peaks
true peaks per channel
Definition: f_ebur128.c:98
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:287
static const uint8_t font_colors[]
Definition: f_ebur128.c:207
#define AV_CH_LOW_FREQUENCY
int meter
select a EBU mode between +9 and +18
Definition: f_ebur128.c:114
static int flags
Definition: log.c:57
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
Definition: avfilter.h:111
A histogram is an array of HIST_SIZE hist_entry storing all the energies recorded (with an accuracy o...
Definition: f_ebur128.c:74
AVFrame * outpicref
output picture reference, updated regularly
Definition: f_ebur128.c:113
#define av_log(a,...)
#define MAX_CHANNELS
Definition: f_ebur128.c:46
A filter pad used for either input or output.
Definition: internal.h:54
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
libswresample public header
double * sample_peaks
sample peaks per channel
Definition: f_ebur128.c:99
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
const uint8_t avpriv_cga_font[2048]
Definition: xga_font_data.c:29
int count
how many times the corresponding value occurred
Definition: f_ebur128.c:75
static const uint16_t mask[17]
Definition: lzw.c:38
#define S(s, c, i)
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:163
#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
unsigned nb_outputs
number of output pads
Definition: avfilter.h:336
The libswresample context.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:179
void * priv
private data for use by the filter
Definition: avfilter.h:338
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:558
Definition: graph2dot.c:48
simple assert() macros that are a bit more flexible than ISO C assert().
#define MOVE_TO_NEXT_CACHED_ENTRY(time)
#define FFMAX(a, b)
Definition: common.h:94
struct integrator i400
400ms integrator, used for Momentary loudness (M), and Integrated loudness (I)
Definition: f_ebur128.c:132
static av_cold void uninit(AVFilterContext *ctx)
Definition: f_ebur128.c:867
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
#define I3000_BINS
Definition: f_ebur128.c:131
int * y_line_ref
y reference values for drawing the LU lines in the graph and the gauge
Definition: f_ebur128.c:117
struct rect graph
rectangle for the main graph in the center
Definition: f_ebur128.c:111
audio channel layout utility functions
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:440
double loudness
L = -0.691 + 10 * log10(E)
Definition: f_ebur128.c:77
AVFormatContext * ctx
Definition: movenc.c:48
#define LOG_FMT
double rel_threshold
relative threshold
Definition: f_ebur128.c:85
#define TRUE
Definition: windows2linux.h:33
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define LRA_LOWER_PRC
int n
Definition: avisynth_c.h:684
double loudness_range
loudness range in LU (LRA)
Definition: f_ebur128.c:137
#define ENERGY(loudness)
Definition: f_ebur128.c:440
static const AVFilterPad outputs[]
Definition: af_afftfilt.c:389
#define HIST_POS(power)
Definition: f_ebur128.c:515
#define OFFSET(x)
Definition: f_ebur128.c:153
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (w...
Definition: formats.c:401
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:489
A list of supported channel layouts.
Definition: formats.h:85
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
static const AVFilterPad inputs[]
Definition: af_afftfilt.c:379
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:237
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:225
#define ABS_THRES
silence gate: we discard anything below this absolute (LUFS) threshold
Definition: f_ebur128.c:62
av_cold void swr_free(SwrContext **ss)
Free the given SwrContext and set the pointer to NULL.
Definition: swresample.c:137
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:282
int x
Definition: f_ebur128.c:91
void * buf
Definition: avisynth_c.h:690
int nb_kept_powers
number of sum above absolute threshold
Definition: f_ebur128.c:87
Describe the class of an AVClass context structure.
Definition: log.h:67
#define SAMPLES
Filter definition.
Definition: avfilter.h:144
Definition: f_ebur128.c:91
Rational number (pair of numerator and denominator).
Definition: rational.h:58
const char * name
Filter name.
Definition: avfilter.h:148
int h
Definition: f_ebur128.c:91
offset must point to two consecutive integers
Definition: opt.h:233
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:706
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:335
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:266
#define LOUDNESS(energy)
Definition: f_ebur128.c:441
static int64_t pts
Global timestamp for the audio frames.
int dual_mono
whether or not to treat single channel input files as dual-mono
Definition: f_ebur128.c:143
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:208
struct rect text
rectangle for the LU legend on the left
Definition: f_ebur128.c:110
#define META_PREFIX
internal math functions header
if(ret< 0)
Definition: vf_mcdeint.c:282
static const AVFilterPad ebur128_inputs[]
Definition: f_ebur128.c:930
int h
size of the video output
Definition: f_ebur128.c:109
#define PRINT_PEAK_SUMMARY(str, sp, ptype)
uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index)
Get the channel with the given index in channel_layout.
static double c[64]
struct rect gauge
rectangle for the gauge on the right
Definition: f_ebur128.c:112
int w
Definition: f_ebur128.c:91
#define DRAW_RECT(r)
#define I400_BINS
Definition: f_ebur128.c:130
static int config_audio_input(AVFilterLink *inlink)
Definition: f_ebur128.c:349
#define A
Definition: f_ebur128.c:154
#define FONT8
Definition: f_ebur128.c:204
static int gate_update(struct integrator *integ, double power, double loudness, int gate_thres)
Definition: f_ebur128.c:519
int loglevel
log level for frame logging
Definition: f_ebur128.c:141
double x[MAX_CHANNELS *3]
3 input samples cache for each channel
Definition: f_ebur128.c:126
#define V
Definition: f_ebur128.c:155
int len
#define FILTER(Y, X, name)
double lra_high
low and high LRA values
Definition: f_ebur128.c:138
A list of supported formats for one end of a filter link.
Definition: formats.h:64
#define PAD
An instance of a filter.
Definition: avfilter.h:323
#define LRA_GATE_THRES
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:701
double sum[MAX_CHANNELS]
sum of the last N ms filtered samples (cache content)
Definition: f_ebur128.c:83
double z[MAX_CHANNELS *3]
3 RLB-filter samples cache for each channel
Definition: f_ebur128.c:128
#define av_freep(p)
#define SET_META(name, var)
int peak_mode
enabled peak modes
Definition: f_ebur128.c:97
#define av_malloc_array(a, b)
formats
Definition: signature.h:48
double * ch_weighting
channel weighting mapping
Definition: f_ebur128.c:121
int nb_channels
double pan_law
pan law value used to calculate dual-mono measurements
Definition: f_ebur128.c:144
internal API functions
int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
Definition: opt.c:676
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
Definition: internal.h:293
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:260
static const uint8_t graph_colors[]
Definition: f_ebur128.c:176
for(j=16;j >0;--j)
CGA/EGA/VGA ROM font data.
av_cold int swr_init(struct SwrContext *s)
Initialize context after user parameters have been set.
Definition: swresample.c:152
double energy
E = 10^((L + 0.691) / 10)
Definition: f_ebur128.c:76
#define BACK_MASK
int filled
1 if the cache is completely filled, 0 otherwise
Definition: f_ebur128.c:84
static const uint8_t * get_graph_color(const EBUR128Context *ebur128, int v, int y)
Definition: f_ebur128.c:187