1 /* See COPYING file for copyright and license details. */
2
3 #include "ebur128.h"
4
5 #include <float.h>
6 #include <limits.h>
7 #include <math.h> /* You may have to define _USE_MATH_DEFINES if you use MSVC */
8 #include <stdio.h>
9 #include <stdlib.h>
10
11 /* This can be replaced by any BSD-like queue implementation. */
12 #include <sys/queue.h>
13
14 #define CHECK_ERROR(condition, errorcode, goto_point) \
15 if ((condition)) { \
16 errcode = (errorcode); \
17 goto goto_point; \
18 }
19
20 STAILQ_HEAD(ebur128_double_queue, ebur128_dq_entry);
21 struct ebur128_dq_entry {
22 double z;
23 STAILQ_ENTRY(ebur128_dq_entry) entries;
24 };
25
26 #define ALMOST_ZERO 0.000001
27
28 typedef struct { // Data structure for polyphase FIR interpolator
29 unsigned int factor; // Interpolation factor of the interpolator
30 unsigned int taps; // Taps (prefer odd to increase zero coeffs)
31 unsigned int channels; // Number of channels
32 unsigned int delay; // Size of delay buffer
33 struct {
34 unsigned int count; // Number of coefficients in this subfilter
35 unsigned int* index; // Delay index of corresponding filter coeff
36 double* coeff; // List of subfilter coefficients
37 }* filter; // List of subfilters (one for each factor)
38 float** z; // List of delay buffers (one for each channel)
39 unsigned int zi; // Current delay buffer index
40 } interpolator;
41
42 struct ebur128_state_internal {
43 /** Filtered audio data (used as ring buffer). */
44 double* audio_data;
45 /** Size of audio_data array. */
46 size_t audio_data_frames;
47 /** Current index for audio_data. */
48 size_t audio_data_index;
49 /** How many frames are needed for a gating block. Will correspond to 400ms
50 * of audio at initialization, and 100ms after the first block (75% overlap
51 * as specified in the 2011 revision of BS1770). */
52 unsigned long needed_frames;
53 /** The channel map. Has as many elements as there are channels. */
54 int* channel_map;
55 /** How many samples fit in 100ms (rounded). */
56 unsigned long samples_in_100ms;
57 /** BS.1770 filter coefficients (nominator). */
58 double b[5];
59 /** BS.1770 filter coefficients (denominator). */
60 double a[5];
61 /** BS.1770 filter state. */
62 double v[5][5];
63 /** Linked list of block energies. */
64 struct ebur128_double_queue block_list;
65 unsigned long block_list_max;
66 unsigned long block_list_size;
67 /** Linked list of 3s-block energies, used to calculate LRA. */
68 struct ebur128_double_queue short_term_block_list;
69 unsigned long st_block_list_max;
70 unsigned long st_block_list_size;
71 int use_histogram;
72 unsigned long *block_energy_histogram;
73 unsigned long *short_term_block_energy_histogram;
74 /** Keeps track of when a new short term block is needed. */
75 size_t short_term_frame_counter;
76 /** Maximum sample peak, one per channel */
77 double* sample_peak;
78 double* prev_sample_peak;
79 /** Maximum true peak, one per channel */
80 double* true_peak;
81 double* prev_true_peak;
82 interpolator* interp;
83 float* resampler_buffer_input;
84 size_t resampler_buffer_input_frames;
85 float* resampler_buffer_output;
86 size_t resampler_buffer_output_frames;
87 /** The maximum window duration in ms. */
88 unsigned long window;
89 unsigned long history;
90 };
91
92 static double relative_gate = -10.0;
93
94 /* Those will be calculated when initializing the library */
95 static double relative_gate_factor;
96 static double minus_twenty_decibels;
97 static double histogram_energies[1000];
98 static double histogram_energy_boundaries[1001];
99
interp_create(unsigned int taps,unsigned int factor,unsigned int channels)100 static interpolator* interp_create(unsigned int taps, unsigned int factor, unsigned int channels) {
101 interpolator* interp = calloc(1, sizeof(interpolator));
102 unsigned int j = 0;
103
104 interp->taps = taps;
105 interp->factor = factor;
106 interp->channels = channels;
107 interp->delay = (interp->taps + interp->factor - 1) / interp->factor;
108
109 // Initialize the filter memory
110 // One subfilter per interpolation factor.
111 interp->filter = calloc(interp->factor, sizeof(*interp->filter));
112 for (j = 0; j < interp->factor; j++) {
113 interp->filter[j].index = calloc(interp->delay, sizeof(unsigned int));
114 interp->filter[j].coeff = calloc(interp->delay, sizeof(double));
115 }
116 // One delay buffer per channel.
117 interp->z = calloc(interp->channels, sizeof(float*));
118 for (j = 0; j < interp->channels; j++) {
119 interp->z[j] = calloc( interp->delay, sizeof(float) );
120 }
121
122 // Calculate the filter coefficients
123 for (j = 0; j < interp->taps; j++) {
124 // Calculate sinc
125 double m = (double)j - (double)(interp->taps - 1) / 2.0;
126 double c = 1.0;
127 if (fabs(m) > ALMOST_ZERO) {
128 c = sin(m * M_PI / interp->factor) / (m * M_PI / interp->factor);
129 }
130 // Apply Hanning window
131 c *= 0.5 * (1 - cos(2 * M_PI * j / (interp->taps - 1)));
132
133 if (fabs(c) > ALMOST_ZERO) { // Ignore any zero coeffs.
134 // Put the coefficient into the correct subfilter
135 unsigned int f = j % interp->factor;
136 unsigned int t = interp->filter[f].count++;
137 interp->filter[f].coeff[t] = c;
138 interp->filter[f].index[t] = j / interp->factor;
139 }
140 }
141 return interp;
142 }
143
interp_destroy(interpolator * interp)144 static void interp_destroy(interpolator* interp) {
145 unsigned int j = 0;
146 if (!interp) return;
147 for (j = 0; j < interp->factor; j++) {
148 free(interp->filter[j].index);
149 free(interp->filter[j].coeff);
150 }
151 free(interp->filter);
152 for (j = 0; j < interp->channels; j++) {
153 free(interp->z[j]);
154 }
155 free(interp->z);
156 free(interp);
157 }
158
interp_process(interpolator * interp,size_t frames,float * in,float * out)159 static void interp_process(interpolator* interp, size_t frames, float* in, float* out) {
160 size_t frame = 0;
161 unsigned int chan = 0;
162 unsigned int f = 0;
163 unsigned int t = 0;
164 unsigned int out_stride = interp->channels * interp->factor;
165 float* outp = 0;
166 double acc = 0;
167 double c = 0;
168 for (frame = 0; frame < frames; frame++) {
169 for (chan = 0; chan < interp->channels; chan++) {
170 // Add sample to delay buffer
171 interp->z[chan][interp->zi] = *in++;
172 // Apply coefficients
173 outp = out + chan;
174 for (f = 0; f < interp->factor; f++) {
175 acc = 0.0;
176 for (t = 0; t < interp->filter[f].count; t++) {
177 int i = (int)interp->zi - (int)interp->filter[f].index[t];
178 if (i < 0) i += interp->delay;
179 c = interp->filter[f].coeff[t];
180 acc += interp->z[chan][i] * c;
181 }
182 *outp = (float)acc;
183 outp += interp->channels;
184 }
185 }
186 out += out_stride;
187 interp->zi++;
188 if (interp->zi == interp->delay) interp->zi = 0;
189 }
190 }
191
ebur128_init_filter(ebur128_state * st)192 static void ebur128_init_filter(ebur128_state* st) {
193 int i, j;
194
195 double f0 = 1681.974450955533;
196 double G = 3.999843853973347;
197 double Q = 0.7071752369554196;
198
199 double K = tan(M_PI * f0 / (double) st->samplerate);
200 double Vh = pow(10.0, G / 20.0);
201 double Vb = pow(Vh, 0.4996667741545416);
202
203 double pb[3] = {0.0, 0.0, 0.0};
204 double pa[3] = {1.0, 0.0, 0.0};
205 double rb[3] = {1.0, -2.0, 1.0};
206 double ra[3] = {1.0, 0.0, 0.0};
207
208 double a0 = 1.0 + K / Q + K * K ;
209 pb[0] = (Vh + Vb * K / Q + K * K) / a0;
210 pb[1] = 2.0 * (K * K - Vh) / a0;
211 pb[2] = (Vh - Vb * K / Q + K * K) / a0;
212 pa[1] = 2.0 * (K * K - 1.0) / a0;
213 pa[2] = (1.0 - K / Q + K * K) / a0;
214
215 /* fprintf(stderr, "%.14f %.14f %.14f %.14f %.14f\n",
216 b1[0], b1[1], b1[2], a1[1], a1[2]); */
217
218 f0 = 38.13547087602444;
219 Q = 0.5003270373238773;
220 K = tan(M_PI * f0 / (double) st->samplerate);
221
222 ra[1] = 2.0 * (K * K - 1.0) / (1.0 + K / Q + K * K);
223 ra[2] = (1.0 - K / Q + K * K) / (1.0 + K / Q + K * K);
224
225 /* fprintf(stderr, "%.14f %.14f\n", a2[1], a2[2]); */
226
227 st->d->b[0] = pb[0] * rb[0];
228 st->d->b[1] = pb[0] * rb[1] + pb[1] * rb[0];
229 st->d->b[2] = pb[0] * rb[2] + pb[1] * rb[1] + pb[2] * rb[0];
230 st->d->b[3] = pb[1] * rb[2] + pb[2] * rb[1];
231 st->d->b[4] = pb[2] * rb[2];
232
233 st->d->a[0] = pa[0] * ra[0];
234 st->d->a[1] = pa[0] * ra[1] + pa[1] * ra[0];
235 st->d->a[2] = pa[0] * ra[2] + pa[1] * ra[1] + pa[2] * ra[0];
236 st->d->a[3] = pa[1] * ra[2] + pa[2] * ra[1];
237 st->d->a[4] = pa[2] * ra[2];
238
239 for (i = 0; i < 5; ++i) {
240 for (j = 0; j < 5; ++j) {
241 st->d->v[i][j] = 0.0;
242 }
243 }
244 }
245
ebur128_init_channel_map(ebur128_state * st)246 static int ebur128_init_channel_map(ebur128_state* st) {
247 size_t i;
248 st->d->channel_map = (int*) malloc(st->channels * sizeof(int));
249 if (!st->d->channel_map) return EBUR128_ERROR_NOMEM;
250 if (st->channels == 4) {
251 st->d->channel_map[0] = EBUR128_LEFT;
252 st->d->channel_map[1] = EBUR128_RIGHT;
253 st->d->channel_map[2] = EBUR128_LEFT_SURROUND;
254 st->d->channel_map[3] = EBUR128_RIGHT_SURROUND;
255 } else if (st->channels == 5) {
256 st->d->channel_map[0] = EBUR128_LEFT;
257 st->d->channel_map[1] = EBUR128_RIGHT;
258 st->d->channel_map[2] = EBUR128_CENTER;
259 st->d->channel_map[3] = EBUR128_LEFT_SURROUND;
260 st->d->channel_map[4] = EBUR128_RIGHT_SURROUND;
261 } else {
262 for (i = 0; i < st->channels; ++i) {
263 switch (i) {
264 case 0: st->d->channel_map[i] = EBUR128_LEFT; break;
265 case 1: st->d->channel_map[i] = EBUR128_RIGHT; break;
266 case 2: st->d->channel_map[i] = EBUR128_CENTER; break;
267 case 3: st->d->channel_map[i] = EBUR128_UNUSED; break;
268 case 4: st->d->channel_map[i] = EBUR128_LEFT_SURROUND; break;
269 case 5: st->d->channel_map[i] = EBUR128_RIGHT_SURROUND; break;
270 default: st->d->channel_map[i] = EBUR128_UNUSED; break;
271 }
272 }
273 }
274 return EBUR128_SUCCESS;
275 }
276
ebur128_init_resampler(ebur128_state * st)277 static int ebur128_init_resampler(ebur128_state* st) {
278 int errcode = EBUR128_SUCCESS;
279
280 if (st->samplerate < 96000) {
281 st->d->interp = interp_create(49, 4, st->channels);
282 CHECK_ERROR(!st->d->interp, EBUR128_ERROR_NOMEM, exit)
283 } else if (st->samplerate < 192000) {
284 st->d->interp = interp_create(49, 2, st->channels);
285 CHECK_ERROR(!st->d->interp, EBUR128_ERROR_NOMEM, exit)
286 } else {
287 st->d->resampler_buffer_input = NULL;
288 st->d->resampler_buffer_output = NULL;
289 st->d->interp = NULL;
290 goto exit;
291 }
292
293 st->d->resampler_buffer_input_frames = st->d->samples_in_100ms * 4;
294 st->d->resampler_buffer_input = malloc(st->d->resampler_buffer_input_frames *
295 st->channels *
296 sizeof(float));
297 CHECK_ERROR(!st->d->resampler_buffer_input, EBUR128_ERROR_NOMEM, free_interp)
298
299 st->d->resampler_buffer_output_frames =
300 st->d->resampler_buffer_input_frames *
301 st->d->interp->factor;
302 st->d->resampler_buffer_output = malloc
303 (st->d->resampler_buffer_output_frames *
304 st->channels *
305 sizeof(float));
306 CHECK_ERROR(!st->d->resampler_buffer_output, EBUR128_ERROR_NOMEM, free_input)
307
308 return errcode;
309
310 free_interp:
311 interp_destroy(st->d->interp);
312 st->d->interp = NULL;
313 free_input:
314 free(st->d->resampler_buffer_input);
315 st->d->resampler_buffer_input = NULL;
316 exit:
317 return errcode;
318 }
319
ebur128_destroy_resampler(ebur128_state * st)320 static void ebur128_destroy_resampler(ebur128_state* st) {
321 free(st->d->resampler_buffer_input);
322 st->d->resampler_buffer_input = NULL;
323 free(st->d->resampler_buffer_output);
324 st->d->resampler_buffer_output = NULL;
325 interp_destroy(st->d->interp);
326 st->d->interp = NULL;
327 }
328
ebur128_get_version(int * major,int * minor,int * patch)329 void ebur128_get_version(int* major, int* minor, int* patch) {
330 *major = EBUR128_VERSION_MAJOR;
331 *minor = EBUR128_VERSION_MINOR;
332 *patch = EBUR128_VERSION_PATCH;
333 }
334
ebur128_init(unsigned int channels,unsigned long samplerate,int mode)335 ebur128_state* ebur128_init(unsigned int channels,
336 unsigned long samplerate,
337 int mode) {
338 int result;
339 int errcode;
340 ebur128_state* st;
341 unsigned int i;
342 size_t j;
343
344 st = (ebur128_state*) malloc(sizeof(ebur128_state));
345 CHECK_ERROR(!st, 0, exit)
346 st->d = (struct ebur128_state_internal*)
347 malloc(sizeof(struct ebur128_state_internal));
348 CHECK_ERROR(!st->d, 0, free_state)
349 st->channels = channels;
350 errcode = ebur128_init_channel_map(st);
351 CHECK_ERROR(errcode, 0, free_internal)
352
353 st->d->sample_peak = (double*) malloc(channels * sizeof(double));
354 CHECK_ERROR(!st->d->sample_peak, 0, free_channel_map)
355 st->d->prev_sample_peak = (double*) malloc(channels * sizeof(double));
356 CHECK_ERROR(!st->d->prev_sample_peak, 0, free_sample_peak)
357 st->d->true_peak = (double*) malloc(channels * sizeof(double));
358 CHECK_ERROR(!st->d->true_peak, 0, free_prev_sample_peak)
359 st->d->prev_true_peak = (double*) malloc(channels * sizeof(double));
360 CHECK_ERROR(!st->d->prev_true_peak, 0, free_true_peak)
361 for (i = 0; i < channels; ++i) {
362 st->d->sample_peak[i] = 0.0;
363 st->d->prev_sample_peak[i] = 0.0;
364 st->d->true_peak[i] = 0.0;
365 st->d->prev_true_peak[i] = 0.0;
366 }
367
368 st->d->use_histogram = mode & EBUR128_MODE_HISTOGRAM ? 1 : 0;
369 st->d->history = ULONG_MAX;
370 st->samplerate = samplerate;
371 st->d->samples_in_100ms = (st->samplerate + 5) / 10;
372 st->mode = mode;
373 if ((mode & EBUR128_MODE_S) == EBUR128_MODE_S) {
374 st->d->window = 3000;
375 } else if ((mode & EBUR128_MODE_M) == EBUR128_MODE_M) {
376 st->d->window = 400;
377 } else {
378 goto free_prev_true_peak;
379 }
380 st->d->audio_data_frames = st->samplerate * st->d->window / 1000;
381 if (st->d->audio_data_frames % st->d->samples_in_100ms) {
382 /* round up to multiple of samples_in_100ms */
383 st->d->audio_data_frames = st->d->audio_data_frames
384 + st->d->samples_in_100ms
385 - (st->d->audio_data_frames % st->d->samples_in_100ms);
386 }
387 st->d->audio_data = (double*) malloc(st->d->audio_data_frames *
388 st->channels *
389 sizeof(double));
390 CHECK_ERROR(!st->d->audio_data, 0, free_true_peak)
391 for (j = 0; j < st->d->audio_data_frames * st->channels; ++j) {
392 st->d->audio_data[i] = 0.0;
393 }
394
395 ebur128_init_filter(st);
396
397 if (st->d->use_histogram) {
398 st->d->block_energy_histogram = malloc(1000 * sizeof(unsigned long));
399 CHECK_ERROR(!st->d->block_energy_histogram, 0, free_audio_data)
400 for (i = 0; i < 1000; ++i) {
401 st->d->block_energy_histogram[i] = 0;
402 }
403 } else {
404 st->d->block_energy_histogram = NULL;
405 }
406 if (st->d->use_histogram) {
407 st->d->short_term_block_energy_histogram = malloc(1000 * sizeof(unsigned long));
408 CHECK_ERROR(!st->d->short_term_block_energy_histogram, 0, free_block_energy_histogram)
409 for (i = 0; i < 1000; ++i) {
410 st->d->short_term_block_energy_histogram[i] = 0;
411 }
412 } else {
413 st->d->short_term_block_energy_histogram = NULL;
414 }
415 STAILQ_INIT(&st->d->block_list);
416 st->d->block_list_size = 0;
417 st->d->block_list_max = st->d->history / 100;
418 STAILQ_INIT(&st->d->short_term_block_list);
419 st->d->st_block_list_size = 0;
420 st->d->st_block_list_max = st->d->history / 3000;
421 st->d->short_term_frame_counter = 0;
422
423 result = ebur128_init_resampler(st);
424 CHECK_ERROR(result, 0, free_short_term_block_energy_histogram)
425
426 /* the first block needs 400ms of audio data */
427 st->d->needed_frames = st->d->samples_in_100ms * 4;
428 /* start at the beginning of the buffer */
429 st->d->audio_data_index = 0;
430
431 /* initialize static constants */
432 relative_gate_factor = pow(10.0, relative_gate / 10.0);
433 minus_twenty_decibels = pow(10.0, -20.0 / 10.0);
434 histogram_energy_boundaries[0] = pow(10.0, (-70.0 + 0.691) / 10.0);
435 if (st->d->use_histogram) {
436 for (i = 0; i < 1000; ++i) {
437 histogram_energies[i] = pow(10.0, ((double) i / 10.0 - 69.95 + 0.691) / 10.0);
438 }
439 for (i = 1; i < 1001; ++i) {
440 histogram_energy_boundaries[i] = pow(10.0, ((double) i / 10.0 - 70.0 + 0.691) / 10.0);
441 }
442 }
443
444 return st;
445
446 free_short_term_block_energy_histogram:
447 free(st->d->short_term_block_energy_histogram);
448 free_block_energy_histogram:
449 free(st->d->block_energy_histogram);
450 free_audio_data:
451 free(st->d->audio_data);
452 free_prev_true_peak:
453 free(st->d->prev_true_peak);
454 free_true_peak:
455 free(st->d->true_peak);
456 free_prev_sample_peak:
457 free(st->d->prev_sample_peak);
458 free_sample_peak:
459 free(st->d->sample_peak);
460 free_channel_map:
461 free(st->d->channel_map);
462 free_internal:
463 free(st->d);
464 free_state:
465 free(st);
466 exit:
467 return NULL;
468 }
469
ebur128_destroy(ebur128_state ** st)470 void ebur128_destroy(ebur128_state** st) {
471 struct ebur128_dq_entry* entry;
472 free((*st)->d->block_energy_histogram);
473 free((*st)->d->short_term_block_energy_histogram);
474 free((*st)->d->audio_data);
475 free((*st)->d->channel_map);
476 free((*st)->d->sample_peak);
477 free((*st)->d->prev_sample_peak);
478 free((*st)->d->true_peak);
479 free((*st)->d->prev_true_peak);
480 while (!STAILQ_EMPTY(&(*st)->d->block_list)) {
481 entry = STAILQ_FIRST(&(*st)->d->block_list);
482 STAILQ_REMOVE_HEAD(&(*st)->d->block_list, entries);
483 free(entry);
484 }
485 while (!STAILQ_EMPTY(&(*st)->d->short_term_block_list)) {
486 entry = STAILQ_FIRST(&(*st)->d->short_term_block_list);
487 STAILQ_REMOVE_HEAD(&(*st)->d->short_term_block_list, entries);
488 free(entry);
489 }
490 ebur128_destroy_resampler(*st);
491 free((*st)->d);
492 free(*st);
493 *st = NULL;
494 }
495
ebur128_check_true_peak(ebur128_state * st,size_t frames)496 static void ebur128_check_true_peak(ebur128_state* st, size_t frames) {
497 size_t c, i;
498 interp_process(st->d->interp, frames,
499 st->d->resampler_buffer_input,
500 st->d->resampler_buffer_output);
501 for (c = 0; c < st->channels; ++c) {
502 for (i = 0; i < st->d->resampler_buffer_output_frames; ++i) {
503 if (st->d->resampler_buffer_output[i * st->channels + c] >
504 st->d->prev_true_peak[c]) {
505 st->d->prev_true_peak[c] =
506 st->d->resampler_buffer_output[i * st->channels + c];
507 } else if (-st->d->resampler_buffer_output[i * st->channels + c] >
508 st->d->prev_true_peak[c]) {
509 st->d->prev_true_peak[c] =
510 -st->d->resampler_buffer_output[i * st->channels + c];
511 }
512 }
513 }
514 }
515
516 #ifdef __SSE2_MATH__
517 #include <xmmintrin.h>
518 #define TURN_ON_FTZ \
519 unsigned int mxcsr = _mm_getcsr(); \
520 _mm_setcsr(mxcsr | _MM_FLUSH_ZERO_ON);
521 #define TURN_OFF_FTZ _mm_setcsr(mxcsr);
522 #define FLUSH_MANUALLY
523 #else
524 #warning "manual FTZ is being used, please enable SSE2 (-msse2 -mfpmath=sse)"
525 #define TURN_ON_FTZ
526 #define TURN_OFF_FTZ
527 #define FLUSH_MANUALLY \
528 st->d->v[ci][4] = fabs(st->d->v[ci][4]) < DBL_MIN ? 0.0 : st->d->v[ci][4]; \
529 st->d->v[ci][3] = fabs(st->d->v[ci][3]) < DBL_MIN ? 0.0 : st->d->v[ci][3]; \
530 st->d->v[ci][2] = fabs(st->d->v[ci][2]) < DBL_MIN ? 0.0 : st->d->v[ci][2]; \
531 st->d->v[ci][1] = fabs(st->d->v[ci][1]) < DBL_MIN ? 0.0 : st->d->v[ci][1];
532 #endif
533
534 #define EBUR128_FILTER(type, min_scale, max_scale) \
535 static void ebur128_filter_##type(ebur128_state* st, const type* src, \
536 size_t frames) { \
537 static double scaling_factor = -((double) min_scale) > (double) max_scale ? \
538 -((double) min_scale) : (double) max_scale; \
539 double* audio_data = st->d->audio_data + st->d->audio_data_index; \
540 size_t i, c; \
541 \
542 TURN_ON_FTZ \
543 \
544 if ((st->mode & EBUR128_MODE_SAMPLE_PEAK) == EBUR128_MODE_SAMPLE_PEAK) { \
545 for (c = 0; c < st->channels; ++c) { \
546 double max = 0.0; \
547 for (i = 0; i < frames; ++i) { \
548 if (src[i * st->channels + c] > max) { \
549 max = src[i * st->channels + c]; \
550 } else if (-src[i * st->channels + c] > max) { \
551 max = -1.0 * src[i * st->channels + c]; \
552 } \
553 } \
554 max /= scaling_factor; \
555 if (max > st->d->prev_sample_peak[c]) st->d->prev_sample_peak[c] = max; \
556 } \
557 } \
558 if ((st->mode & EBUR128_MODE_TRUE_PEAK) == EBUR128_MODE_TRUE_PEAK && \
559 st->d->interp) { \
560 for (c = 0; c < st->channels; ++c) { \
561 for (i = 0; i < frames; ++i) { \
562 st->d->resampler_buffer_input[i * st->channels + c] = \
563 (float) (src[i * st->channels + c] / scaling_factor); \
564 } \
565 } \
566 ebur128_check_true_peak(st, frames); \
567 } \
568 for (c = 0; c < st->channels; ++c) { \
569 int ci = st->d->channel_map[c] - 1; \
570 if (ci < 0) continue; \
571 else if (ci == EBUR128_DUAL_MONO - 1) ci = 0; /*dual mono */ \
572 for (i = 0; i < frames; ++i) { \
573 st->d->v[ci][0] = (double) (src[i * st->channels + c] / scaling_factor) \
574 - st->d->a[1] * st->d->v[ci][1] \
575 - st->d->a[2] * st->d->v[ci][2] \
576 - st->d->a[3] * st->d->v[ci][3] \
577 - st->d->a[4] * st->d->v[ci][4]; \
578 audio_data[i * st->channels + c] = \
579 st->d->b[0] * st->d->v[ci][0] \
580 + st->d->b[1] * st->d->v[ci][1] \
581 + st->d->b[2] * st->d->v[ci][2] \
582 + st->d->b[3] * st->d->v[ci][3] \
583 + st->d->b[4] * st->d->v[ci][4]; \
584 st->d->v[ci][4] = st->d->v[ci][3]; \
585 st->d->v[ci][3] = st->d->v[ci][2]; \
586 st->d->v[ci][2] = st->d->v[ci][1]; \
587 st->d->v[ci][1] = st->d->v[ci][0]; \
588 } \
589 FLUSH_MANUALLY \
590 } \
591 TURN_OFF_FTZ \
592 }
EBUR128_FILTER(short,SHRT_MIN,SHRT_MAX)593 EBUR128_FILTER(short, SHRT_MIN, SHRT_MAX)
594 EBUR128_FILTER(int, INT_MIN, INT_MAX)
595 EBUR128_FILTER(float, -1.0f, 1.0f)
596 EBUR128_FILTER(double, -1.0, 1.0)
597
598 static double ebur128_energy_to_loudness(double energy) {
599 return 10 * (log(energy) / log(10.0)) - 0.691;
600 }
601
find_histogram_index(double energy)602 static size_t find_histogram_index(double energy) {
603 size_t index_min = 0;
604 size_t index_max = 1000;
605 size_t index_mid;
606
607 do {
608 index_mid = (index_min + index_max) / 2;
609 if (energy >= histogram_energy_boundaries[index_mid]) {
610 index_min = index_mid;
611 } else {
612 index_max = index_mid;
613 }
614 } while (index_max - index_min != 1);
615
616 return index_min;
617 }
618
ebur128_calc_gating_block(ebur128_state * st,size_t frames_per_block,double * optional_output)619 static int ebur128_calc_gating_block(ebur128_state* st, size_t frames_per_block,
620 double* optional_output) {
621 size_t i, c;
622 double sum = 0.0;
623 double channel_sum;
624 for (c = 0; c < st->channels; ++c) {
625 if (st->d->channel_map[c] == EBUR128_UNUSED) continue;
626 channel_sum = 0.0;
627 if (st->d->audio_data_index < frames_per_block * st->channels) {
628 for (i = 0; i < st->d->audio_data_index / st->channels; ++i) {
629 channel_sum += st->d->audio_data[i * st->channels + c] *
630 st->d->audio_data[i * st->channels + c];
631 }
632 for (i = st->d->audio_data_frames -
633 (frames_per_block -
634 st->d->audio_data_index / st->channels);
635 i < st->d->audio_data_frames; ++i) {
636 channel_sum += st->d->audio_data[i * st->channels + c] *
637 st->d->audio_data[i * st->channels + c];
638 }
639 } else {
640 for (i = st->d->audio_data_index / st->channels - frames_per_block;
641 i < st->d->audio_data_index / st->channels;
642 ++i) {
643 channel_sum += st->d->audio_data[i * st->channels + c] *
644 st->d->audio_data[i * st->channels + c];
645 }
646 }
647 if (st->d->channel_map[c] == EBUR128_Mp110 ||
648 st->d->channel_map[c] == EBUR128_Mm110 ||
649 st->d->channel_map[c] == EBUR128_Mp060 ||
650 st->d->channel_map[c] == EBUR128_Mm060 ||
651 st->d->channel_map[c] == EBUR128_Mp090 ||
652 st->d->channel_map[c] == EBUR128_Mm090) {
653 channel_sum *= 1.41;
654 } else if (st->d->channel_map[c] == EBUR128_DUAL_MONO) {
655 channel_sum *= 2.0;
656 }
657 sum += channel_sum;
658 }
659 sum /= (double) frames_per_block;
660 if (optional_output) {
661 *optional_output = sum;
662 return EBUR128_SUCCESS;
663 } else if (sum >= histogram_energy_boundaries[0]) {
664 if (st->d->use_histogram) {
665 ++st->d->block_energy_histogram[find_histogram_index(sum)];
666 } else {
667 struct ebur128_dq_entry* block;
668 if (st->d->block_list_size == st->d->block_list_max) {
669 block = STAILQ_FIRST(&st->d->block_list);
670 STAILQ_REMOVE_HEAD(&st->d->block_list, entries);
671 } else {
672 block = (struct ebur128_dq_entry*) malloc(sizeof(struct ebur128_dq_entry));
673 if (!block) return EBUR128_ERROR_NOMEM;
674 st->d->block_list_size++;
675 }
676 block->z = sum;
677 STAILQ_INSERT_TAIL(&st->d->block_list, block, entries);
678 }
679 return EBUR128_SUCCESS;
680 } else {
681 return EBUR128_SUCCESS;
682 }
683 }
684
ebur128_set_channel(ebur128_state * st,unsigned int channel_number,int value)685 int ebur128_set_channel(ebur128_state* st,
686 unsigned int channel_number,
687 int value) {
688 if (channel_number >= st->channels) {
689 return 1;
690 }
691 if (value == EBUR128_DUAL_MONO &&
692 (st->channels != 1 || channel_number != 0)) {
693 fprintf(stderr, "EBUR128_DUAL_MONO only works with mono files!\n");
694 return 1;
695 }
696 st->d->channel_map[channel_number] = value;
697 return 0;
698 }
699
ebur128_change_parameters(ebur128_state * st,unsigned int channels,unsigned long samplerate)700 int ebur128_change_parameters(ebur128_state* st,
701 unsigned int channels,
702 unsigned long samplerate) {
703 int errcode = EBUR128_SUCCESS;
704 size_t j;
705
706 if (channels == st->channels &&
707 samplerate == st->samplerate) {
708 return EBUR128_ERROR_NO_CHANGE;
709 }
710 free(st->d->audio_data);
711 st->d->audio_data = NULL;
712
713 if (channels != st->channels) {
714 unsigned int i;
715
716 free(st->d->channel_map); st->d->channel_map = NULL;
717 free(st->d->sample_peak); st->d->sample_peak = NULL;
718 free(st->d->prev_sample_peak); st->d->prev_sample_peak = NULL;
719 free(st->d->true_peak); st->d->true_peak = NULL;
720 free(st->d->prev_true_peak); st->d->prev_true_peak = NULL;
721 st->channels = channels;
722
723 errcode = ebur128_init_channel_map(st);
724 CHECK_ERROR(errcode, EBUR128_ERROR_NOMEM, exit)
725
726 st->d->sample_peak = (double*) malloc(channels * sizeof(double));
727 CHECK_ERROR(!st->d->sample_peak, EBUR128_ERROR_NOMEM, exit)
728 st->d->prev_sample_peak = (double*) malloc(channels * sizeof(double));
729 CHECK_ERROR(!st->d->prev_sample_peak, EBUR128_ERROR_NOMEM, exit)
730 st->d->true_peak = (double*) malloc(channels * sizeof(double));
731 CHECK_ERROR(!st->d->true_peak, EBUR128_ERROR_NOMEM, exit)
732 st->d->prev_true_peak = (double*) malloc(channels * sizeof(double));
733 CHECK_ERROR(!st->d->prev_true_peak, EBUR128_ERROR_NOMEM, exit)
734 for (i = 0; i < channels; ++i) {
735 st->d->sample_peak[i] = 0.0;
736 st->d->prev_sample_peak[i] = 0.0;
737 st->d->true_peak[i] = 0.0;
738 st->d->prev_true_peak[i] = 0.0;
739 }
740 }
741 if (samplerate != st->samplerate) {
742 st->samplerate = samplerate;
743 st->d->samples_in_100ms = (st->samplerate + 5) / 10;
744 ebur128_init_filter(st);
745 }
746 st->d->audio_data_frames = st->samplerate * st->d->window / 1000;
747 if (st->d->audio_data_frames % st->d->samples_in_100ms) {
748 /* round up to multiple of samples_in_100ms */
749 st->d->audio_data_frames = st->d->audio_data_frames
750 + st->d->samples_in_100ms
751 - (st->d->audio_data_frames % st->d->samples_in_100ms);
752 }
753 st->d->audio_data = (double*) malloc(st->d->audio_data_frames *
754 st->channels *
755 sizeof(double));
756 CHECK_ERROR(!st->d->audio_data, EBUR128_ERROR_NOMEM, exit)
757 for (j = 0; j < st->d->audio_data_frames * st->channels; ++j) {
758 st->d->audio_data[j] = 0.0;
759 }
760
761 ebur128_destroy_resampler(st);
762 errcode = ebur128_init_resampler(st);
763 CHECK_ERROR(errcode, EBUR128_ERROR_NOMEM, exit)
764
765 /* the first block needs 400ms of audio data */
766 st->d->needed_frames = st->d->samples_in_100ms * 4;
767 /* start at the beginning of the buffer */
768 st->d->audio_data_index = 0;
769 /* reset short term frame counter */
770 st->d->short_term_frame_counter = 0;
771
772 exit:
773 return errcode;
774 }
775
ebur128_set_max_window(ebur128_state * st,unsigned long window)776 int ebur128_set_max_window(ebur128_state* st, unsigned long window)
777 {
778 int errcode = EBUR128_SUCCESS;
779 size_t j;
780
781 if ((st->mode & EBUR128_MODE_S) == EBUR128_MODE_S && window < 3000) {
782 window = 3000;
783 } else if ((st->mode & EBUR128_MODE_M) == EBUR128_MODE_M && window < 400) {
784 window = 400;
785 }
786 if (window == st->d->window) {
787 return EBUR128_ERROR_NO_CHANGE;
788 }
789
790 st->d->window = window;
791 free(st->d->audio_data);
792 st->d->audio_data = NULL;
793 st->d->audio_data_frames = st->samplerate * st->d->window / 1000;
794 if (st->d->audio_data_frames % st->d->samples_in_100ms) {
795 /* round up to multiple of samples_in_100ms */
796 st->d->audio_data_frames = st->d->audio_data_frames
797 + st->d->samples_in_100ms
798 - (st->d->audio_data_frames % st->d->samples_in_100ms);
799 }
800 st->d->audio_data = (double*) malloc(st->d->audio_data_frames *
801 st->channels *
802 sizeof(double));
803 CHECK_ERROR(!st->d->audio_data, EBUR128_ERROR_NOMEM, exit)
804 for (j = 0; j < st->d->audio_data_frames * st->channels; ++j) {
805 st->d->audio_data[j] = 0.0;
806 }
807
808 /* the first block needs 400ms of audio data */
809 st->d->needed_frames = st->d->samples_in_100ms * 4;
810 /* start at the beginning of the buffer */
811 st->d->audio_data_index = 0;
812 /* reset short term frame counter */
813 st->d->short_term_frame_counter = 0;
814
815 exit:
816 return errcode;
817 }
818
ebur128_set_max_history(ebur128_state * st,unsigned long history)819 int ebur128_set_max_history(ebur128_state* st, unsigned long history)
820 {
821 if ((st->mode & EBUR128_MODE_LRA) == EBUR128_MODE_LRA && history < 3000) {
822 history = 3000;
823 } else if ((st->mode & EBUR128_MODE_M) == EBUR128_MODE_M && history < 400) {
824 history = 400;
825 }
826 if (history == st->d->history) {
827 return EBUR128_ERROR_NO_CHANGE;
828 }
829 st->d->history = history;
830 st->d->block_list_max = st->d->history / 100;
831 st->d->st_block_list_max = st->d->history / 3000;
832 while (st->d->block_list_size > st->d->block_list_max) {
833 struct ebur128_dq_entry* block = STAILQ_FIRST(&st->d->block_list);
834 STAILQ_REMOVE_HEAD(&st->d->block_list, entries);
835 free(block);
836 st->d->block_list_size--;
837 }
838 while (st->d->st_block_list_size > st->d->st_block_list_max) {
839 struct ebur128_dq_entry* block = STAILQ_FIRST(&st->d->short_term_block_list);
840 STAILQ_REMOVE_HEAD(&st->d->short_term_block_list, entries);
841 free(block);
842 st->d->st_block_list_size--;
843 }
844 return EBUR128_SUCCESS;
845 }
846
847 static int ebur128_energy_shortterm(ebur128_state* st, double* out);
848 #define EBUR128_ADD_FRAMES(type) \
849 int ebur128_add_frames_##type(ebur128_state* st, \
850 const type* src, size_t frames) { \
851 size_t src_index = 0; \
852 unsigned int c = 0; \
853 for (c = 0; c < st->channels; c++) { \
854 st->d->prev_sample_peak[c] = 0.0; \
855 st->d->prev_true_peak[c] = 0.0; \
856 } \
857 while (frames > 0) { \
858 if (frames >= st->d->needed_frames) { \
859 ebur128_filter_##type(st, src + src_index, st->d->needed_frames); \
860 src_index += st->d->needed_frames * st->channels; \
861 frames -= st->d->needed_frames; \
862 st->d->audio_data_index += st->d->needed_frames * st->channels; \
863 /* calculate the new gating block */ \
864 if ((st->mode & EBUR128_MODE_I) == EBUR128_MODE_I) { \
865 if (ebur128_calc_gating_block(st, st->d->samples_in_100ms * 4, NULL)) {\
866 return EBUR128_ERROR_NOMEM; \
867 } \
868 } \
869 if ((st->mode & EBUR128_MODE_LRA) == EBUR128_MODE_LRA) { \
870 st->d->short_term_frame_counter += st->d->needed_frames; \
871 if (st->d->short_term_frame_counter == st->d->samples_in_100ms * 30) { \
872 struct ebur128_dq_entry* block; \
873 double st_energy; \
874 ebur128_energy_shortterm(st, &st_energy); \
875 if (st_energy >= histogram_energy_boundaries[0]) { \
876 if (st->d->use_histogram) { \
877 ++st->d->short_term_block_energy_histogram[ \
878 find_histogram_index(st_energy)];\
879 } else { \
880 if (st->d->st_block_list_size == st->d->st_block_list_max) { \
881 block = STAILQ_FIRST(&st->d->short_term_block_list); \
882 STAILQ_REMOVE_HEAD(&st->d->short_term_block_list, entries); \
883 } else { \
884 block = (struct ebur128_dq_entry*) \
885 malloc(sizeof(struct ebur128_dq_entry)); \
886 if (!block) return EBUR128_ERROR_NOMEM; \
887 st->d->st_block_list_size++; \
888 } \
889 block->z = st_energy; \
890 STAILQ_INSERT_TAIL(&st->d->short_term_block_list, \
891 block, entries); \
892 } \
893 } \
894 st->d->short_term_frame_counter = st->d->samples_in_100ms * 20; \
895 } \
896 } \
897 /* 100ms are needed for all blocks besides the first one */ \
898 st->d->needed_frames = st->d->samples_in_100ms; \
899 /* reset audio_data_index when buffer full */ \
900 if (st->d->audio_data_index == st->d->audio_data_frames * st->channels) {\
901 st->d->audio_data_index = 0; \
902 } \
903 } else { \
904 ebur128_filter_##type(st, src + src_index, frames); \
905 st->d->audio_data_index += frames * st->channels; \
906 if ((st->mode & EBUR128_MODE_LRA) == EBUR128_MODE_LRA) { \
907 st->d->short_term_frame_counter += frames; \
908 } \
909 st->d->needed_frames -= frames; \
910 frames = 0; \
911 } \
912 } \
913 for (c = 0; c < st->channels; c++) { \
914 if (st->d->prev_sample_peak[c] > st->d->sample_peak[c]) { \
915 st->d->sample_peak[c] = st->d->prev_sample_peak[c]; \
916 } \
917 if (st->d->prev_true_peak[c] > st->d->true_peak[c]) { \
918 st->d->true_peak[c] = st->d->prev_true_peak[c]; \
919 } \
920 } \
921 return EBUR128_SUCCESS; \
922 }
923 EBUR128_ADD_FRAMES(short)
EBUR128_ADD_FRAMES(int)924 EBUR128_ADD_FRAMES(int)
925 EBUR128_ADD_FRAMES(float)
926 EBUR128_ADD_FRAMES(double)
927
928 static int ebur128_calc_relative_threshold(ebur128_state* st,
929 size_t* above_thresh_counter,
930 double* relative_threshold) {
931 struct ebur128_dq_entry* it;
932 size_t i;
933 *relative_threshold = 0.0;
934 *above_thresh_counter = 0;
935
936 if (st->d->use_histogram) {
937 for (i = 0; i < 1000; ++i) {
938 *relative_threshold += st->d->block_energy_histogram[i] *
939 histogram_energies[i];
940 *above_thresh_counter += st->d->block_energy_histogram[i];
941 }
942 } else {
943 STAILQ_FOREACH(it, &st->d->block_list, entries) {
944 ++*above_thresh_counter;
945 *relative_threshold += it->z;
946 }
947 }
948
949 if (*above_thresh_counter != 0) {
950 *relative_threshold /= (double) *above_thresh_counter;
951 *relative_threshold *= relative_gate_factor;
952 }
953
954 return EBUR128_SUCCESS;
955 }
956
ebur128_gated_loudness(ebur128_state ** sts,size_t size,double * out)957 static int ebur128_gated_loudness(ebur128_state** sts, size_t size,
958 double* out) {
959 struct ebur128_dq_entry* it;
960 double gated_loudness = 0.0;
961 double relative_threshold = 0.0;
962 size_t above_thresh_counter = 0;
963 size_t i, j, start_index;
964
965 for (i = 0; i < size; i++) {
966 if (sts[i] && (sts[i]->mode & EBUR128_MODE_I) != EBUR128_MODE_I) {
967 return EBUR128_ERROR_INVALID_MODE;
968 }
969 }
970
971 for (i = 0; i < size; i++) {
972 if (!sts[i]) continue;
973 ebur128_calc_relative_threshold(sts[i], &above_thresh_counter, &relative_threshold);
974 }
975 if (!above_thresh_counter) {
976 *out = -HUGE_VAL;
977 return EBUR128_SUCCESS;
978 }
979
980 above_thresh_counter = 0;
981 if (relative_threshold < histogram_energy_boundaries[0]) {
982 start_index = 0;
983 } else {
984 start_index = find_histogram_index(relative_threshold);
985 if (relative_threshold > histogram_energies[start_index]) {
986 ++start_index;
987 }
988 }
989 for (i = 0; i < size; i++) {
990 if (!sts[i]) continue;
991 if (sts[i]->d->use_histogram) {
992 for (j = start_index; j < 1000; ++j) {
993 gated_loudness += sts[i]->d->block_energy_histogram[j] *
994 histogram_energies[j];
995 above_thresh_counter += sts[i]->d->block_energy_histogram[j];
996 }
997 } else {
998 STAILQ_FOREACH(it, &sts[i]->d->block_list, entries) {
999 if (it->z >= relative_threshold) {
1000 ++above_thresh_counter;
1001 gated_loudness += it->z;
1002 }
1003 }
1004 }
1005 }
1006 if (!above_thresh_counter) {
1007 *out = -HUGE_VAL;
1008 return EBUR128_SUCCESS;
1009 }
1010 gated_loudness /= (double) above_thresh_counter;
1011 *out = ebur128_energy_to_loudness(gated_loudness);
1012 return EBUR128_SUCCESS;
1013 }
1014
ebur128_relative_threshold(ebur128_state * st,double * out)1015 int ebur128_relative_threshold(ebur128_state* st, double* out) {
1016 double relative_threshold;
1017 size_t above_thresh_counter;
1018
1019 if (st && (st->mode & EBUR128_MODE_I) != EBUR128_MODE_I)
1020 return EBUR128_ERROR_INVALID_MODE;
1021
1022 ebur128_calc_relative_threshold(st, &above_thresh_counter, &relative_threshold);
1023
1024 if (!above_thresh_counter) {
1025 *out = -70.0;
1026 return EBUR128_SUCCESS;
1027 }
1028
1029 *out = ebur128_energy_to_loudness(relative_threshold);
1030 return EBUR128_SUCCESS;
1031 }
1032
ebur128_loudness_global(ebur128_state * st,double * out)1033 int ebur128_loudness_global(ebur128_state* st, double* out) {
1034 return ebur128_gated_loudness(&st, 1, out);
1035 }
1036
ebur128_loudness_global_multiple(ebur128_state ** sts,size_t size,double * out)1037 int ebur128_loudness_global_multiple(ebur128_state** sts, size_t size,
1038 double* out) {
1039 return ebur128_gated_loudness(sts, size, out);
1040 }
1041
ebur128_energy_in_interval(ebur128_state * st,size_t interval_frames,double * out)1042 static int ebur128_energy_in_interval(ebur128_state* st,
1043 size_t interval_frames,
1044 double* out) {
1045 if (interval_frames > st->d->audio_data_frames) {
1046 return EBUR128_ERROR_INVALID_MODE;
1047 }
1048 ebur128_calc_gating_block(st, interval_frames, out);
1049 return EBUR128_SUCCESS;
1050 }
1051
ebur128_energy_shortterm(ebur128_state * st,double * out)1052 static int ebur128_energy_shortterm(ebur128_state* st, double* out) {
1053 return ebur128_energy_in_interval(st, st->d->samples_in_100ms * 30, out);
1054 }
1055
ebur128_loudness_momentary(ebur128_state * st,double * out)1056 int ebur128_loudness_momentary(ebur128_state* st, double* out) {
1057 double energy;
1058 int error = ebur128_energy_in_interval(st, st->d->samples_in_100ms * 4,
1059 &energy);
1060 if (error) {
1061 return error;
1062 } else if (energy <= 0.0) {
1063 *out = -HUGE_VAL;
1064 return EBUR128_SUCCESS;
1065 }
1066 *out = ebur128_energy_to_loudness(energy);
1067 return EBUR128_SUCCESS;
1068 }
1069
ebur128_loudness_shortterm(ebur128_state * st,double * out)1070 int ebur128_loudness_shortterm(ebur128_state* st, double* out) {
1071 double energy;
1072 int error = ebur128_energy_shortterm(st, &energy);
1073 if (error) {
1074 return error;
1075 } else if (energy <= 0.0) {
1076 *out = -HUGE_VAL;
1077 return EBUR128_SUCCESS;
1078 }
1079 *out = ebur128_energy_to_loudness(energy);
1080 return EBUR128_SUCCESS;
1081 }
1082
ebur128_loudness_window(ebur128_state * st,unsigned long window,double * out)1083 int ebur128_loudness_window(ebur128_state* st,
1084 unsigned long window,
1085 double* out) {
1086 double energy;
1087 size_t interval_frames = st->samplerate * window / 1000;
1088 int error = ebur128_energy_in_interval(st, interval_frames, &energy);
1089 if (error) {
1090 return error;
1091 } else if (energy <= 0.0) {
1092 *out = -HUGE_VAL;
1093 return EBUR128_SUCCESS;
1094 }
1095 *out = ebur128_energy_to_loudness(energy);
1096 return EBUR128_SUCCESS;
1097 }
1098
ebur128_double_cmp(const void * p1,const void * p2)1099 static int ebur128_double_cmp(const void *p1, const void *p2) {
1100 const double* d1 = (const double*) p1;
1101 const double* d2 = (const double*) p2;
1102 return (*d1 > *d2) - (*d1 < *d2);
1103 }
1104
1105 /* EBU - TECH 3342 */
ebur128_loudness_range_multiple(ebur128_state ** sts,size_t size,double * out)1106 int ebur128_loudness_range_multiple(ebur128_state** sts, size_t size,
1107 double* out) {
1108 size_t i, j;
1109 struct ebur128_dq_entry* it;
1110 double* stl_vector;
1111 size_t stl_size;
1112 double* stl_relgated;
1113 size_t stl_relgated_size;
1114 double stl_power, stl_integrated;
1115 /* High and low percentile energy */
1116 double h_en, l_en;
1117 int use_histogram = 0;
1118
1119 for (i = 0; i < size; ++i) {
1120 if (sts[i]) {
1121 if ((sts[i]->mode & EBUR128_MODE_LRA) != EBUR128_MODE_LRA) {
1122 return EBUR128_ERROR_INVALID_MODE;
1123 }
1124 if (i == 0 && sts[i]->mode & EBUR128_MODE_HISTOGRAM) {
1125 use_histogram = 1;
1126 } else if (use_histogram != !!(sts[i]->mode & EBUR128_MODE_HISTOGRAM)) {
1127 return EBUR128_ERROR_INVALID_MODE;
1128 }
1129 }
1130 }
1131
1132 if (use_histogram) {
1133 unsigned long hist[1000] = { 0 };
1134 size_t percentile_low, percentile_high;
1135 size_t index;
1136
1137 stl_size = 0;
1138 stl_power = 0.0;
1139 for (i = 0; i < size; ++i) {
1140 if (!sts[i]) continue;
1141 for (j = 0; j < 1000; ++j) {
1142 hist[j] += sts[i]->d->short_term_block_energy_histogram[j];
1143 stl_size += sts[i]->d->short_term_block_energy_histogram[j];
1144 stl_power += sts[i]->d->short_term_block_energy_histogram[j]
1145 * histogram_energies[j];
1146 }
1147 }
1148 if (!stl_size) {
1149 *out = 0.0;
1150 return EBUR128_SUCCESS;
1151 }
1152
1153 stl_power /= stl_size;
1154 stl_integrated = minus_twenty_decibels * stl_power;
1155
1156 if (stl_integrated < histogram_energy_boundaries[0]) {
1157 index = 0;
1158 } else {
1159 index = find_histogram_index(stl_integrated);
1160 if (stl_integrated > histogram_energies[index]) {
1161 ++index;
1162 }
1163 }
1164 stl_size = 0;
1165 for (j = index; j < 1000; ++j) {
1166 stl_size += hist[j];
1167 }
1168 if (!stl_size) {
1169 *out = 0.0;
1170 return EBUR128_SUCCESS;
1171 }
1172
1173 percentile_low = (size_t) ((stl_size - 1) * 0.1 + 0.5);
1174 percentile_high = (size_t) ((stl_size - 1) * 0.95 + 0.5);
1175
1176 stl_size = 0;
1177 j = index;
1178 while (stl_size <= percentile_low) {
1179 stl_size += hist[j++];
1180 }
1181 l_en = histogram_energies[j - 1];
1182 while (stl_size <= percentile_high) {
1183 stl_size += hist[j++];
1184 }
1185 h_en = histogram_energies[j - 1];
1186 *out = ebur128_energy_to_loudness(h_en) - ebur128_energy_to_loudness(l_en);
1187 return EBUR128_SUCCESS;
1188
1189 } else {
1190 stl_size = 0;
1191 for (i = 0; i < size; ++i) {
1192 if (!sts[i]) continue;
1193 STAILQ_FOREACH(it, &sts[i]->d->short_term_block_list, entries) {
1194 ++stl_size;
1195 }
1196 }
1197 if (!stl_size) {
1198 *out = 0.0;
1199 return EBUR128_SUCCESS;
1200 }
1201 stl_vector = (double*) malloc(stl_size * sizeof(double));
1202 if (!stl_vector)
1203 return EBUR128_ERROR_NOMEM;
1204
1205 for (j = 0, i = 0; i < size; ++i) {
1206 if (!sts[i]) continue;
1207 STAILQ_FOREACH(it, &sts[i]->d->short_term_block_list, entries) {
1208 stl_vector[j] = it->z;
1209 ++j;
1210 }
1211 }
1212 qsort(stl_vector, stl_size, sizeof(double), ebur128_double_cmp);
1213 stl_power = 0.0;
1214 for (i = 0; i < stl_size; ++i) {
1215 stl_power += stl_vector[i];
1216 }
1217 stl_power /= (double) stl_size;
1218 stl_integrated = minus_twenty_decibels * stl_power;
1219
1220 stl_relgated = stl_vector;
1221 stl_relgated_size = stl_size;
1222 while (stl_relgated_size > 0 && *stl_relgated < stl_integrated) {
1223 ++stl_relgated;
1224 --stl_relgated_size;
1225 }
1226
1227 if (stl_relgated_size) {
1228 h_en = stl_relgated[(size_t) ((stl_relgated_size - 1) * 0.95 + 0.5)];
1229 l_en = stl_relgated[(size_t) ((stl_relgated_size - 1) * 0.1 + 0.5)];
1230 free(stl_vector);
1231 *out = ebur128_energy_to_loudness(h_en) - ebur128_energy_to_loudness(l_en);
1232 return EBUR128_SUCCESS;
1233 } else {
1234 free(stl_vector);
1235 *out = 0.0;
1236 return EBUR128_SUCCESS;
1237 }
1238 }
1239 }
1240
ebur128_loudness_range(ebur128_state * st,double * out)1241 int ebur128_loudness_range(ebur128_state* st, double* out) {
1242 return ebur128_loudness_range_multiple(&st, 1, out);
1243 }
1244
ebur128_sample_peak(ebur128_state * st,unsigned int channel_number,double * out)1245 int ebur128_sample_peak(ebur128_state* st,
1246 unsigned int channel_number,
1247 double* out) {
1248 if ((st->mode & EBUR128_MODE_SAMPLE_PEAK) != EBUR128_MODE_SAMPLE_PEAK) {
1249 return EBUR128_ERROR_INVALID_MODE;
1250 } else if (channel_number >= st->channels) {
1251 return EBUR128_ERROR_INVALID_CHANNEL_INDEX;
1252 }
1253 *out = st->d->sample_peak[channel_number];
1254 return EBUR128_SUCCESS;
1255 }
1256
ebur128_prev_sample_peak(ebur128_state * st,unsigned int channel_number,double * out)1257 int ebur128_prev_sample_peak(ebur128_state* st,
1258 unsigned int channel_number,
1259 double* out) {
1260 if ((st->mode & EBUR128_MODE_SAMPLE_PEAK) != EBUR128_MODE_SAMPLE_PEAK) {
1261 return EBUR128_ERROR_INVALID_MODE;
1262 } else if (channel_number >= st->channels) {
1263 return EBUR128_ERROR_INVALID_CHANNEL_INDEX;
1264 }
1265 *out = st->d->prev_sample_peak[channel_number];
1266 return EBUR128_SUCCESS;
1267 }
1268
ebur128_true_peak(ebur128_state * st,unsigned int channel_number,double * out)1269 int ebur128_true_peak(ebur128_state* st,
1270 unsigned int channel_number,
1271 double* out) {
1272 if ((st->mode & EBUR128_MODE_TRUE_PEAK) != EBUR128_MODE_TRUE_PEAK) {
1273 return EBUR128_ERROR_INVALID_MODE;
1274 } else if (channel_number >= st->channels) {
1275 return EBUR128_ERROR_INVALID_CHANNEL_INDEX;
1276 }
1277 *out = st->d->true_peak[channel_number] > st->d->sample_peak[channel_number]
1278 ? st->d->true_peak[channel_number]
1279 : st->d->sample_peak[channel_number];
1280 return EBUR128_SUCCESS;
1281 }
1282
ebur128_prev_true_peak(ebur128_state * st,unsigned int channel_number,double * out)1283 int ebur128_prev_true_peak(ebur128_state* st,
1284 unsigned int channel_number,
1285 double* out) {
1286 if ((st->mode & EBUR128_MODE_TRUE_PEAK) != EBUR128_MODE_TRUE_PEAK) {
1287 return EBUR128_ERROR_INVALID_MODE;
1288 } else if (channel_number >= st->channels) {
1289 return EBUR128_ERROR_INVALID_CHANNEL_INDEX;
1290 }
1291 *out = st->d->prev_true_peak[channel_number]
1292 > st->d->prev_sample_peak[channel_number]
1293 ? st->d->prev_true_peak[channel_number]
1294 : st->d->prev_sample_peak[channel_number];
1295 return EBUR128_SUCCESS;
1296 }
1297