FFmpeg  4.0
ebur128.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2011 Jan Kokemüller
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  * This file is based on libebur128 which is available at
21  * https://github.com/jiixyj/libebur128/
22  *
23  * Libebur128 has the following copyright:
24  *
25  * Permission is hereby granted, free of charge, to any person obtaining a copy
26  * of this software and associated documentation files (the "Software"), to deal
27  * in the Software without restriction, including without limitation the rights
28  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
29  * copies of the Software, and to permit persons to whom the Software is
30  * furnished to do so, subject to the following conditions:
31  *
32  * The above copyright notice and this permission notice shall be included in
33  * all copies or substantial portions of the Software.
34  *
35  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
36  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
37  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
38  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
39  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
40  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
41  * THE SOFTWARE.
42 */
43 
44 #include "ebur128.h"
45 
46 #include <float.h>
47 #include <limits.h>
48 #include <math.h> /* You may have to define _USE_MATH_DEFINES if you use MSVC */
49 
50 #include "libavutil/common.h"
51 #include "libavutil/mem.h"
52 #include "libavutil/thread.h"
53 
54 #define CHECK_ERROR(condition, errorcode, goto_point) \
55  if ((condition)) { \
56  errcode = (errorcode); \
57  goto goto_point; \
58  }
59 
60 #define ALMOST_ZERO 0.000001
61 
62 #define RELATIVE_GATE (-10.0)
63 #define RELATIVE_GATE_FACTOR pow(10.0, RELATIVE_GATE / 10.0)
64 #define MINUS_20DB pow(10.0, -20.0 / 10.0)
65 
67  /** Filtered audio data (used as ring buffer). */
68  double *audio_data;
69  /** Size of audio_data array. */
71  /** Current index for audio_data. */
73  /** How many frames are needed for a gating block. Will correspond to 400ms
74  * of audio at initialization, and 100ms after the first block (75% overlap
75  * as specified in the 2011 revision of BS1770). */
76  unsigned long needed_frames;
77  /** The channel map. Has as many elements as there are channels. */
79  /** How many samples fit in 100ms (rounded). */
80  unsigned long samples_in_100ms;
81  /** BS.1770 filter coefficients (nominator). */
82  double b[5];
83  /** BS.1770 filter coefficients (denominator). */
84  double a[5];
85  /** BS.1770 filter state. */
86  double v[5][5];
87  /** Histograms, used to calculate LRA. */
88  unsigned long *block_energy_histogram;
90  /** Keeps track of when a new short term block is needed. */
92  /** Maximum sample peak, one per channel */
93  double *sample_peak;
94  /** The maximum window duration in ms. */
95  unsigned long window;
96  /** Data pointer array for interleaved data */
97  void **data_ptrs;
98 };
99 
101 static DECLARE_ALIGNED(32, double, histogram_energies)[1000];
103 
105 {
106  int i, j;
107 
108  double f0 = 1681.974450955533;
109  double G = 3.999843853973347;
110  double Q = 0.7071752369554196;
111 
112  double K = tan(M_PI * f0 / (double) st->samplerate);
113  double Vh = pow(10.0, G / 20.0);
114  double Vb = pow(Vh, 0.4996667741545416);
115 
116  double pb[3] = { 0.0, 0.0, 0.0 };
117  double pa[3] = { 1.0, 0.0, 0.0 };
118  double rb[3] = { 1.0, -2.0, 1.0 };
119  double ra[3] = { 1.0, 0.0, 0.0 };
120 
121  double a0 = 1.0 + K / Q + K * K;
122  pb[0] = (Vh + Vb * K / Q + K * K) / a0;
123  pb[1] = 2.0 * (K * K - Vh) / a0;
124  pb[2] = (Vh - Vb * K / Q + K * K) / a0;
125  pa[1] = 2.0 * (K * K - 1.0) / a0;
126  pa[2] = (1.0 - K / Q + K * K) / a0;
127 
128  f0 = 38.13547087602444;
129  Q = 0.5003270373238773;
130  K = tan(M_PI * f0 / (double) st->samplerate);
131 
132  ra[1] = 2.0 * (K * K - 1.0) / (1.0 + K / Q + K * K);
133  ra[2] = (1.0 - K / Q + K * K) / (1.0 + K / Q + K * K);
134 
135  st->d->b[0] = pb[0] * rb[0];
136  st->d->b[1] = pb[0] * rb[1] + pb[1] * rb[0];
137  st->d->b[2] = pb[0] * rb[2] + pb[1] * rb[1] + pb[2] * rb[0];
138  st->d->b[3] = pb[1] * rb[2] + pb[2] * rb[1];
139  st->d->b[4] = pb[2] * rb[2];
140 
141  st->d->a[0] = pa[0] * ra[0];
142  st->d->a[1] = pa[0] * ra[1] + pa[1] * ra[0];
143  st->d->a[2] = pa[0] * ra[2] + pa[1] * ra[1] + pa[2] * ra[0];
144  st->d->a[3] = pa[1] * ra[2] + pa[2] * ra[1];
145  st->d->a[4] = pa[2] * ra[2];
146 
147  for (i = 0; i < 5; ++i) {
148  for (j = 0; j < 5; ++j) {
149  st->d->v[i][j] = 0.0;
150  }
151  }
152 }
153 
155 {
156  size_t i;
157  st->d->channel_map =
158  (int *) av_malloc_array(st->channels, sizeof(int));
159  if (!st->d->channel_map)
160  return AVERROR(ENOMEM);
161  if (st->channels == 4) {
162  st->d->channel_map[0] = FF_EBUR128_LEFT;
163  st->d->channel_map[1] = FF_EBUR128_RIGHT;
166  } else if (st->channels == 5) {
167  st->d->channel_map[0] = FF_EBUR128_LEFT;
168  st->d->channel_map[1] = FF_EBUR128_RIGHT;
169  st->d->channel_map[2] = FF_EBUR128_CENTER;
172  } else {
173  for (i = 0; i < st->channels; ++i) {
174  switch (i) {
175  case 0:
176  st->d->channel_map[i] = FF_EBUR128_LEFT;
177  break;
178  case 1:
179  st->d->channel_map[i] = FF_EBUR128_RIGHT;
180  break;
181  case 2:
182  st->d->channel_map[i] = FF_EBUR128_CENTER;
183  break;
184  case 3:
185  st->d->channel_map[i] = FF_EBUR128_UNUSED;
186  break;
187  case 4:
189  break;
190  case 5:
192  break;
193  default:
194  st->d->channel_map[i] = FF_EBUR128_UNUSED;
195  break;
196  }
197  }
198  }
199  return 0;
200 }
201 
202 static inline void init_histogram(void)
203 {
204  int i;
205  /* initialize static constants */
206  histogram_energy_boundaries[0] = pow(10.0, (-70.0 + 0.691) / 10.0);
207  for (i = 0; i < 1000; ++i) {
208  histogram_energies[i] =
209  pow(10.0, ((double) i / 10.0 - 69.95 + 0.691) / 10.0);
210  }
211  for (i = 1; i < 1001; ++i) {
213  pow(10.0, ((double) i / 10.0 - 70.0 + 0.691) / 10.0);
214  }
215 }
216 
218  unsigned long samplerate,
219  unsigned long window, int mode)
220 {
221  int errcode;
222  FFEBUR128State *st;
223 
224  st = (FFEBUR128State *) av_malloc(sizeof(FFEBUR128State));
225  CHECK_ERROR(!st, 0, exit)
226  st->d = (struct FFEBUR128StateInternal *)
227  av_malloc(sizeof(struct FFEBUR128StateInternal));
228  CHECK_ERROR(!st->d, 0, free_state)
229  st->channels = channels;
230  errcode = ebur128_init_channel_map(st);
231  CHECK_ERROR(errcode, 0, free_internal)
232 
233  st->d->sample_peak =
234  (double *) av_mallocz_array(channels, sizeof(double));
235  CHECK_ERROR(!st->d->sample_peak, 0, free_channel_map)
236 
237  st->samplerate = samplerate;
238  st->d->samples_in_100ms = (st->samplerate + 5) / 10;
239  st->mode = mode;
240  if ((mode & FF_EBUR128_MODE_S) == FF_EBUR128_MODE_S) {
241  st->d->window = FFMAX(window, 3000);
242  } else if ((mode & FF_EBUR128_MODE_M) == FF_EBUR128_MODE_M) {
243  st->d->window = FFMAX(window, 400);
244  } else {
245  goto free_sample_peak;
246  }
247  st->d->audio_data_frames = st->samplerate * st->d->window / 1000;
248  if (st->d->audio_data_frames % st->d->samples_in_100ms) {
249  /* round up to multiple of samples_in_100ms */
251  + st->d->samples_in_100ms
252  - (st->d->audio_data_frames % st->d->samples_in_100ms);
253  }
254  st->d->audio_data =
255  (double *) av_mallocz_array(st->d->audio_data_frames,
256  st->channels * sizeof(double));
257  CHECK_ERROR(!st->d->audio_data, 0, free_sample_peak)
258 
260 
262  av_mallocz(1000 * sizeof(unsigned long));
263  CHECK_ERROR(!st->d->block_energy_histogram, 0, free_audio_data)
265  av_mallocz(1000 * sizeof(unsigned long));
267  free_block_energy_histogram)
268  st->d->short_term_frame_counter = 0;
269 
270  /* the first block needs 400ms of audio data */
271  st->d->needed_frames = st->d->samples_in_100ms * 4;
272  /* start at the beginning of the buffer */
273  st->d->audio_data_index = 0;
274 
276  goto free_short_term_block_energy_histogram;
277 
278  st->d->data_ptrs = av_malloc_array(channels, sizeof(void *));
279  CHECK_ERROR(!st->d->data_ptrs, 0,
280  free_short_term_block_energy_histogram);
281 
282  return st;
283 
284 free_short_term_block_energy_histogram:
286 free_block_energy_histogram:
288 free_audio_data:
289  av_free(st->d->audio_data);
290 free_sample_peak:
291  av_free(st->d->sample_peak);
292 free_channel_map:
293  av_free(st->d->channel_map);
294 free_internal:
295  av_free(st->d);
296 free_state:
297  av_free(st);
298 exit:
299  return NULL;
300 }
301 
303 {
304  av_free((*st)->d->block_energy_histogram);
305  av_free((*st)->d->short_term_block_energy_histogram);
306  av_free((*st)->d->audio_data);
307  av_free((*st)->d->channel_map);
308  av_free((*st)->d->sample_peak);
309  av_free((*st)->d->data_ptrs);
310  av_free((*st)->d);
311  av_free(*st);
312  *st = NULL;
313 }
314 
315 #define EBUR128_FILTER(type, scaling_factor) \
316 static void ebur128_filter_##type(FFEBUR128State* st, const type** srcs, \
317  size_t src_index, size_t frames, \
318  int stride) { \
319  double* audio_data = st->d->audio_data + st->d->audio_data_index; \
320  size_t i, c; \
321  \
322  if ((st->mode & FF_EBUR128_MODE_SAMPLE_PEAK) == FF_EBUR128_MODE_SAMPLE_PEAK) { \
323  for (c = 0; c < st->channels; ++c) { \
324  double max = 0.0; \
325  for (i = 0; i < frames; ++i) { \
326  type v = srcs[c][src_index + i * stride]; \
327  if (v > max) { \
328  max = v; \
329  } else if (-v > max) { \
330  max = -1.0 * v; \
331  } \
332  } \
333  max /= scaling_factor; \
334  if (max > st->d->sample_peak[c]) st->d->sample_peak[c] = max; \
335  } \
336  } \
337  for (c = 0; c < st->channels; ++c) { \
338  int ci = st->d->channel_map[c] - 1; \
339  if (ci < 0) continue; \
340  else if (ci == FF_EBUR128_DUAL_MONO - 1) ci = 0; /*dual mono */ \
341  for (i = 0; i < frames; ++i) { \
342  st->d->v[ci][0] = (double) (srcs[c][src_index + i * stride] / scaling_factor) \
343  - st->d->a[1] * st->d->v[ci][1] \
344  - st->d->a[2] * st->d->v[ci][2] \
345  - st->d->a[3] * st->d->v[ci][3] \
346  - st->d->a[4] * st->d->v[ci][4]; \
347  audio_data[i * st->channels + c] = \
348  st->d->b[0] * st->d->v[ci][0] \
349  + st->d->b[1] * st->d->v[ci][1] \
350  + st->d->b[2] * st->d->v[ci][2] \
351  + st->d->b[3] * st->d->v[ci][3] \
352  + st->d->b[4] * st->d->v[ci][4]; \
353  st->d->v[ci][4] = st->d->v[ci][3]; \
354  st->d->v[ci][3] = st->d->v[ci][2]; \
355  st->d->v[ci][2] = st->d->v[ci][1]; \
356  st->d->v[ci][1] = st->d->v[ci][0]; \
357  } \
358  st->d->v[ci][4] = fabs(st->d->v[ci][4]) < DBL_MIN ? 0.0 : st->d->v[ci][4]; \
359  st->d->v[ci][3] = fabs(st->d->v[ci][3]) < DBL_MIN ? 0.0 : st->d->v[ci][3]; \
360  st->d->v[ci][2] = fabs(st->d->v[ci][2]) < DBL_MIN ? 0.0 : st->d->v[ci][2]; \
361  st->d->v[ci][1] = fabs(st->d->v[ci][1]) < DBL_MIN ? 0.0 : st->d->v[ci][1]; \
362  } \
363 }
364 EBUR128_FILTER(short, -((double)SHRT_MIN))
365 EBUR128_FILTER(int, -((double)INT_MIN))
366 EBUR128_FILTER(float, 1.0)
367 EBUR128_FILTER(double, 1.0)
368 
369 static double ebur128_energy_to_loudness(double energy)
370 {
371  return 10 * (log(energy) / log(10.0)) - 0.691;
372 }
373 
374 static size_t find_histogram_index(double energy)
375 {
376  size_t index_min = 0;
377  size_t index_max = 1000;
378  size_t index_mid;
379 
380  do {
381  index_mid = (index_min + index_max) / 2;
382  if (energy >= histogram_energy_boundaries[index_mid]) {
383  index_min = index_mid;
384  } else {
385  index_max = index_mid;
386  }
387  } while (index_max - index_min != 1);
388 
389  return index_min;
390 }
391 
393  size_t frames_per_block,
394  double *optional_output)
395 {
396  size_t i, c;
397  double sum = 0.0;
398  double channel_sum;
399  for (c = 0; c < st->channels; ++c) {
400  if (st->d->channel_map[c] == FF_EBUR128_UNUSED)
401  continue;
402  channel_sum = 0.0;
403  if (st->d->audio_data_index < frames_per_block * st->channels) {
404  for (i = 0; i < st->d->audio_data_index / st->channels; ++i) {
405  channel_sum += st->d->audio_data[i * st->channels + c] *
406  st->d->audio_data[i * st->channels + c];
407  }
408  for (i = st->d->audio_data_frames -
409  (frames_per_block -
410  st->d->audio_data_index / st->channels);
411  i < st->d->audio_data_frames; ++i) {
412  channel_sum += st->d->audio_data[i * st->channels + c] *
413  st->d->audio_data[i * st->channels + c];
414  }
415  } else {
416  for (i =
417  st->d->audio_data_index / st->channels - frames_per_block;
418  i < st->d->audio_data_index / st->channels; ++i) {
419  channel_sum +=
420  st->d->audio_data[i * st->channels +
421  c] * st->d->audio_data[i *
422  st->channels +
423  c];
424  }
425  }
426  if (st->d->channel_map[c] == FF_EBUR128_Mp110 ||
427  st->d->channel_map[c] == FF_EBUR128_Mm110 ||
428  st->d->channel_map[c] == FF_EBUR128_Mp060 ||
429  st->d->channel_map[c] == FF_EBUR128_Mm060 ||
430  st->d->channel_map[c] == FF_EBUR128_Mp090 ||
431  st->d->channel_map[c] == FF_EBUR128_Mm090) {
432  channel_sum *= 1.41;
433  } else if (st->d->channel_map[c] == FF_EBUR128_DUAL_MONO) {
434  channel_sum *= 2.0;
435  }
436  sum += channel_sum;
437  }
438  sum /= (double) frames_per_block;
439  if (optional_output) {
440  *optional_output = sum;
441  } else if (sum >= histogram_energy_boundaries[0]) {
443  }
444 }
445 
447  unsigned int channel_number, int value)
448 {
449  if (channel_number >= st->channels) {
450  return 1;
451  }
452  if (value == FF_EBUR128_DUAL_MONO &&
453  (st->channels != 1 || channel_number != 0)) {
454  return 1;
455  }
456  st->d->channel_map[channel_number] = value;
457  return 0;
458 }
459 
460 static int ebur128_energy_shortterm(FFEBUR128State * st, double *out);
461 #define FF_EBUR128_ADD_FRAMES_PLANAR(type) \
462 void ff_ebur128_add_frames_planar_##type(FFEBUR128State* st, const type** srcs, \
463  size_t frames, int stride) { \
464  size_t src_index = 0; \
465  while (frames > 0) { \
466  if (frames >= st->d->needed_frames) { \
467  ebur128_filter_##type(st, srcs, src_index, st->d->needed_frames, stride); \
468  src_index += st->d->needed_frames * stride; \
469  frames -= st->d->needed_frames; \
470  st->d->audio_data_index += st->d->needed_frames * st->channels; \
471  /* calculate the new gating block */ \
472  if ((st->mode & FF_EBUR128_MODE_I) == FF_EBUR128_MODE_I) { \
473  ebur128_calc_gating_block(st, st->d->samples_in_100ms * 4, NULL); \
474  } \
475  if ((st->mode & FF_EBUR128_MODE_LRA) == FF_EBUR128_MODE_LRA) { \
476  st->d->short_term_frame_counter += st->d->needed_frames; \
477  if (st->d->short_term_frame_counter == st->d->samples_in_100ms * 30) { \
478  double st_energy; \
479  ebur128_energy_shortterm(st, &st_energy); \
480  if (st_energy >= histogram_energy_boundaries[0]) { \
481  ++st->d->short_term_block_energy_histogram[ \
482  find_histogram_index(st_energy)]; \
483  } \
484  st->d->short_term_frame_counter = st->d->samples_in_100ms * 20; \
485  } \
486  } \
487  /* 100ms are needed for all blocks besides the first one */ \
488  st->d->needed_frames = st->d->samples_in_100ms; \
489  /* reset audio_data_index when buffer full */ \
490  if (st->d->audio_data_index == st->d->audio_data_frames * st->channels) { \
491  st->d->audio_data_index = 0; \
492  } \
493  } else { \
494  ebur128_filter_##type(st, srcs, src_index, frames, stride); \
495  st->d->audio_data_index += frames * st->channels; \
496  if ((st->mode & FF_EBUR128_MODE_LRA) == FF_EBUR128_MODE_LRA) { \
497  st->d->short_term_frame_counter += frames; \
498  } \
499  st->d->needed_frames -= frames; \
500  frames = 0; \
501  } \
502  } \
503 }
508 #define FF_EBUR128_ADD_FRAMES(type) \
509 void ff_ebur128_add_frames_##type(FFEBUR128State* st, const type* src, \
510  size_t frames) { \
511  int i; \
512  const type **buf = (const type**)st->d->data_ptrs; \
513  for (i = 0; i < st->channels; i++) \
514  buf[i] = src + i; \
515  ff_ebur128_add_frames_planar_##type(st, buf, frames, st->channels); \
516 }
520 FF_EBUR128_ADD_FRAMES(double)
521 
523  double *relative_threshold)
524 {
525  size_t i, j;
526  int above_thresh_counter = 0;
527  *relative_threshold = 0.0;
528 
529  for (i = 0; i < size; i++) {
530  unsigned long *block_energy_histogram = sts[i]->d->block_energy_histogram;
531  for (j = 0; j < 1000; ++j) {
532  *relative_threshold += block_energy_histogram[j] * histogram_energies[j];
533  above_thresh_counter += block_energy_histogram[j];
534  }
535  }
536 
537  if (above_thresh_counter != 0) {
538  *relative_threshold /= (double)above_thresh_counter;
539  *relative_threshold *= RELATIVE_GATE_FACTOR;
540  }
541 
542  return above_thresh_counter;
543 }
544 
545 static int ebur128_gated_loudness(FFEBUR128State ** sts, size_t size,
546  double *out)
547 {
548  double gated_loudness = 0.0;
549  double relative_threshold;
550  size_t above_thresh_counter;
551  size_t i, j, start_index;
552 
553  for (i = 0; i < size; i++)
554  if ((sts[i]->mode & FF_EBUR128_MODE_I) != FF_EBUR128_MODE_I)
555  return AVERROR(EINVAL);
556 
557  if (!ebur128_calc_relative_threshold(sts, size, &relative_threshold)) {
558  *out = -HUGE_VAL;
559  return 0;
560  }
561 
562  above_thresh_counter = 0;
563  if (relative_threshold < histogram_energy_boundaries[0]) {
564  start_index = 0;
565  } else {
566  start_index = find_histogram_index(relative_threshold);
567  if (relative_threshold > histogram_energies[start_index]) {
568  ++start_index;
569  }
570  }
571  for (i = 0; i < size; i++) {
572  for (j = start_index; j < 1000; ++j) {
573  gated_loudness += sts[i]->d->block_energy_histogram[j] *
575  above_thresh_counter += sts[i]->d->block_energy_histogram[j];
576  }
577  }
578  if (!above_thresh_counter) {
579  *out = -HUGE_VAL;
580  return 0;
581  }
582  gated_loudness /= (double) above_thresh_counter;
583  *out = ebur128_energy_to_loudness(gated_loudness);
584  return 0;
585 }
586 
588 {
589  double relative_threshold;
590 
592  return AVERROR(EINVAL);
593 
594  if (!ebur128_calc_relative_threshold(&st, 1, &relative_threshold)) {
595  *out = -70.0;
596  return 0;
597  }
598 
599  *out = ebur128_energy_to_loudness(relative_threshold);
600  return 0;
601 }
602 
604 {
605  return ebur128_gated_loudness(&st, 1, out);
606 }
607 
609  double *out)
610 {
611  return ebur128_gated_loudness(sts, size, out);
612 }
613 
615  size_t interval_frames, double *out)
616 {
617  if (interval_frames > st->d->audio_data_frames) {
618  return AVERROR(EINVAL);
619  }
620  ebur128_calc_gating_block(st, interval_frames, out);
621  return 0;
622 }
623 
624 static int ebur128_energy_shortterm(FFEBUR128State * st, double *out)
625 {
626  return ebur128_energy_in_interval(st, st->d->samples_in_100ms * 30,
627  out);
628 }
629 
631 {
632  double energy;
634  &energy);
635  if (error) {
636  return error;
637  } else if (energy <= 0.0) {
638  *out = -HUGE_VAL;
639  return 0;
640  }
641  *out = ebur128_energy_to_loudness(energy);
642  return 0;
643 }
644 
646 {
647  double energy;
648  int error = ebur128_energy_shortterm(st, &energy);
649  if (error) {
650  return error;
651  } else if (energy <= 0.0) {
652  *out = -HUGE_VAL;
653  return 0;
654  }
655  *out = ebur128_energy_to_loudness(energy);
656  return 0;
657 }
658 
660  unsigned long window, double *out)
661 {
662  double energy;
663  size_t interval_frames = st->samplerate * window / 1000;
664  int error = ebur128_energy_in_interval(st, interval_frames, &energy);
665  if (error) {
666  return error;
667  } else if (energy <= 0.0) {
668  *out = -HUGE_VAL;
669  return 0;
670  }
671  *out = ebur128_energy_to_loudness(energy);
672  return 0;
673 }
674 
675 /* EBU - TECH 3342 */
677  double *out)
678 {
679  size_t i, j;
680  size_t stl_size;
681  double stl_power, stl_integrated;
682  /* High and low percentile energy */
683  double h_en, l_en;
684  unsigned long hist[1000] = { 0 };
685  size_t percentile_low, percentile_high;
686  size_t index;
687 
688  for (i = 0; i < size; ++i) {
689  if (sts[i]) {
690  if ((sts[i]->mode & FF_EBUR128_MODE_LRA) !=
691  FF_EBUR128_MODE_LRA) {
692  return AVERROR(EINVAL);
693  }
694  }
695  }
696 
697  stl_size = 0;
698  stl_power = 0.0;
699  for (i = 0; i < size; ++i) {
700  if (!sts[i])
701  continue;
702  for (j = 0; j < 1000; ++j) {
703  hist[j] += sts[i]->d->short_term_block_energy_histogram[j];
704  stl_size += sts[i]->d->short_term_block_energy_histogram[j];
705  stl_power += sts[i]->d->short_term_block_energy_histogram[j]
706  * histogram_energies[j];
707  }
708  }
709  if (!stl_size) {
710  *out = 0.0;
711  return 0;
712  }
713 
714  stl_power /= stl_size;
715  stl_integrated = MINUS_20DB * stl_power;
716 
717  if (stl_integrated < histogram_energy_boundaries[0]) {
718  index = 0;
719  } else {
720  index = find_histogram_index(stl_integrated);
721  if (stl_integrated > histogram_energies[index]) {
722  ++index;
723  }
724  }
725  stl_size = 0;
726  for (j = index; j < 1000; ++j) {
727  stl_size += hist[j];
728  }
729  if (!stl_size) {
730  *out = 0.0;
731  return 0;
732  }
733 
734  percentile_low = (size_t) ((stl_size - 1) * 0.1 + 0.5);
735  percentile_high = (size_t) ((stl_size - 1) * 0.95 + 0.5);
736 
737  stl_size = 0;
738  j = index;
739  while (stl_size <= percentile_low) {
740  stl_size += hist[j++];
741  }
742  l_en = histogram_energies[j - 1];
743  while (stl_size <= percentile_high) {
744  stl_size += hist[j++];
745  }
746  h_en = histogram_energies[j - 1];
747  *out =
748  ebur128_energy_to_loudness(h_en) -
749  ebur128_energy_to_loudness(l_en);
750  return 0;
751 }
752 
754 {
755  return ff_ebur128_loudness_range_multiple(&st, 1, out);
756 }
757 
759  unsigned int channel_number, double *out)
760 {
761  if ((st->mode & FF_EBUR128_MODE_SAMPLE_PEAK) !=
763  return AVERROR(EINVAL);
764  } else if (channel_number >= st->channels) {
765  return AVERROR(EINVAL);
766  }
767  *out = st->d->sample_peak[channel_number];
768  return 0;
769 }
#define NULL
Definition: coverity.c:32
static int ebur128_energy_shortterm(FFEBUR128State *st, double *out)
Definition: ebur128.c:624
int ff_ebur128_loudness_range_multiple(FFEBUR128State **sts, size_t size, double *out)
Get loudness range (LRA) in LU across multiple instances.
Definition: ebur128.c:676
static int ebur128_gated_loudness(FFEBUR128State **sts, size_t size, double *out)
Definition: ebur128.c:545
int size
Memory handling functions.
int * channel_map
The channel map.
Definition: ebur128.c:78
int ff_ebur128_loudness_global(FFEBUR128State *st, double *out)
Get global integrated loudness in LUFS.
Definition: ebur128.c:603
int ff_ebur128_loudness_global_multiple(FFEBUR128State **sts, size_t size, double *out)
Get global integrated loudness in LUFS across multiple instances.
Definition: ebur128.c:608
#define a0
Definition: regdef.h:46
channels
Definition: aptx.c:30
static int ebur128_calc_relative_threshold(FFEBUR128State **sts, size_t size, double *relative_threshold)
Definition: ebur128.c:522
void ff_ebur128_destroy(FFEBUR128State **st)
Destroy library state.
Definition: ebur128.c:302
size_t audio_data_frames
Size of audio_data array.
Definition: ebur128.c:70
can call ff_ebur128_loudness_global_* and ff_ebur128_relative_threshold
Definition: ebur128.h:89
a channel that is counted twice
Definition: ebur128.h:51
can call ff_ebur128_sample_peak
Definition: ebur128.h:93
double v[5][5]
BS.1770 filter state.
Definition: ebur128.c:86
static AVOnce histogram_init
Definition: ebur128.c:100
static size_t find_histogram_index(double energy)
Definition: ebur128.c:374
double b[5]
BS.1770 filter coefficients (nominator).
Definition: ebur128.c:82
#define MINUS_20DB
Definition: ebur128.c:64
int ff_ebur128_loudness_momentary(FFEBUR128State *st, double *out)
Get momentary loudness (last 400ms) in LUFS.
Definition: ebur128.c:630
#define FF_EBUR128_ADD_FRAMES_PLANAR(type)
Definition: ebur128.c:461
#define av_malloc(s)
int ff_ebur128_loudness_range(FFEBUR128State *st, double *out)
Get loudness range (LRA) of programme in LU.
Definition: ebur128.c:753
void ** data_ptrs
Data pointer array for interleaved data.
Definition: ebur128.c:97
static int ebur128_energy_in_interval(FFEBUR128State *st, size_t interval_frames, double *out)
Definition: ebur128.c:614
double * audio_data
Filtered audio data (used as ring buffer).
Definition: ebur128.c:68
unsigned long needed_frames
How many frames are needed for a gating block.
Definition: ebur128.c:76
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
static double histogram_energies[1000]
Definition: ebur128.c:101
double a[5]
BS.1770 filter coefficients (denominator).
Definition: ebur128.c:84
#define CHECK_ERROR(condition, errorcode, goto_point)
Definition: ebur128.c:54
struct FFEBUR128StateInternal * d
Internal state.
Definition: ebur128.h:107
#define AVOnce
Definition: thread.h:159
int ff_ebur128_loudness_window(FFEBUR128State *st, unsigned long window, double *out)
Get loudness of the specified window in LUFS.
Definition: ebur128.c:659
unsigned long samplerate
The sample rate.
Definition: ebur128.h:106
can call ff_ebur128_loudness_shortterm
Definition: ebur128.h:87
unused channel (for example LFE channel)
Definition: ebur128.h:40
static void ebur128_calc_gating_block(FFEBUR128State *st, size_t frames_per_block, double *optional_output)
Definition: ebur128.c:392
#define AVERROR(e)
Definition: error.h:43
itu M-110
Definition: ebur128.h:50
itu M-090
Definition: ebur128.h:57
static void init_histogram(void)
Definition: ebur128.c:202
int ff_ebur128_sample_peak(FFEBUR128State *st, unsigned int channel_number, double *out)
Get maximum sample peak of selected channel in float format.
Definition: ebur128.c:758
int ff_ebur128_loudness_shortterm(FFEBUR128State *st, double *out)
Get short-term loudness (last 3s) in LUFS.
Definition: ebur128.c:645
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
#define FFMAX(a, b)
Definition: common.h:94
unsigned long * short_term_block_energy_histogram
Definition: ebur128.c:89
can call ff_ebur128_loudness_range
Definition: ebur128.h:91
static double histogram_energy_boundaries[1001]
Definition: ebur128.c:102
itu M-060
Definition: ebur128.h:55
Contains information about the state of a loudness measurement.
Definition: ebur128.h:103
#define ra
Definition: regdef.h:57
static void ebur128_init_filter(FFEBUR128State *st)
Definition: ebur128.c:104
FFEBUR128State * ff_ebur128_init(unsigned int channels, unsigned long samplerate, unsigned long window, int mode)
Initialize library state.
Definition: ebur128.c:217
static void error(const char *err)
double * sample_peak
Maximum sample peak, one per channel.
Definition: ebur128.c:93
itu M+090
Definition: ebur128.h:56
itu M+060
Definition: ebur128.h:54
#define AV_ONCE_INIT
Definition: thread.h:160
int ff_ebur128_set_channel(FFEBUR128State *st, unsigned int channel_number, int value)
Set channel type.
Definition: ebur128.c:446
double value
Definition: eval.c:98
int index
Definition: gxfenc.c:89
unsigned int channels
The number of channels.
Definition: ebur128.h:105
int mode
The current mode.
Definition: ebur128.h:104
itu M+110
Definition: ebur128.h:48
#define RELATIVE_GATE_FACTOR
Definition: ebur128.c:63
size_t short_term_frame_counter
Keeps track of when a new short term block is needed.
Definition: ebur128.c:91
unsigned long window
The maximum window duration in ms.
Definition: ebur128.c:95
common internal and external API header
can call ff_ebur128_loudness_momentary
Definition: ebur128.h:85
#define G
Definition: huffyuvdsp.h:33
static double c[64]
int ff_ebur128_relative_threshold(FFEBUR128State *st, double *out)
Get relative threshold in LUFS.
Definition: ebur128.c:587
#define av_free(p)
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:162
#define EBUR128_FILTER(type, scaling_factor)
Definition: ebur128.c:315
FILE * out
Definition: movenc.c:54
unsigned long * block_energy_histogram
Histograms, used to calculate LRA.
Definition: ebur128.c:88
#define M_PI
Definition: mathematics.h:52
#define av_malloc_array(a, b)
static int ebur128_init_channel_map(FFEBUR128State *st)
Definition: ebur128.c:154
unsigned long samples_in_100ms
How many samples fit in 100ms (rounded).
Definition: ebur128.c:80
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
size_t audio_data_index
Current index for audio_data.
Definition: ebur128.c:72
libebur128 - a library for loudness measurement according to the EBU R128 standard.
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:191
#define FF_EBUR128_ADD_FRAMES(type)
Definition: ebur128.c:508