1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "webrtc/modules/audio_processing/utility/delay_estimator_wrapper.h"
12
13 #include <assert.h>
14 #include <stdlib.h>
15 #include <string.h>
16
17 #include "webrtc/modules/audio_processing/utility/delay_estimator.h"
18 #include "webrtc/modules/audio_processing/utility/delay_estimator_internal.h"
19 #include "webrtc/system_wrappers/include/compile_assert_c.h"
20
21 // Only bit |kBandFirst| through bit |kBandLast| are processed and
22 // |kBandFirst| - |kBandLast| must be < 32.
23 enum { kBandFirst = 12 };
24 enum { kBandLast = 43 };
25
SetBit(uint32_t in,int pos)26 static __inline uint32_t SetBit(uint32_t in, int pos) {
27 uint32_t mask = (1 << pos);
28 uint32_t out = (in | mask);
29
30 return out;
31 }
32
33 // Calculates the mean recursively. Same version as WebRtc_MeanEstimatorFix(),
34 // but for float.
35 //
36 // Inputs:
37 // - new_value : New additional value.
38 // - scale : Scale for smoothing (should be less than 1.0).
39 //
40 // Input/Output:
41 // - mean_value : Pointer to the mean value for updating.
42 //
MeanEstimatorFloat(float new_value,float scale,float * mean_value)43 static void MeanEstimatorFloat(float new_value,
44 float scale,
45 float* mean_value) {
46 assert(scale < 1.0f);
47 *mean_value += (new_value - *mean_value) * scale;
48 }
49
50 // Computes the binary spectrum by comparing the input |spectrum| with a
51 // |threshold_spectrum|. Float and fixed point versions.
52 //
53 // Inputs:
54 // - spectrum : Spectrum of which the binary spectrum should be
55 // calculated.
56 // - threshold_spectrum : Threshold spectrum with which the input
57 // spectrum is compared.
58 // Return:
59 // - out : Binary spectrum.
60 //
BinarySpectrumFix(const uint16_t * spectrum,SpectrumType * threshold_spectrum,int q_domain,int * threshold_initialized)61 static uint32_t BinarySpectrumFix(const uint16_t* spectrum,
62 SpectrumType* threshold_spectrum,
63 int q_domain,
64 int* threshold_initialized) {
65 int i = kBandFirst;
66 uint32_t out = 0;
67
68 assert(q_domain < 16);
69
70 if (!(*threshold_initialized)) {
71 // Set the |threshold_spectrum| to half the input |spectrum| as starting
72 // value. This speeds up the convergence.
73 for (i = kBandFirst; i <= kBandLast; i++) {
74 if (spectrum[i] > 0) {
75 // Convert input spectrum from Q(|q_domain|) to Q15.
76 int32_t spectrum_q15 = ((int32_t) spectrum[i]) << (15 - q_domain);
77 threshold_spectrum[i].int32_ = (spectrum_q15 >> 1);
78 *threshold_initialized = 1;
79 }
80 }
81 }
82 for (i = kBandFirst; i <= kBandLast; i++) {
83 // Convert input spectrum from Q(|q_domain|) to Q15.
84 int32_t spectrum_q15 = ((int32_t) spectrum[i]) << (15 - q_domain);
85 // Update the |threshold_spectrum|.
86 WebRtc_MeanEstimatorFix(spectrum_q15, 6, &(threshold_spectrum[i].int32_));
87 // Convert |spectrum| at current frequency bin to a binary value.
88 if (spectrum_q15 > threshold_spectrum[i].int32_) {
89 out = SetBit(out, i - kBandFirst);
90 }
91 }
92
93 return out;
94 }
95
BinarySpectrumFloat(const float * spectrum,SpectrumType * threshold_spectrum,int * threshold_initialized)96 static uint32_t BinarySpectrumFloat(const float* spectrum,
97 SpectrumType* threshold_spectrum,
98 int* threshold_initialized) {
99 int i = kBandFirst;
100 uint32_t out = 0;
101 const float kScale = 1 / 64.0;
102
103 if (!(*threshold_initialized)) {
104 // Set the |threshold_spectrum| to half the input |spectrum| as starting
105 // value. This speeds up the convergence.
106 for (i = kBandFirst; i <= kBandLast; i++) {
107 if (spectrum[i] > 0.0f) {
108 threshold_spectrum[i].float_ = (spectrum[i] / 2);
109 *threshold_initialized = 1;
110 }
111 }
112 }
113
114 for (i = kBandFirst; i <= kBandLast; i++) {
115 // Update the |threshold_spectrum|.
116 MeanEstimatorFloat(spectrum[i], kScale, &(threshold_spectrum[i].float_));
117 // Convert |spectrum| at current frequency bin to a binary value.
118 if (spectrum[i] > threshold_spectrum[i].float_) {
119 out = SetBit(out, i - kBandFirst);
120 }
121 }
122
123 return out;
124 }
125
WebRtc_FreeDelayEstimatorFarend(void * handle)126 void WebRtc_FreeDelayEstimatorFarend(void* handle) {
127 DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
128
129 if (handle == NULL) {
130 return;
131 }
132
133 free(self->mean_far_spectrum);
134 self->mean_far_spectrum = NULL;
135
136 WebRtc_FreeBinaryDelayEstimatorFarend(self->binary_farend);
137 self->binary_farend = NULL;
138
139 free(self);
140 }
141
WebRtc_CreateDelayEstimatorFarend(int spectrum_size,int history_size)142 void* WebRtc_CreateDelayEstimatorFarend(int spectrum_size, int history_size) {
143 DelayEstimatorFarend* self = NULL;
144
145 // Check if the sub band used in the delay estimation is small enough to fit
146 // the binary spectra in a uint32_t.
147 COMPILE_ASSERT(kBandLast - kBandFirst < 32);
148
149 if (spectrum_size >= kBandLast) {
150 self = malloc(sizeof(DelayEstimatorFarend));
151 }
152
153 if (self != NULL) {
154 int memory_fail = 0;
155
156 // Allocate memory for the binary far-end spectrum handling.
157 self->binary_farend = WebRtc_CreateBinaryDelayEstimatorFarend(history_size);
158 memory_fail |= (self->binary_farend == NULL);
159
160 // Allocate memory for spectrum buffers.
161 self->mean_far_spectrum = malloc(spectrum_size * sizeof(SpectrumType));
162 memory_fail |= (self->mean_far_spectrum == NULL);
163
164 self->spectrum_size = spectrum_size;
165
166 if (memory_fail) {
167 WebRtc_FreeDelayEstimatorFarend(self);
168 self = NULL;
169 }
170 }
171
172 return self;
173 }
174
WebRtc_InitDelayEstimatorFarend(void * handle)175 int WebRtc_InitDelayEstimatorFarend(void* handle) {
176 DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
177
178 if (self == NULL) {
179 return -1;
180 }
181
182 // Initialize far-end part of binary delay estimator.
183 WebRtc_InitBinaryDelayEstimatorFarend(self->binary_farend);
184
185 // Set averaged far and near end spectra to zero.
186 memset(self->mean_far_spectrum, 0,
187 sizeof(SpectrumType) * self->spectrum_size);
188 // Reset initialization indicators.
189 self->far_spectrum_initialized = 0;
190
191 return 0;
192 }
193
WebRtc_SoftResetDelayEstimatorFarend(void * handle,int delay_shift)194 void WebRtc_SoftResetDelayEstimatorFarend(void* handle, int delay_shift) {
195 DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
196 assert(self != NULL);
197 WebRtc_SoftResetBinaryDelayEstimatorFarend(self->binary_farend, delay_shift);
198 }
199
WebRtc_AddFarSpectrumFix(void * handle,const uint16_t * far_spectrum,int spectrum_size,int far_q)200 int WebRtc_AddFarSpectrumFix(void* handle,
201 const uint16_t* far_spectrum,
202 int spectrum_size,
203 int far_q) {
204 DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
205 uint32_t binary_spectrum = 0;
206
207 if (self == NULL) {
208 return -1;
209 }
210 if (far_spectrum == NULL) {
211 // Empty far end spectrum.
212 return -1;
213 }
214 if (spectrum_size != self->spectrum_size) {
215 // Data sizes don't match.
216 return -1;
217 }
218 if (far_q > 15) {
219 // If |far_q| is larger than 15 we cannot guarantee no wrap around.
220 return -1;
221 }
222
223 // Get binary spectrum.
224 binary_spectrum = BinarySpectrumFix(far_spectrum, self->mean_far_spectrum,
225 far_q, &(self->far_spectrum_initialized));
226 WebRtc_AddBinaryFarSpectrum(self->binary_farend, binary_spectrum);
227
228 return 0;
229 }
230
WebRtc_AddFarSpectrumFloat(void * handle,const float * far_spectrum,int spectrum_size)231 int WebRtc_AddFarSpectrumFloat(void* handle,
232 const float* far_spectrum,
233 int spectrum_size) {
234 DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
235 uint32_t binary_spectrum = 0;
236
237 if (self == NULL) {
238 return -1;
239 }
240 if (far_spectrum == NULL) {
241 // Empty far end spectrum.
242 return -1;
243 }
244 if (spectrum_size != self->spectrum_size) {
245 // Data sizes don't match.
246 return -1;
247 }
248
249 // Get binary spectrum.
250 binary_spectrum = BinarySpectrumFloat(far_spectrum, self->mean_far_spectrum,
251 &(self->far_spectrum_initialized));
252 WebRtc_AddBinaryFarSpectrum(self->binary_farend, binary_spectrum);
253
254 return 0;
255 }
256
WebRtc_FreeDelayEstimator(void * handle)257 void WebRtc_FreeDelayEstimator(void* handle) {
258 DelayEstimator* self = (DelayEstimator*) handle;
259
260 if (handle == NULL) {
261 return;
262 }
263
264 free(self->mean_near_spectrum);
265 self->mean_near_spectrum = NULL;
266
267 WebRtc_FreeBinaryDelayEstimator(self->binary_handle);
268 self->binary_handle = NULL;
269
270 free(self);
271 }
272
WebRtc_CreateDelayEstimator(void * farend_handle,int max_lookahead)273 void* WebRtc_CreateDelayEstimator(void* farend_handle, int max_lookahead) {
274 DelayEstimator* self = NULL;
275 DelayEstimatorFarend* farend = (DelayEstimatorFarend*) farend_handle;
276
277 if (farend_handle != NULL) {
278 self = malloc(sizeof(DelayEstimator));
279 }
280
281 if (self != NULL) {
282 int memory_fail = 0;
283
284 // Allocate memory for the farend spectrum handling.
285 self->binary_handle =
286 WebRtc_CreateBinaryDelayEstimator(farend->binary_farend, max_lookahead);
287 memory_fail |= (self->binary_handle == NULL);
288
289 // Allocate memory for spectrum buffers.
290 self->mean_near_spectrum = malloc(farend->spectrum_size *
291 sizeof(SpectrumType));
292 memory_fail |= (self->mean_near_spectrum == NULL);
293
294 self->spectrum_size = farend->spectrum_size;
295
296 if (memory_fail) {
297 WebRtc_FreeDelayEstimator(self);
298 self = NULL;
299 }
300 }
301
302 return self;
303 }
304
WebRtc_InitDelayEstimator(void * handle)305 int WebRtc_InitDelayEstimator(void* handle) {
306 DelayEstimator* self = (DelayEstimator*) handle;
307
308 if (self == NULL) {
309 return -1;
310 }
311
312 // Initialize binary delay estimator.
313 WebRtc_InitBinaryDelayEstimator(self->binary_handle);
314
315 // Set averaged far and near end spectra to zero.
316 memset(self->mean_near_spectrum, 0,
317 sizeof(SpectrumType) * self->spectrum_size);
318 // Reset initialization indicators.
319 self->near_spectrum_initialized = 0;
320
321 return 0;
322 }
323
WebRtc_SoftResetDelayEstimator(void * handle,int delay_shift)324 int WebRtc_SoftResetDelayEstimator(void* handle, int delay_shift) {
325 DelayEstimator* self = (DelayEstimator*) handle;
326 assert(self != NULL);
327 return WebRtc_SoftResetBinaryDelayEstimator(self->binary_handle, delay_shift);
328 }
329
WebRtc_set_history_size(void * handle,int history_size)330 int WebRtc_set_history_size(void* handle, int history_size) {
331 DelayEstimator* self = handle;
332
333 if ((self == NULL) || (history_size <= 1)) {
334 return -1;
335 }
336 return WebRtc_AllocateHistoryBufferMemory(self->binary_handle, history_size);
337 }
338
WebRtc_history_size(const void * handle)339 int WebRtc_history_size(const void* handle) {
340 const DelayEstimator* self = handle;
341
342 if (self == NULL) {
343 return -1;
344 }
345 if (self->binary_handle->farend->history_size !=
346 self->binary_handle->history_size) {
347 // Non matching history sizes.
348 return -1;
349 }
350 return self->binary_handle->history_size;
351 }
352
WebRtc_set_lookahead(void * handle,int lookahead)353 int WebRtc_set_lookahead(void* handle, int lookahead) {
354 DelayEstimator* self = (DelayEstimator*) handle;
355 assert(self != NULL);
356 assert(self->binary_handle != NULL);
357 if ((lookahead > self->binary_handle->near_history_size - 1) ||
358 (lookahead < 0)) {
359 return -1;
360 }
361 self->binary_handle->lookahead = lookahead;
362 return self->binary_handle->lookahead;
363 }
364
WebRtc_lookahead(void * handle)365 int WebRtc_lookahead(void* handle) {
366 DelayEstimator* self = (DelayEstimator*) handle;
367 assert(self != NULL);
368 assert(self->binary_handle != NULL);
369 return self->binary_handle->lookahead;
370 }
371
WebRtc_set_allowed_offset(void * handle,int allowed_offset)372 int WebRtc_set_allowed_offset(void* handle, int allowed_offset) {
373 DelayEstimator* self = (DelayEstimator*) handle;
374
375 if ((self == NULL) || (allowed_offset < 0)) {
376 return -1;
377 }
378 self->binary_handle->allowed_offset = allowed_offset;
379 return 0;
380 }
381
WebRtc_get_allowed_offset(const void * handle)382 int WebRtc_get_allowed_offset(const void* handle) {
383 const DelayEstimator* self = (const DelayEstimator*) handle;
384
385 if (self == NULL) {
386 return -1;
387 }
388 return self->binary_handle->allowed_offset;
389 }
390
WebRtc_enable_robust_validation(void * handle,int enable)391 int WebRtc_enable_robust_validation(void* handle, int enable) {
392 DelayEstimator* self = (DelayEstimator*) handle;
393
394 if (self == NULL) {
395 return -1;
396 }
397 if ((enable < 0) || (enable > 1)) {
398 return -1;
399 }
400 assert(self->binary_handle != NULL);
401 self->binary_handle->robust_validation_enabled = enable;
402 return 0;
403 }
404
WebRtc_is_robust_validation_enabled(const void * handle)405 int WebRtc_is_robust_validation_enabled(const void* handle) {
406 const DelayEstimator* self = (const DelayEstimator*) handle;
407
408 if (self == NULL) {
409 return -1;
410 }
411 return self->binary_handle->robust_validation_enabled;
412 }
413
WebRtc_DelayEstimatorProcessFix(void * handle,const uint16_t * near_spectrum,int spectrum_size,int near_q)414 int WebRtc_DelayEstimatorProcessFix(void* handle,
415 const uint16_t* near_spectrum,
416 int spectrum_size,
417 int near_q) {
418 DelayEstimator* self = (DelayEstimator*) handle;
419 uint32_t binary_spectrum = 0;
420
421 if (self == NULL) {
422 return -1;
423 }
424 if (near_spectrum == NULL) {
425 // Empty near end spectrum.
426 return -1;
427 }
428 if (spectrum_size != self->spectrum_size) {
429 // Data sizes don't match.
430 return -1;
431 }
432 if (near_q > 15) {
433 // If |near_q| is larger than 15 we cannot guarantee no wrap around.
434 return -1;
435 }
436
437 // Get binary spectra.
438 binary_spectrum = BinarySpectrumFix(near_spectrum,
439 self->mean_near_spectrum,
440 near_q,
441 &(self->near_spectrum_initialized));
442
443 return WebRtc_ProcessBinarySpectrum(self->binary_handle, binary_spectrum);
444 }
445
WebRtc_DelayEstimatorProcessFloat(void * handle,const float * near_spectrum,int spectrum_size)446 int WebRtc_DelayEstimatorProcessFloat(void* handle,
447 const float* near_spectrum,
448 int spectrum_size) {
449 DelayEstimator* self = (DelayEstimator*) handle;
450 uint32_t binary_spectrum = 0;
451
452 if (self == NULL) {
453 return -1;
454 }
455 if (near_spectrum == NULL) {
456 // Empty near end spectrum.
457 return -1;
458 }
459 if (spectrum_size != self->spectrum_size) {
460 // Data sizes don't match.
461 return -1;
462 }
463
464 // Get binary spectrum.
465 binary_spectrum = BinarySpectrumFloat(near_spectrum, self->mean_near_spectrum,
466 &(self->near_spectrum_initialized));
467
468 return WebRtc_ProcessBinarySpectrum(self->binary_handle, binary_spectrum);
469 }
470
WebRtc_last_delay(void * handle)471 int WebRtc_last_delay(void* handle) {
472 DelayEstimator* self = (DelayEstimator*) handle;
473
474 if (self == NULL) {
475 return -1;
476 }
477
478 return WebRtc_binary_last_delay(self->binary_handle);
479 }
480
WebRtc_last_delay_quality(void * handle)481 float WebRtc_last_delay_quality(void* handle) {
482 DelayEstimator* self = (DelayEstimator*) handle;
483 assert(self != NULL);
484 return WebRtc_binary_last_delay_quality(self->binary_handle);
485 }
486