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_opt_max; ///< the y value (pixel position) for 1 LU
118  int y_opt_min; ///< the y value (pixel position) for -1 LU
119  int *y_line_ref; ///< y reference values for drawing the LU lines in the graph and the gauge
120 
121  /* audio */
122  int nb_channels; ///< number of channels in the input
123  double *ch_weighting; ///< channel weighting mapping
124  int sample_count; ///< sample count used for refresh frequency, reset at refresh
125 
126  /* Filter caches.
127  * The mult by 3 in the following is for X[i], X[i-1] and X[i-2] */
128  double x[MAX_CHANNELS * 3]; ///< 3 input samples cache for each channel
129  double y[MAX_CHANNELS * 3]; ///< 3 pre-filter samples cache for each channel
130  double z[MAX_CHANNELS * 3]; ///< 3 RLB-filter samples cache for each channel
131 
132 #define I400_BINS (48000 * 4 / 10)
133 #define I3000_BINS (48000 * 3)
134  struct integrator i400; ///< 400ms integrator, used for Momentary loudness (M), and Integrated loudness (I)
135  struct integrator i3000; ///< 3s integrator, used for Short term loudness (S), and Loudness Range (LRA)
136 
137  /* I and LRA specific */
138  double integrated_loudness; ///< integrated loudness in LUFS (I)
139  double loudness_range; ///< loudness range in LU (LRA)
140  double lra_low, lra_high; ///< low and high LRA values
141 
142  /* misc */
143  int loglevel; ///< log level for frame logging
144  int metadata; ///< whether or not to inject loudness results in frames
145  int dual_mono; ///< whether or not to treat single channel input files as dual-mono
146  double pan_law; ///< pan law value used to calculate dual-mono measurements
147  int target; ///< target level in LUFS used to set relative zero LU in visualization
148  int gauge_type; ///< whether gauge shows momentary or short
149  int scale; ///< display scale type of statistics
151 
152 enum {
156 };
157 
158 enum {
161 };
162 
163 enum {
166 };
167 
168 #define OFFSET(x) offsetof(EBUR128Context, x)
169 #define A AV_OPT_FLAG_AUDIO_PARAM
170 #define V AV_OPT_FLAG_VIDEO_PARAM
171 #define F AV_OPT_FLAG_FILTERING_PARAM
172 static const AVOption ebur128_options[] = {
173  { "video", "set video output", OFFSET(do_video), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, V|F },
174  { "size", "set video size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str = "640x480"}, 0, 0, V|F },
175  { "meter", "set scale meter (+9 to +18)", OFFSET(meter), AV_OPT_TYPE_INT, {.i64 = 9}, 9, 18, V|F },
176  { "framelog", "force frame logging level", OFFSET(loglevel), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, A|V|F, "level" },
177  { "info", "information logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_INFO}, INT_MIN, INT_MAX, A|V|F, "level" },
178  { "verbose", "verbose logging level", 0, AV_OPT_TYPE_CONST, {.i64 = AV_LOG_VERBOSE}, INT_MIN, INT_MAX, A|V|F, "level" },
179  { "metadata", "inject metadata in the filtergraph", OFFSET(metadata), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, A|V|F },
180  { "peak", "set peak mode", OFFSET(peak_mode), AV_OPT_TYPE_FLAGS, {.i64 = PEAK_MODE_NONE}, 0, INT_MAX, A|F, "mode" },
181  { "none", "disable any peak mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_NONE}, INT_MIN, INT_MAX, A|F, "mode" },
182  { "sample", "enable peak-sample mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_SAMPLES_PEAKS}, INT_MIN, INT_MAX, A|F, "mode" },
183  { "true", "enable true-peak mode", 0, AV_OPT_TYPE_CONST, {.i64 = PEAK_MODE_TRUE_PEAKS}, INT_MIN, INT_MAX, A|F, "mode" },
184  { "dualmono", "treat mono input files as dual-mono", OFFSET(dual_mono), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, A|F },
185  { "panlaw", "set a specific pan law for dual-mono files", OFFSET(pan_law), AV_OPT_TYPE_DOUBLE, {.dbl = -3.01029995663978}, -10.0, 0.0, A|F },
186  { "target", "set a specific target level in LUFS (-23 to 0)", OFFSET(target), AV_OPT_TYPE_INT, {.i64 = -23}, -23, 0, V|F },
187  { "gauge", "set gauge display type", OFFSET(gauge_type), AV_OPT_TYPE_INT, {.i64 = 0 }, GAUGE_TYPE_MOMENTARY, GAUGE_TYPE_SHORTTERM, V|F, "gaugetype" },
188  { "momentary", "display momentary value", 0, AV_OPT_TYPE_CONST, {.i64 = GAUGE_TYPE_MOMENTARY}, INT_MIN, INT_MAX, V|F, "gaugetype" },
189  { "m", "display momentary value", 0, AV_OPT_TYPE_CONST, {.i64 = GAUGE_TYPE_MOMENTARY}, INT_MIN, INT_MAX, V|F, "gaugetype" },
190  { "shortterm", "display short-term value", 0, AV_OPT_TYPE_CONST, {.i64 = GAUGE_TYPE_SHORTTERM}, INT_MIN, INT_MAX, V|F, "gaugetype" },
191  { "s", "display short-term value", 0, AV_OPT_TYPE_CONST, {.i64 = GAUGE_TYPE_SHORTTERM}, INT_MIN, INT_MAX, V|F, "gaugetype" },
192  { "scale", "sets display method for the stats", OFFSET(scale), AV_OPT_TYPE_INT, {.i64 = 0}, SCALE_TYPE_ABSOLUTE, SCALE_TYPE_RELATIVE, V|F, "scaletype" },
193  { "absolute", "display absolute values (LUFS)", 0, AV_OPT_TYPE_CONST, {.i64 = SCALE_TYPE_ABSOLUTE}, INT_MIN, INT_MAX, V|F, "scaletype" },
194  { "LUFS", "display absolute values (LUFS)", 0, AV_OPT_TYPE_CONST, {.i64 = SCALE_TYPE_ABSOLUTE}, INT_MIN, INT_MAX, V|F, "scaletype" },
195  { "relative", "display values relative to target (LU)", 0, AV_OPT_TYPE_CONST, {.i64 = SCALE_TYPE_RELATIVE}, INT_MIN, INT_MAX, V|F, "scaletype" },
196  { "LU", "display values relative to target (LU)", 0, AV_OPT_TYPE_CONST, {.i64 = SCALE_TYPE_RELATIVE}, INT_MIN, INT_MAX, V|F, "scaletype" },
197  { NULL },
198 };
199 
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;
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 uint16_t chl = av_channel_layout_extract_channel(outlink->channel_layout, i);
425  ebur128->ch_weighting[i] = 0;
426  } else if (chl & BACK_MASK) {
427  ebur128->ch_weighting[i] = 1.41;
428  } else {
429  ebur128->ch_weighting[i] = 1.0;
430  }
431 
432  if (!ebur128->ch_weighting[i])
433  continue;
434 
435  /* bins buffer for the two integration window (400ms and 3s) */
436  ebur128->i400.cache[i] = av_calloc(I400_BINS, sizeof(*ebur128->i400.cache[0]));
437  ebur128->i3000.cache[i] = av_calloc(I3000_BINS, sizeof(*ebur128->i3000.cache[0]));
438  if (!ebur128->i400.cache[i] || !ebur128->i3000.cache[i])
439  return AVERROR(ENOMEM);
440  }
441 
442 #if CONFIG_SWRESAMPLE
443  if (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS) {
444  int ret;
445 
446  ebur128->swr_buf = av_malloc_array(nb_channels, 19200 * sizeof(double));
447  ebur128->true_peaks = av_calloc(nb_channels, sizeof(*ebur128->true_peaks));
448  ebur128->true_peaks_per_frame = av_calloc(nb_channels, sizeof(*ebur128->true_peaks_per_frame));
449  ebur128->swr_ctx = swr_alloc();
450  if (!ebur128->swr_buf || !ebur128->true_peaks ||
451  !ebur128->true_peaks_per_frame || !ebur128->swr_ctx)
452  return AVERROR(ENOMEM);
453 
454  av_opt_set_int(ebur128->swr_ctx, "in_channel_layout", outlink->channel_layout, 0);
455  av_opt_set_int(ebur128->swr_ctx, "in_sample_rate", outlink->sample_rate, 0);
456  av_opt_set_sample_fmt(ebur128->swr_ctx, "in_sample_fmt", outlink->format, 0);
457 
458  av_opt_set_int(ebur128->swr_ctx, "out_channel_layout", outlink->channel_layout, 0);
459  av_opt_set_int(ebur128->swr_ctx, "out_sample_rate", 192000, 0);
460  av_opt_set_sample_fmt(ebur128->swr_ctx, "out_sample_fmt", outlink->format, 0);
461 
462  ret = swr_init(ebur128->swr_ctx);
463  if (ret < 0)
464  return ret;
465  }
466 #endif
467 
468  if (ebur128->peak_mode & PEAK_MODE_SAMPLES_PEAKS) {
469  ebur128->sample_peaks = av_calloc(nb_channels, sizeof(*ebur128->sample_peaks));
470  if (!ebur128->sample_peaks)
471  return AVERROR(ENOMEM);
472  }
473 
474  return 0;
475 }
476 
477 #define ENERGY(loudness) (ff_exp10(((loudness) + 0.691) / 10.))
478 #define LOUDNESS(energy) (-0.691 + 10 * log10(energy))
479 #define DBFS(energy) (20 * log10(energy))
480 
481 static struct hist_entry *get_histogram(void)
482 {
483  int i;
484  struct hist_entry *h = av_calloc(HIST_SIZE, sizeof(*h));
485 
486  if (!h)
487  return NULL;
488  for (i = 0; i < HIST_SIZE; i++) {
489  h[i].loudness = i / (double)HIST_GRAIN + ABS_THRES;
490  h[i].energy = ENERGY(h[i].loudness);
491  }
492  return h;
493 }
494 
496 {
497  EBUR128Context *ebur128 = ctx->priv;
498  AVFilterPad pad;
499  int ret;
500 
501  if (ebur128->loglevel != AV_LOG_INFO &&
502  ebur128->loglevel != AV_LOG_VERBOSE) {
503  if (ebur128->do_video || ebur128->metadata)
504  ebur128->loglevel = AV_LOG_VERBOSE;
505  else
506  ebur128->loglevel = AV_LOG_INFO;
507  }
508 
509  if (!CONFIG_SWRESAMPLE && (ebur128->peak_mode & PEAK_MODE_TRUE_PEAKS)) {
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 
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);
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 
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 
894 {
895  EBUR128Context *ebur128 = ctx->priv;
898  AVFilterLink *inlink = ctx->inputs[0];
899  AVFilterLink *outlink = ctx->outputs[0];
900  int ret;
901 
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 
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 
1009  .name = "ebur128",
1010  .description = NULL_IF_CONFIG_SMALL("EBU R128 scanner."),
1011  .priv_size = sizeof(EBUR128Context),
1012  .init = init,
1013  .uninit = uninit,
1015  .inputs = ebur128_inputs,
1016  .outputs = NULL,
1017  .priv_class = &ebur128_class,
1019 };
#define NULL
Definition: coverity.c:32
static struct hist_entry * get_histogram(void)
Definition: f_ebur128.c:481
int target
target level in LUFS used to set relative zero LU in visualization
Definition: f_ebur128.c:147
This structure describes decoded (raw) audio or video data.
Definition: frame.h:226
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:893
double lra_low
Definition: f_ebur128.c:140
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:291
int sample_count
sample count used for refresh frequency, reset at refresh
Definition: f_ebur128.c:124
#define I_GATE_THRES
Main libavfilter public API header.
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
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:404
static int lu_to_y(const EBUR128Context *ebur128, double v)
Definition: f_ebur128.c:231
#define COMPUTE_LOUDNESS(m, time)
static av_cold int init(AVFilterContext *ctx)
Definition: f_ebur128.c:495
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:129
#define vsnprintf
Definition: snprintf.h:36
AVFilter ff_af_ebur128
Definition: f_ebur128.c:1008
#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:99
static const AVOption ebur128_options[]
Definition: f_ebur128.c:172
#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:122
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
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:171
#define FONT16
Definition: f_ebur128.c:240
AVFILTER_DEFINE_CLASS(ebur128)
int metadata
whether or not to inject loudness results in frames
Definition: f_ebur128.c:144
const char * name
Pad name.
Definition: internal.h:60
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
#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:1080
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:349
#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:247
static int filter_frame(AVFilterLink *inlink, AVFrame *insamples)
Definition: f_ebur128.c:588
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:280
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:135
int y
Definition: f_ebur128.c:91
double integrated_loudness
integrated loudness in LUFS (I)
Definition: f_ebur128.c:138
double * true_peaks
true peaks per channel
Definition: f_ebur128.c:98
int scale
display scale type of statistics
Definition: f_ebur128.c:149
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:319
static const uint8_t font_colors[]
Definition: f_ebur128.c:242
#define AV_CH_LOW_FREQUENCY
int meter
select a EBU mode between +9 and +18
Definition: f_ebur128.c:114
#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
int y_opt_min
the y value (pixel position) for -1 LU
Definition: f_ebur128.c:118
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:202
#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:351
The libswresample context.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:568
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:134
static av_cold void uninit(AVFilterContext *ctx)
Definition: f_ebur128.c:935
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:113
#define I3000_BINS
Definition: f_ebur128.c:133
int * y_line_ref
y reference values for drawing the LU lines in the graph and the gauge
Definition: f_ebur128.c:119
int gauge_type
whether gauge shows momentary or short
Definition: f_ebur128.c:148
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
uint8_t w
Definition: llviddspenc.c:38
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:139
#define ENERGY(loudness)
Definition: f_ebur128.c:477
#define HIST_POS(power)
Definition: f_ebur128.c:561
#define OFFSET(x)
Definition: f_ebur128.c:168
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
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:540
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
A list of supported channel layouts.
Definition: formats.h:85
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
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:257
#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:314
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:350
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:266
#define LOUDNESS(energy)
Definition: f_ebur128.c:478
static int64_t pts
#define flags(name, subs,...)
Definition: cbs_av1.c:596
int dual_mono
whether or not to treat single channel input files as dual-mono
Definition: f_ebur128.c:145
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:240
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:279
static const AVFilterPad ebur128_inputs[]
Definition: f_ebur128.c:998
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:132
static int config_audio_input(AVFilterLink *inlink)
Definition: f_ebur128.c:386
#define A
Definition: f_ebur128.c:169
#define FONT8
Definition: f_ebur128.c:239
static int gate_update(struct integrator *integ, double power, double loudness, int gate_thres)
Definition: f_ebur128.c:565
int loglevel
log level for frame logging
Definition: f_ebur128.c:143
double x[MAX_CHANNELS *3]
3 input samples cache for each channel
Definition: f_ebur128.c:128
#define V
Definition: f_ebur128.c:170
int len
#define FILTER(Y, X, name)
double lra_high
low and high LRA values
Definition: f_ebur128.c:140
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:338
#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:130
#define SET_META(name, var)
#define av_freep(p)
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:123
int nb_channels
double pan_law
pan law value used to calculate dual-mono measurements
Definition: f_ebur128.c:146
int y_opt_max
the y value (pixel position) for 1 LU
Definition: f_ebur128.c:117
internal API functions
int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
Definition: opt.c:686
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
Definition: internal.h:285
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:292
static const uint8_t graph_colors[]
Definition: f_ebur128.c:202
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
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
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:221