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/mem_internal.h"
53 #include "libavutil/thread.h"
54
55 #define CHECK_ERROR(condition, errorcode, goto_point) \
56 if ((condition)) { \
57 errcode = (errorcode); \
58 goto goto_point; \
59 }
60
61 #define ALMOST_ZERO 0.000001
62
63 #define RELATIVE_GATE (-10.0)
64 #define RELATIVE_GATE_FACTOR pow(10.0, RELATIVE_GATE / 10.0)
65 #define MINUS_20DB pow(10.0, -20.0 / 10.0)
66
67 struct FFEBUR128StateInternal {
68 /** Filtered audio data (used as ring buffer). */
69 double *audio_data;
70 /** Size of audio_data array. */
71 size_t audio_data_frames;
72 /** Current index for audio_data. */
73 size_t audio_data_index;
74 /** How many frames are needed for a gating block. Will correspond to 400ms
75 * of audio at initialization, and 100ms after the first block (75% overlap
76 * as specified in the 2011 revision of BS1770). */
77 unsigned long needed_frames;
78 /** The channel map. Has as many elements as there are channels. */
79 int *channel_map;
80 /** How many samples fit in 100ms (rounded). */
81 unsigned long samples_in_100ms;
82 /** BS.1770 filter coefficients (nominator). */
83 double b[5];
84 /** BS.1770 filter coefficients (denominator). */
85 double a[5];
86 /** BS.1770 filter state. */
87 double v[5][5];
88 /** Histograms, used to calculate LRA. */
89 unsigned long *block_energy_histogram;
90 unsigned long *short_term_block_energy_histogram;
91 /** Keeps track of when a new short term block is needed. */
92 size_t short_term_frame_counter;
93 /** Maximum sample peak, one per channel */
94 double *sample_peak;
95 /** The maximum window duration in ms. */
96 unsigned long window;
97 /** Data pointer array for interleaved data */
98 void **data_ptrs;
99 };
100
101 static AVOnce histogram_init = AV_ONCE_INIT;
102 static DECLARE_ALIGNED(32, double, histogram_energies)[1000];
103 static DECLARE_ALIGNED(32, double, histogram_energy_boundaries)[1001];
104
ebur128_init_filter(FFEBUR128State * st)105 static void ebur128_init_filter(FFEBUR128State * st)
106 {
107 int i, j;
108
109 double f0 = 1681.974450955533;
110 double G = 3.999843853973347;
111 double Q = 0.7071752369554196;
112
113 double K = tan(M_PI * f0 / (double) st->samplerate);
114 double Vh = pow(10.0, G / 20.0);
115 double Vb = pow(Vh, 0.4996667741545416);
116
117 double pb[3] = { 0.0, 0.0, 0.0 };
118 double pa[3] = { 1.0, 0.0, 0.0 };
119 double rb[3] = { 1.0, -2.0, 1.0 };
120 double ra[3] = { 1.0, 0.0, 0.0 };
121
122 double a0 = 1.0 + K / Q + K * K;
123 pb[0] = (Vh + Vb * K / Q + K * K) / a0;
124 pb[1] = 2.0 * (K * K - Vh) / a0;
125 pb[2] = (Vh - Vb * K / Q + K * K) / a0;
126 pa[1] = 2.0 * (K * K - 1.0) / a0;
127 pa[2] = (1.0 - K / Q + K * K) / a0;
128
129 f0 = 38.13547087602444;
130 Q = 0.5003270373238773;
131 K = tan(M_PI * f0 / (double) st->samplerate);
132
133 ra[1] = 2.0 * (K * K - 1.0) / (1.0 + K / Q + K * K);
134 ra[2] = (1.0 - K / Q + K * K) / (1.0 + K / Q + K * K);
135
136 st->d->b[0] = pb[0] * rb[0];
137 st->d->b[1] = pb[0] * rb[1] + pb[1] * rb[0];
138 st->d->b[2] = pb[0] * rb[2] + pb[1] * rb[1] + pb[2] * rb[0];
139 st->d->b[3] = pb[1] * rb[2] + pb[2] * rb[1];
140 st->d->b[4] = pb[2] * rb[2];
141
142 st->d->a[0] = pa[0] * ra[0];
143 st->d->a[1] = pa[0] * ra[1] + pa[1] * ra[0];
144 st->d->a[2] = pa[0] * ra[2] + pa[1] * ra[1] + pa[2] * ra[0];
145 st->d->a[3] = pa[1] * ra[2] + pa[2] * ra[1];
146 st->d->a[4] = pa[2] * ra[2];
147
148 for (i = 0; i < 5; ++i) {
149 for (j = 0; j < 5; ++j) {
150 st->d->v[i][j] = 0.0;
151 }
152 }
153 }
154
ebur128_init_channel_map(FFEBUR128State * st)155 static int ebur128_init_channel_map(FFEBUR128State * st)
156 {
157 size_t i;
158 st->d->channel_map =
159 (int *) av_malloc_array(st->channels, sizeof(*st->d->channel_map));
160 if (!st->d->channel_map)
161 return AVERROR(ENOMEM);
162 if (st->channels == 4) {
163 st->d->channel_map[0] = FF_EBUR128_LEFT;
164 st->d->channel_map[1] = FF_EBUR128_RIGHT;
165 st->d->channel_map[2] = FF_EBUR128_LEFT_SURROUND;
166 st->d->channel_map[3] = FF_EBUR128_RIGHT_SURROUND;
167 } else if (st->channels == 5) {
168 st->d->channel_map[0] = FF_EBUR128_LEFT;
169 st->d->channel_map[1] = FF_EBUR128_RIGHT;
170 st->d->channel_map[2] = FF_EBUR128_CENTER;
171 st->d->channel_map[3] = FF_EBUR128_LEFT_SURROUND;
172 st->d->channel_map[4] = FF_EBUR128_RIGHT_SURROUND;
173 } else {
174 for (i = 0; i < st->channels; ++i) {
175 switch (i) {
176 case 0:
177 st->d->channel_map[i] = FF_EBUR128_LEFT;
178 break;
179 case 1:
180 st->d->channel_map[i] = FF_EBUR128_RIGHT;
181 break;
182 case 2:
183 st->d->channel_map[i] = FF_EBUR128_CENTER;
184 break;
185 case 3:
186 st->d->channel_map[i] = FF_EBUR128_UNUSED;
187 break;
188 case 4:
189 st->d->channel_map[i] = FF_EBUR128_LEFT_SURROUND;
190 break;
191 case 5:
192 st->d->channel_map[i] = FF_EBUR128_RIGHT_SURROUND;
193 break;
194 default:
195 st->d->channel_map[i] = FF_EBUR128_UNUSED;
196 break;
197 }
198 }
199 }
200 return 0;
201 }
202
init_histogram(void)203 static inline void init_histogram(void)
204 {
205 int i;
206 /* initialize static constants */
207 histogram_energy_boundaries[0] = pow(10.0, (-70.0 + 0.691) / 10.0);
208 for (i = 0; i < 1000; ++i) {
209 histogram_energies[i] =
210 pow(10.0, ((double) i / 10.0 - 69.95 + 0.691) / 10.0);
211 }
212 for (i = 1; i < 1001; ++i) {
213 histogram_energy_boundaries[i] =
214 pow(10.0, ((double) i / 10.0 - 70.0 + 0.691) / 10.0);
215 }
216 }
217
ff_ebur128_init(unsigned int channels,unsigned long samplerate,unsigned long window,int mode)218 FFEBUR128State *ff_ebur128_init(unsigned int channels,
219 unsigned long samplerate,
220 unsigned long window, int mode)
221 {
222 int errcode;
223 FFEBUR128State *st;
224
225 st = (FFEBUR128State *) av_malloc(sizeof(*st));
226 CHECK_ERROR(!st, 0, exit)
227 st->d = (struct FFEBUR128StateInternal *)
228 av_malloc(sizeof(*st->d));
229 CHECK_ERROR(!st->d, 0, free_state)
230 st->channels = channels;
231 errcode = ebur128_init_channel_map(st);
232 CHECK_ERROR(errcode, 0, free_internal)
233
234 st->d->sample_peak =
235 (double *) av_mallocz_array(channels, sizeof(*st->d->sample_peak));
236 CHECK_ERROR(!st->d->sample_peak, 0, free_channel_map)
237
238 st->samplerate = samplerate;
239 st->d->samples_in_100ms = (st->samplerate + 5) / 10;
240 st->mode = mode;
241 if ((mode & FF_EBUR128_MODE_S) == FF_EBUR128_MODE_S) {
242 st->d->window = FFMAX(window, 3000);
243 } else if ((mode & FF_EBUR128_MODE_M) == FF_EBUR128_MODE_M) {
244 st->d->window = FFMAX(window, 400);
245 } else {
246 goto free_sample_peak;
247 }
248 st->d->audio_data_frames = st->samplerate * st->d->window / 1000;
249 if (st->d->audio_data_frames % st->d->samples_in_100ms) {
250 /* round up to multiple of samples_in_100ms */
251 st->d->audio_data_frames = st->d->audio_data_frames
252 + st->d->samples_in_100ms
253 - (st->d->audio_data_frames % st->d->samples_in_100ms);
254 }
255 st->d->audio_data =
256 (double *) av_mallocz_array(st->d->audio_data_frames,
257 st->channels * sizeof(*st->d->audio_data));
258 CHECK_ERROR(!st->d->audio_data, 0, free_sample_peak)
259
260 ebur128_init_filter(st);
261
262 st->d->block_energy_histogram =
263 av_mallocz(1000 * sizeof(*st->d->block_energy_histogram));
264 CHECK_ERROR(!st->d->block_energy_histogram, 0, free_audio_data)
265 st->d->short_term_block_energy_histogram =
266 av_mallocz(1000 * sizeof(*st->d->short_term_block_energy_histogram));
267 CHECK_ERROR(!st->d->short_term_block_energy_histogram, 0,
268 free_block_energy_histogram)
269 st->d->short_term_frame_counter = 0;
270
271 /* the first block needs 400ms of audio data */
272 st->d->needed_frames = st->d->samples_in_100ms * 4;
273 /* start at the beginning of the buffer */
274 st->d->audio_data_index = 0;
275
276 if (ff_thread_once(&histogram_init, &init_histogram) != 0)
277 goto free_short_term_block_energy_histogram;
278
279 st->d->data_ptrs = av_malloc_array(channels, sizeof(*st->d->data_ptrs));
280 CHECK_ERROR(!st->d->data_ptrs, 0,
281 free_short_term_block_energy_histogram);
282
283 return st;
284
285 free_short_term_block_energy_histogram:
286 av_free(st->d->short_term_block_energy_histogram);
287 free_block_energy_histogram:
288 av_free(st->d->block_energy_histogram);
289 free_audio_data:
290 av_free(st->d->audio_data);
291 free_sample_peak:
292 av_free(st->d->sample_peak);
293 free_channel_map:
294 av_free(st->d->channel_map);
295 free_internal:
296 av_free(st->d);
297 free_state:
298 av_free(st);
299 exit:
300 return NULL;
301 }
302
ff_ebur128_destroy(FFEBUR128State ** st)303 void ff_ebur128_destroy(FFEBUR128State ** st)
304 {
305 av_free((*st)->d->block_energy_histogram);
306 av_free((*st)->d->short_term_block_energy_histogram);
307 av_free((*st)->d->audio_data);
308 av_free((*st)->d->channel_map);
309 av_free((*st)->d->sample_peak);
310 av_free((*st)->d->data_ptrs);
311 av_free((*st)->d);
312 av_free(*st);
313 *st = NULL;
314 }
315
316 #define EBUR128_FILTER(type, scaling_factor) \
317 static void ebur128_filter_##type(FFEBUR128State* st, const type** srcs, \
318 size_t src_index, size_t frames, \
319 int stride) { \
320 double* audio_data = st->d->audio_data + st->d->audio_data_index; \
321 size_t i, c; \
322 \
323 if ((st->mode & FF_EBUR128_MODE_SAMPLE_PEAK) == FF_EBUR128_MODE_SAMPLE_PEAK) { \
324 for (c = 0; c < st->channels; ++c) { \
325 double max = 0.0; \
326 for (i = 0; i < frames; ++i) { \
327 type v = srcs[c][src_index + i * stride]; \
328 if (v > max) { \
329 max = v; \
330 } else if (-v > max) { \
331 max = -1.0 * v; \
332 } \
333 } \
334 max /= scaling_factor; \
335 if (max > st->d->sample_peak[c]) st->d->sample_peak[c] = max; \
336 } \
337 } \
338 for (c = 0; c < st->channels; ++c) { \
339 int ci = st->d->channel_map[c] - 1; \
340 if (ci < 0) continue; \
341 else if (ci == FF_EBUR128_DUAL_MONO - 1) ci = 0; /*dual mono */ \
342 for (i = 0; i < frames; ++i) { \
343 st->d->v[ci][0] = (double) (srcs[c][src_index + i * stride] / scaling_factor) \
344 - st->d->a[1] * st->d->v[ci][1] \
345 - st->d->a[2] * st->d->v[ci][2] \
346 - st->d->a[3] * st->d->v[ci][3] \
347 - st->d->a[4] * st->d->v[ci][4]; \
348 audio_data[i * st->channels + c] = \
349 st->d->b[0] * st->d->v[ci][0] \
350 + st->d->b[1] * st->d->v[ci][1] \
351 + st->d->b[2] * st->d->v[ci][2] \
352 + st->d->b[3] * st->d->v[ci][3] \
353 + st->d->b[4] * st->d->v[ci][4]; \
354 st->d->v[ci][4] = st->d->v[ci][3]; \
355 st->d->v[ci][3] = st->d->v[ci][2]; \
356 st->d->v[ci][2] = st->d->v[ci][1]; \
357 st->d->v[ci][1] = st->d->v[ci][0]; \
358 } \
359 st->d->v[ci][4] = fabs(st->d->v[ci][4]) < DBL_MIN ? 0.0 : st->d->v[ci][4]; \
360 st->d->v[ci][3] = fabs(st->d->v[ci][3]) < DBL_MIN ? 0.0 : st->d->v[ci][3]; \
361 st->d->v[ci][2] = fabs(st->d->v[ci][2]) < DBL_MIN ? 0.0 : st->d->v[ci][2]; \
362 st->d->v[ci][1] = fabs(st->d->v[ci][1]) < DBL_MIN ? 0.0 : st->d->v[ci][1]; \
363 } \
364 }
365 EBUR128_FILTER(double, 1.0)
366
ebur128_energy_to_loudness(double energy)367 static double ebur128_energy_to_loudness(double energy)
368 {
369 return 10 * log10(energy) - 0.691;
370 }
371
find_histogram_index(double energy)372 static size_t find_histogram_index(double energy)
373 {
374 size_t index_min = 0;
375 size_t index_max = 1000;
376 size_t index_mid;
377
378 do {
379 index_mid = (index_min + index_max) / 2;
380 if (energy >= histogram_energy_boundaries[index_mid]) {
381 index_min = index_mid;
382 } else {
383 index_max = index_mid;
384 }
385 } while (index_max - index_min != 1);
386
387 return index_min;
388 }
389
ebur128_calc_gating_block(FFEBUR128State * st,size_t frames_per_block,double * optional_output)390 static void ebur128_calc_gating_block(FFEBUR128State * st,
391 size_t frames_per_block,
392 double *optional_output)
393 {
394 size_t i, c;
395 double sum = 0.0;
396 double channel_sum;
397 for (c = 0; c < st->channels; ++c) {
398 if (st->d->channel_map[c] == FF_EBUR128_UNUSED)
399 continue;
400 channel_sum = 0.0;
401 if (st->d->audio_data_index < frames_per_block * st->channels) {
402 for (i = 0; i < st->d->audio_data_index / st->channels; ++i) {
403 channel_sum += st->d->audio_data[i * st->channels + c] *
404 st->d->audio_data[i * st->channels + c];
405 }
406 for (i = st->d->audio_data_frames -
407 (frames_per_block -
408 st->d->audio_data_index / st->channels);
409 i < st->d->audio_data_frames; ++i) {
410 channel_sum += st->d->audio_data[i * st->channels + c] *
411 st->d->audio_data[i * st->channels + c];
412 }
413 } else {
414 for (i =
415 st->d->audio_data_index / st->channels - frames_per_block;
416 i < st->d->audio_data_index / st->channels; ++i) {
417 channel_sum +=
418 st->d->audio_data[i * st->channels +
419 c] * st->d->audio_data[i *
420 st->channels +
421 c];
422 }
423 }
424 if (st->d->channel_map[c] == FF_EBUR128_Mp110 ||
425 st->d->channel_map[c] == FF_EBUR128_Mm110 ||
426 st->d->channel_map[c] == FF_EBUR128_Mp060 ||
427 st->d->channel_map[c] == FF_EBUR128_Mm060 ||
428 st->d->channel_map[c] == FF_EBUR128_Mp090 ||
429 st->d->channel_map[c] == FF_EBUR128_Mm090) {
430 channel_sum *= 1.41;
431 } else if (st->d->channel_map[c] == FF_EBUR128_DUAL_MONO) {
432 channel_sum *= 2.0;
433 }
434 sum += channel_sum;
435 }
436 sum /= (double) frames_per_block;
437 if (optional_output) {
438 *optional_output = sum;
439 } else if (sum >= histogram_energy_boundaries[0]) {
440 ++st->d->block_energy_histogram[find_histogram_index(sum)];
441 }
442 }
443
ff_ebur128_set_channel(FFEBUR128State * st,unsigned int channel_number,int value)444 int ff_ebur128_set_channel(FFEBUR128State * st,
445 unsigned int channel_number, int value)
446 {
447 if (channel_number >= st->channels) {
448 return 1;
449 }
450 if (value == FF_EBUR128_DUAL_MONO &&
451 (st->channels != 1 || channel_number != 0)) {
452 return 1;
453 }
454 st->d->channel_map[channel_number] = value;
455 return 0;
456 }
457
458 static int ebur128_energy_shortterm(FFEBUR128State * st, double *out);
459 #define EBUR128_ADD_FRAMES_PLANAR(type) \
460 static void ebur128_add_frames_planar_##type(FFEBUR128State* st, const type** srcs, \
461 size_t frames, int stride) { \
462 size_t src_index = 0; \
463 while (frames > 0) { \
464 if (frames >= st->d->needed_frames) { \
465 ebur128_filter_##type(st, srcs, src_index, st->d->needed_frames, stride); \
466 src_index += st->d->needed_frames * stride; \
467 frames -= st->d->needed_frames; \
468 st->d->audio_data_index += st->d->needed_frames * st->channels; \
469 /* calculate the new gating block */ \
470 if ((st->mode & FF_EBUR128_MODE_I) == FF_EBUR128_MODE_I) { \
471 ebur128_calc_gating_block(st, st->d->samples_in_100ms * 4, NULL); \
472 } \
473 if ((st->mode & FF_EBUR128_MODE_LRA) == FF_EBUR128_MODE_LRA) { \
474 st->d->short_term_frame_counter += st->d->needed_frames; \
475 if (st->d->short_term_frame_counter == st->d->samples_in_100ms * 30) { \
476 double st_energy; \
477 ebur128_energy_shortterm(st, &st_energy); \
478 if (st_energy >= histogram_energy_boundaries[0]) { \
479 ++st->d->short_term_block_energy_histogram[ \
480 find_histogram_index(st_energy)]; \
481 } \
482 st->d->short_term_frame_counter = st->d->samples_in_100ms * 20; \
483 } \
484 } \
485 /* 100ms are needed for all blocks besides the first one */ \
486 st->d->needed_frames = st->d->samples_in_100ms; \
487 /* reset audio_data_index when buffer full */ \
488 if (st->d->audio_data_index == st->d->audio_data_frames * st->channels) { \
489 st->d->audio_data_index = 0; \
490 } \
491 } else { \
492 ebur128_filter_##type(st, srcs, src_index, frames, stride); \
493 st->d->audio_data_index += frames * st->channels; \
494 if ((st->mode & FF_EBUR128_MODE_LRA) == FF_EBUR128_MODE_LRA) { \
495 st->d->short_term_frame_counter += frames; \
496 } \
497 st->d->needed_frames -= frames; \
498 frames = 0; \
499 } \
500 } \
501 }
502 EBUR128_ADD_FRAMES_PLANAR(double)
503 #define FF_EBUR128_ADD_FRAMES(type) \
504 void ff_ebur128_add_frames_##type(FFEBUR128State* st, const type* src, \
505 size_t frames) { \
506 int i; \
507 const type **buf = (const type**)st->d->data_ptrs; \
508 for (i = 0; i < st->channels; i++) \
509 buf[i] = src + i; \
510 ebur128_add_frames_planar_##type(st, buf, frames, st->channels); \
511 }
FF_EBUR128_ADD_FRAMES(double)512 FF_EBUR128_ADD_FRAMES(double)
513
514 static int ebur128_calc_relative_threshold(FFEBUR128State **sts, size_t size,
515 double *relative_threshold)
516 {
517 size_t i, j;
518 int above_thresh_counter = 0;
519 *relative_threshold = 0.0;
520
521 for (i = 0; i < size; i++) {
522 unsigned long *block_energy_histogram = sts[i]->d->block_energy_histogram;
523 for (j = 0; j < 1000; ++j) {
524 *relative_threshold += block_energy_histogram[j] * histogram_energies[j];
525 above_thresh_counter += block_energy_histogram[j];
526 }
527 }
528
529 if (above_thresh_counter != 0) {
530 *relative_threshold /= (double)above_thresh_counter;
531 *relative_threshold *= RELATIVE_GATE_FACTOR;
532 }
533
534 return above_thresh_counter;
535 }
536
ebur128_gated_loudness(FFEBUR128State ** sts,size_t size,double * out)537 static int ebur128_gated_loudness(FFEBUR128State ** sts, size_t size,
538 double *out)
539 {
540 double gated_loudness = 0.0;
541 double relative_threshold;
542 size_t above_thresh_counter;
543 size_t i, j, start_index;
544
545 for (i = 0; i < size; i++)
546 if ((sts[i]->mode & FF_EBUR128_MODE_I) != FF_EBUR128_MODE_I)
547 return AVERROR(EINVAL);
548
549 if (!ebur128_calc_relative_threshold(sts, size, &relative_threshold)) {
550 *out = -HUGE_VAL;
551 return 0;
552 }
553
554 above_thresh_counter = 0;
555 if (relative_threshold < histogram_energy_boundaries[0]) {
556 start_index = 0;
557 } else {
558 start_index = find_histogram_index(relative_threshold);
559 if (relative_threshold > histogram_energies[start_index]) {
560 ++start_index;
561 }
562 }
563 for (i = 0; i < size; i++) {
564 for (j = start_index; j < 1000; ++j) {
565 gated_loudness += sts[i]->d->block_energy_histogram[j] *
566 histogram_energies[j];
567 above_thresh_counter += sts[i]->d->block_energy_histogram[j];
568 }
569 }
570 if (!above_thresh_counter) {
571 *out = -HUGE_VAL;
572 return 0;
573 }
574 gated_loudness /= (double) above_thresh_counter;
575 *out = ebur128_energy_to_loudness(gated_loudness);
576 return 0;
577 }
578
ff_ebur128_relative_threshold(FFEBUR128State * st,double * out)579 int ff_ebur128_relative_threshold(FFEBUR128State * st, double *out)
580 {
581 double relative_threshold;
582
583 if ((st->mode & FF_EBUR128_MODE_I) != FF_EBUR128_MODE_I)
584 return AVERROR(EINVAL);
585
586 if (!ebur128_calc_relative_threshold(&st, 1, &relative_threshold)) {
587 *out = -70.0;
588 return 0;
589 }
590
591 *out = ebur128_energy_to_loudness(relative_threshold);
592 return 0;
593 }
594
ff_ebur128_loudness_global(FFEBUR128State * st,double * out)595 int ff_ebur128_loudness_global(FFEBUR128State * st, double *out)
596 {
597 return ebur128_gated_loudness(&st, 1, out);
598 }
599
ebur128_energy_in_interval(FFEBUR128State * st,size_t interval_frames,double * out)600 static int ebur128_energy_in_interval(FFEBUR128State * st,
601 size_t interval_frames, double *out)
602 {
603 if (interval_frames > st->d->audio_data_frames) {
604 return AVERROR(EINVAL);
605 }
606 ebur128_calc_gating_block(st, interval_frames, out);
607 return 0;
608 }
609
ebur128_energy_shortterm(FFEBUR128State * st,double * out)610 static int ebur128_energy_shortterm(FFEBUR128State * st, double *out)
611 {
612 return ebur128_energy_in_interval(st, st->d->samples_in_100ms * 30,
613 out);
614 }
615
ff_ebur128_loudness_shortterm(FFEBUR128State * st,double * out)616 int ff_ebur128_loudness_shortterm(FFEBUR128State * st, double *out)
617 {
618 double energy;
619 int error = ebur128_energy_shortterm(st, &energy);
620 if (error) {
621 return error;
622 } else if (energy <= 0.0) {
623 *out = -HUGE_VAL;
624 return 0;
625 }
626 *out = ebur128_energy_to_loudness(energy);
627 return 0;
628 }
629
630 /* EBU - TECH 3342 */
ff_ebur128_loudness_range_multiple(FFEBUR128State ** sts,size_t size,double * out)631 int ff_ebur128_loudness_range_multiple(FFEBUR128State ** sts, size_t size,
632 double *out)
633 {
634 size_t i, j;
635 size_t stl_size;
636 double stl_power, stl_integrated;
637 /* High and low percentile energy */
638 double h_en, l_en;
639 unsigned long hist[1000] = { 0 };
640 size_t percentile_low, percentile_high;
641 size_t index;
642
643 for (i = 0; i < size; ++i) {
644 if (sts[i]) {
645 if ((sts[i]->mode & FF_EBUR128_MODE_LRA) !=
646 FF_EBUR128_MODE_LRA) {
647 return AVERROR(EINVAL);
648 }
649 }
650 }
651
652 stl_size = 0;
653 stl_power = 0.0;
654 for (i = 0; i < size; ++i) {
655 if (!sts[i])
656 continue;
657 for (j = 0; j < 1000; ++j) {
658 hist[j] += sts[i]->d->short_term_block_energy_histogram[j];
659 stl_size += sts[i]->d->short_term_block_energy_histogram[j];
660 stl_power += sts[i]->d->short_term_block_energy_histogram[j]
661 * histogram_energies[j];
662 }
663 }
664 if (!stl_size) {
665 *out = 0.0;
666 return 0;
667 }
668
669 stl_power /= stl_size;
670 stl_integrated = MINUS_20DB * stl_power;
671
672 if (stl_integrated < histogram_energy_boundaries[0]) {
673 index = 0;
674 } else {
675 index = find_histogram_index(stl_integrated);
676 if (stl_integrated > histogram_energies[index]) {
677 ++index;
678 }
679 }
680 stl_size = 0;
681 for (j = index; j < 1000; ++j) {
682 stl_size += hist[j];
683 }
684 if (!stl_size) {
685 *out = 0.0;
686 return 0;
687 }
688
689 percentile_low = (size_t) ((stl_size - 1) * 0.1 + 0.5);
690 percentile_high = (size_t) ((stl_size - 1) * 0.95 + 0.5);
691
692 stl_size = 0;
693 j = index;
694 while (stl_size <= percentile_low) {
695 stl_size += hist[j++];
696 }
697 l_en = histogram_energies[j - 1];
698 while (stl_size <= percentile_high) {
699 stl_size += hist[j++];
700 }
701 h_en = histogram_energies[j - 1];
702 *out =
703 ebur128_energy_to_loudness(h_en) -
704 ebur128_energy_to_loudness(l_en);
705 return 0;
706 }
707
ff_ebur128_loudness_range(FFEBUR128State * st,double * out)708 int ff_ebur128_loudness_range(FFEBUR128State * st, double *out)
709 {
710 return ff_ebur128_loudness_range_multiple(&st, 1, out);
711 }
712
ff_ebur128_sample_peak(FFEBUR128State * st,unsigned int channel_number,double * out)713 int ff_ebur128_sample_peak(FFEBUR128State * st,
714 unsigned int channel_number, double *out)
715 {
716 if ((st->mode & FF_EBUR128_MODE_SAMPLE_PEAK) !=
717 FF_EBUR128_MODE_SAMPLE_PEAK) {
718 return AVERROR(EINVAL);
719 } else if (channel_number >= st->channels) {
720 return AVERROR(EINVAL);
721 }
722 *out = st->d->sample_peak[channel_number];
723 return 0;
724 }
725