src/third_party/webrtc/modules/audio_processing/utility/delay_estimator_wrapper.c

   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/interface/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
  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 //
  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 //
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 }