Moved the AEC C code to be built using C++

webrtc/modules/audio_processing/aec/aec_core.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 /*
  * The core AEC algorithm, which is presented with time-aligned signals.
  */
 
 #include "webrtc/modules/audio_processing/aec/aec_core.h"
 
 #ifdef WEBRTC_AEC_DEBUG_DUMP
 #include <stdio.h>
 #endif
 
 #include <assert.h>
 #include <math.h>
 #include <stddef.h>  // size_t
 #include <stdlib.h>
 #include <string.h>
 
+extern "C" {
 #include "webrtc/common_audio/ring_buffer.h"
+}
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_processing/aec/aec_common.h"
 #include "webrtc/modules/audio_processing/aec/aec_core_internal.h"
+extern "C" {
 #include "webrtc/modules/audio_processing/aec/aec_rdft.h"
+}
 #include "webrtc/modules/audio_processing/logging/aec_logging.h"
+extern "C" {
 #include "webrtc/modules/audio_processing/utility/delay_estimator_wrapper.h"
+}
 #include "webrtc/system_wrappers/include/cpu_features_wrapper.h"
 #include "webrtc/typedefs.h"
 
 // Buffer size (samples)
 static const size_t kBufSizePartitions = 250;  // 1 second of audio in 16 kHz.
 
 // Metrics
 static const int subCountLen = 4;
 static const int countLen = 50;
 static const int kDelayMetricsAggregationWindow = 1250;  // 5 seconds at 16 kHz.
 
 // Quantities to control H band scaling for SWB input
-static const float cnScaleHband =
-    (float)0.4;  // scale for comfort noise in H band
+static const float cnScaleHband = 0.4f;  // scale for comfort noise in H band.
 // Initial bin for averaging nlp gain in low band
 static const int freqAvgIc = PART_LEN / 2;
 
 // Matlab code to produce table:
 // win = sqrt(hanning(63)); win = [0 ; win(1:32)];
 // fprintf(1, '\t%.14f, %.14f, %.14f,\n', win);
 ALIGN16_BEG const float ALIGN16_END WebRtcAec_sqrtHanning[65] = {
     0.00000000000000f, 0.02454122852291f, 0.04906767432742f, 0.07356456359967f,
     0.09801714032956f, 0.12241067519922f, 0.14673047445536f, 0.17096188876030f,
     0.19509032201613f, 0.21910124015687f, 0.24298017990326f, 0.26671275747490f,
@@ skipping 351 matching lines @@
         (aec->sd[i] * aec->se[i] + 1e-10f);
     cohxd[i] =
         (aec->sxd[i][0] * aec->sxd[i][0] + aec->sxd[i][1] * aec->sxd[i][1]) /
         (aec->sx[i] * aec->sd[i] + 1e-10f);
   }
 }
 
 static void GetHighbandGain(const float* lambda, float* nlpGainHband) {
   int i;
 
-  *nlpGainHband = (float)0.0;
+  *nlpGainHband = 0.0f;
   for (i = freqAvgIc; i < PART_LEN1 - 1; i++) {
     *nlpGainHband += lambda[i];
   }
-  *nlpGainHband /= (float)(PART_LEN1 - 1 - freqAvgIc);
+  *nlpGainHband /= static_cast<float>(PART_LEN1 - 1 - freqAvgIc);
 }
 
 static void ComfortNoise(AecCore* aec,
                          float efw[2][PART_LEN1],
                          float comfortNoiseHband[2][PART_LEN1],
                          const float* noisePow,
                          const float* lambda) {
   int i, num;
   float rand[PART_LEN];
   float noise, noiseAvg, tmp, tmpAvg;
   int16_t randW16[PART_LEN];
   float u[2][PART_LEN1];
 
   const float pi2 = 6.28318530717959f;
 
   // Generate a uniform random array on [0 1]
   WebRtcSpl_RandUArray(randW16, PART_LEN, &aec->seed);
   for (i = 0; i < PART_LEN; i++) {
-    rand[i] = ((float)randW16[i]) / 32768;
+    rand[i] = static_cast<float>(randW16[i]) / 32768;
   }
 
   // Reject LF noise
   u[0][0] = 0;
   u[1][0] = 0;
   for (i = 1; i < PART_LEN1; i++) {
     tmp = pi2 * rand[i - 1];
 
     noise = sqrtf(noisePow[i]);
     u[0][i] = noise * cosf(tmp);
     u[1][i] = -noise * sinf(tmp);
   }
   u[1][PART_LEN] = 0;
 
   for (i = 0; i < PART_LEN1; i++) {
     // This is the proper weighting to match the background noise power
     tmp = sqrtf(WEBRTC_SPL_MAX(1 - lambda[i] * lambda[i], 0));
     // tmp = 1 - lambda[i];
     efw[0][i] += tmp * u[0][i];
     efw[1][i] += tmp * u[1][i];
   }
 
   // For H band comfort noise
-  // TODO: don't compute noise and "tmp" twice. Use the previous results.
+  // TODO(peah): don't compute noise and "tmp" twice. Use the previous results.
   noiseAvg = 0.0;
   tmpAvg = 0.0;
   num = 0;
   if (aec->num_bands > 1) {
     // average noise scale
     // average over second half of freq spectrum (i.e., 4->8khz)
-    // TODO: we shouldn't need num. We know how many elements we're summing.
+    // TODO(peah): we shouldn't need num. We know how many elements we're
+    // summing.
     for (i = PART_LEN1 >> 1; i < PART_LEN1; i++) {
       num++;
       noiseAvg += sqrtf(noisePow[i]);
     }
-    noiseAvg /= (float)num;
+    noiseAvg /= static_cast<float>(num);
 
     // average nlp scale
     // average over second half of freq spectrum (i.e., 4->8khz)
-    // TODO: we shouldn't need num. We know how many elements we're summing.
+    // TODO(peah): we shouldn't need num. We know how many elements
+    // we're summing.
     num = 0;
     for (i = PART_LEN1 >> 1; i < PART_LEN1; i++) {
       num++;
       tmpAvg += sqrtf(WEBRTC_SPL_MAX(1 - lambda[i] * lambda[i], 0));
     }
-    tmpAvg /= (float)num;
+    tmpAvg /= static_cast<float>(num);
 
     // Use average noise for H band
-    // TODO: we should probably have a new random vector here.
+    // TODO(peah): we should probably have a new random vector here.
     // Reject LF noise
     u[0][0] = 0;
     u[1][0] = 0;
     for (i = 1; i < PART_LEN1; i++) {
       tmp = pi2 * rand[i - 1];
 
       // Use average noise for H band
-      u[0][i] = noiseAvg * (float)cos(tmp);
-      u[1][i] = -noiseAvg * (float)sin(tmp);
+      u[0][i] = noiseAvg * static_cast<float>(cos(tmp));
+      u[1][i] = -noiseAvg * static_cast<float>(sin(tmp));
     }
     u[1][PART_LEN] = 0;
 
     for (i = 0; i < PART_LEN1; i++) {
       // Use average NLP weight for H band
       comfortNoiseHband[0][i] = tmpAvg * u[0][i];
       comfortNoiseHband[1][i] = tmpAvg * u[1][i];
     }
   } else {
     memset(comfortNoiseHband, 0,
@@ skipping 103 matching lines @@
     if ((aec->stateCounter > (0.5f * countLen * subCountLen)) &&
         (aec->farlevel.sfrcounter == 0)
 
         // Estimate in active far-end segments only
         && (aec->farlevel.averagelevel >
             (actThreshold * aec->farlevel.minlevel))) {
       // Subtract noise power
       echo = aec->nearlevel.averagelevel - safety * aec->nearlevel.minlevel;
 
       // ERL
-      dtmp = 10 * (float)log10(aec->farlevel.averagelevel /
-                                   aec->nearlevel.averagelevel +
-                               1e-10f);
-      dtmp2 = 10 * (float)log10(aec->farlevel.averagelevel / echo + 1e-10f);
+      dtmp = 10 * static_cast<float>(log10(aec->farlevel.averagelevel /
+                                           aec->nearlevel.averagelevel +
+                                           1e-10f));
+      dtmp2 = 10 * static_cast<float>(log10(aec->farlevel.averagelevel /
+                                            echo +
+                                            1e-10f));
 
       aec->erl.instant = dtmp;
       if (dtmp > aec->erl.max) {
         aec->erl.max = dtmp;
       }
 
       if (dtmp < aec->erl.min) {
         aec->erl.min = dtmp;
       }
 
       aec->erl.counter++;
       aec->erl.sum += dtmp;
       aec->erl.average = aec->erl.sum / aec->erl.counter;
 
       // Upper mean
       if (dtmp > aec->erl.average) {
         aec->erl.hicounter++;
         aec->erl.hisum += dtmp;
         aec->erl.himean = aec->erl.hisum / aec->erl.hicounter;
       }
 
       // A_NLP
-      dtmp = 10 * (float)log10(aec->nearlevel.averagelevel /
-          aec->linoutlevel.averagelevel + 1e-10f);
+      dtmp = 10 * static_cast<float>(log10(aec->nearlevel.averagelevel /
+                                           aec->linoutlevel.averagelevel +
+                                           1e-10f));
 
       // subtract noise power
       suppressedEcho = aec->linoutlevel.averagelevel -
           safety * aec->linoutlevel.minlevel;
 
-      dtmp2 = 10 * (float)log10(echo / suppressedEcho + 1e-10f);
+      dtmp2 = 10 * static_cast<float>(log10(echo / suppressedEcho + 1e-10f));
 
       aec->aNlp.instant = dtmp2;
       if (dtmp > aec->aNlp.max) {
         aec->aNlp.max = dtmp;
       }
 
       if (dtmp < aec->aNlp.min) {
         aec->aNlp.min = dtmp;
       }
 
       aec->aNlp.counter++;
       aec->aNlp.sum += dtmp;
       aec->aNlp.average = aec->aNlp.sum / aec->aNlp.counter;
 
       // Upper mean
       if (dtmp > aec->aNlp.average) {
         aec->aNlp.hicounter++;
         aec->aNlp.hisum += dtmp;
         aec->aNlp.himean = aec->aNlp.hisum / aec->aNlp.hicounter;
       }
 
       // ERLE
 
       // subtract noise power
       suppressedEcho = 2 * (aec->nlpoutlevel.averagelevel -
                             safety * aec->nlpoutlevel.minlevel);
 
-      dtmp = 10 * (float)log10(aec->nearlevel.averagelevel /
-                                   (2 * aec->nlpoutlevel.averagelevel) +
-                               1e-10f);
-      dtmp2 = 10 * (float)log10(echo / suppressedEcho + 1e-10f);
+      dtmp = 10 * static_cast<float>(log10(aec->nearlevel.averagelevel /
+                                           (2 * aec->nlpoutlevel.averagelevel) +
+                                           1e-10f));
+      dtmp2 = 10 * static_cast<float>(log10(echo / suppressedEcho + 1e-10f));
 
       dtmp = dtmp2;
       aec->erle.instant = dtmp;
       if (dtmp > aec->erle.max) {
         aec->erle.max = dtmp;
       }
 
       if (dtmp < aec->erle.min) {
         aec->erle.min = dtmp;
       }
@@ skipping 45 matching lines @@
     }
   }
   // Account for lookahead.
   self->delay_median = (median - lookahead) * kMsPerBlock;
 
   // Calculate the L1 norm, with median value as central moment.
   for (i = 0; i < kHistorySizeBlocks; i++) {
     l1_norm += abs(i - median) * self->delay_histogram[i];
   }
   self->delay_std =
-      (int)((l1_norm + self->num_delay_values / 2) / self->num_delay_values) *
-      kMsPerBlock;
+      static_cast<int>((l1_norm + self->num_delay_values / 2) /
+                       self->num_delay_values) * kMsPerBlock;
 
   // Determine fraction of delays that are out of bounds, that is, either
   // negative (anti-causal system) or larger than the AEC filter length.
   {
     int num_delays_out_of_bounds = self->num_delay_values;
     const int histogram_length =
         sizeof(self->delay_histogram) / sizeof(self->delay_histogram[0]);
     for (i = lookahead; i < lookahead + self->num_partitions; ++i) {
       if (i < histogram_length)
         num_delays_out_of_bounds -= self->delay_histogram[i];
     }
     self->fraction_poor_delays =
-        (float)num_delays_out_of_bounds / self->num_delay_values;
+        static_cast<float>(num_delays_out_of_bounds) / self->num_delay_values;
   }
 
   // Reset histogram.
   memset(self->delay_histogram, 0, sizeof(self->delay_histogram));
   self->num_delay_values = 0;
 
   return;
 }
 
 static void ScaledInverseFft(float freq_data[2][PART_LEN1],
                              float time_data[PART_LEN2],
                              float scale,
                              int conjugate) {
   int i;
-  const float normalization = scale / ((float)PART_LEN2);
+  const float normalization = scale / static_cast<float>(PART_LEN2);
   const float sign = (conjugate ? -1 : 1);
   time_data[0] = freq_data[0][0] * normalization;
   time_data[1] = freq_data[0][PART_LEN] * normalization;
   for (i = 1; i < PART_LEN; i++) {
     time_data[2 * i] = freq_data[0][i] * normalization;
     time_data[2 * i + 1] = sign * freq_data[1][i] * normalization;
   }
   aec_rdft_inverse_128(time_data);
 }
 
@@ skipping 43 matching lines @@
        self->delay_quality_threshold)) {
     int delay = last_delay - WebRtc_lookahead(self->delay_estimator);
     // Allow for a slack in the actual delay, defined by a |lower_bound| and an
     // |upper_bound|.  The adaptive echo cancellation filter is currently
     // |num_partitions| (of 64 samples) long.  If the delay estimate is negative
     // or at least 3/4 of the filter length we open up for correction.
     const int lower_bound = 0;
     const int upper_bound = self->num_partitions * 3 / 4;
     const int do_correction = delay <= lower_bound || delay > upper_bound;
     if (do_correction == 1) {
-      int available_read = (int)WebRtc_available_read(self->far_time_buf);
+      int available_read =
+          static_cast<int>(WebRtc_available_read(self->far_time_buf));
       // With |shift_offset| we gradually rely on the delay estimates.  For
       // positive delays we reduce the correction by |shift_offset| to lower the
       // risk of pushing the AEC into a non causal state.  For negative delays
       // we rely on the values up to a rounding error, hence compensate by 1
       // element to make sure to push the delay into the causal region.
       delay_correction = -delay;
       delay_correction += delay > self->shift_offset ? self->shift_offset : 1;
       self->shift_offset--;
       self->shift_offset = (self->shift_offset <= 1 ? 1 : self->shift_offset);
       if (delay_correction > available_read - self->mult - 1) {
@@ skipping 214 matching lines @@
       memcpy(hNl, cohde, sizeof(hNl));
       hNlFb = hNlDeAvg;
       hNlFbLow = hNlDeAvg;
     } else {
       aec->echoState = 1;
       for (i = 0; i < PART_LEN1; i++) {
         hNl[i] = WEBRTC_SPL_MIN(cohde[i], 1 - cohxd[i]);
       }
 
       // Select an order statistic from the preferred bands.
-      // TODO: Using quicksort now, but a selection algorithm may be preferred.
+      // TODO(peah): Using quicksort now, but a selection algorithm may be
+      // preferred.
       memcpy(hNlPref, &hNl[minPrefBand], sizeof(float) * prefBandSize);
       qsort(hNlPref, prefBandSize, sizeof(float), CmpFloat);
-      hNlFb = hNlPref[(int)floor(prefBandQuant * (prefBandSize - 1))];
-      hNlFbLow = hNlPref[(int)floor(prefBandQuantLow * (prefBandSize - 1))];
+      hNlFb = hNlPref[static_cast<int>(floor(prefBandQuant *
+                                             (prefBandSize - 1)))];
+      hNlFbLow = hNlPref[static_cast<int>(floor(prefBandQuantLow *
+                                                (prefBandSize - 1)))];
     }
   }
 
   // Track the local filter minimum to determine suppression overdrive.
   if (hNlFbLow < 0.6f && hNlFbLow < aec->hNlFbLocalMin) {
     aec->hNlFbLocalMin = hNlFbLow;
     aec->hNlFbMin = hNlFbLow;
     aec->hNlNewMin = 1;
     aec->hNlMinCtr = 0;
   }
   aec->hNlFbLocalMin =
       WEBRTC_SPL_MIN(aec->hNlFbLocalMin + 0.0008f / aec->mult, 1);
   aec->hNlXdAvgMin = WEBRTC_SPL_MIN(aec->hNlXdAvgMin + 0.0006f / aec->mult, 1);
 
   if (aec->hNlNewMin == 1) {
     aec->hNlMinCtr++;
   }
   if (aec->hNlMinCtr == 2) {
     aec->hNlNewMin = 0;
     aec->hNlMinCtr = 0;
     aec->overDrive =
         WEBRTC_SPL_MAX(kTargetSupp[aec->nlp_mode] /
-                           ((float)log(aec->hNlFbMin + 1e-10f) + 1e-10f),
+                       static_cast<float>(log(aec->hNlFbMin + 1e-10f) + 1e-10f),
                        min_overdrive[aec->nlp_mode]);
   }
 
   // Smooth the overdrive.
   if (aec->overDrive < aec->overDriveSm) {
     aec->overDriveSm = 0.99f * aec->overDriveSm + 0.01f * aec->overDrive;
   } else {
     aec->overDriveSm = 0.9f * aec->overDriveSm + 0.1f * aec->overDrive;
   }
 
@@ skipping 98 matching lines @@
   float outputH[NUM_HIGH_BANDS_MAX][PART_LEN];
   float* outputH_ptr[NUM_HIGH_BANDS_MAX];
   float* x_fft_ptr = NULL;
 
   for (i = 0; i < NUM_HIGH_BANDS_MAX; ++i) {
     outputH_ptr[i] = outputH[i];
   }
 
   // Concatenate old and new nearend blocks.
   for (i = 0; i < aec->num_bands - 1; ++i) {
-    WebRtc_ReadBuffer(aec->nearFrBufH[i], (void**)&nearend_ptr, nearend,
-                      PART_LEN);
+    WebRtc_ReadBuffer(aec->nearFrBufH[i],
+                      reinterpret_cast<void**>(&nearend_ptr),
+                      nearend, PART_LEN);
     memcpy(aec->dBufH[i] + PART_LEN, nearend_ptr, sizeof(nearend));
   }
-  WebRtc_ReadBuffer(aec->nearFrBuf, (void**)&nearend_ptr, nearend, PART_LEN);
+  WebRtc_ReadBuffer(aec->nearFrBuf, reinterpret_cast<void**>(&nearend_ptr),
+                    nearend, PART_LEN);
   memcpy(aec->dBuf + PART_LEN, nearend_ptr, sizeof(nearend));
 
   // We should always have at least one element stored in |far_buf|.
   assert(WebRtc_available_read(aec->far_time_buf) > 0);
-  WebRtc_ReadBuffer(aec->far_time_buf, (void**)&farend_ptr, farend, 1);
+  WebRtc_ReadBuffer(aec->far_time_buf, reinterpret_cast<void**>(&farend_ptr),
+                    farend, 1);
 
 #ifdef WEBRTC_AEC_DEBUG_DUMP
   {
     // TODO(minyue): |farend_ptr| starts from buffered samples. This will be
     // modified when |aec->far_time_buf| is revised.
     RTC_AEC_DEBUG_WAV_WRITE(aec->farFile, &farend_ptr[PART_LEN], PART_LEN);
 
     RTC_AEC_DEBUG_WAV_WRITE(aec->nearFile, nearend_ptr, PART_LEN);
   }
 #endif
@@ skipping 101 matching lines @@
   // For high bands
   for (i = 0; i < aec->num_bands - 1; ++i) {
     WebRtc_WriteBuffer(aec->outFrBufH[i], outputH[i], PART_LEN);
   }
 
   RTC_AEC_DEBUG_WAV_WRITE(aec->outFile, output, PART_LEN);
 }
 
 AecCore* WebRtcAec_CreateAec() {
   int i;
-  AecCore* aec = malloc(sizeof(AecCore));
+  AecCore* aec = reinterpret_cast<AecCore*>(malloc(sizeof(AecCore)));
   if (!aec) {
     return NULL;
   }
 
   aec->nearFrBuf = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN, sizeof(float));
   if (!aec->nearFrBuf) {
     WebRtcAec_FreeAec(aec);
     return NULL;
   }
 
@@ skipping 208 matching lines @@
 
   // Default target suppression mode.
   aec->nlp_mode = 1;
 
   // Sampling frequency multiplier w.r.t. 8 kHz.
   // In case of multiple bands we process the lower band in 16 kHz, hence the
   // multiplier is always 2.
   if (aec->num_bands > 1) {
     aec->mult = 2;
   } else {
-    aec->mult = (short)aec->sampFreq / 8000;
+    aec->mult = static_cast<int16_t>(aec->sampFreq) / 8000;
   }
 
   aec->farBufWritePos = 0;
   aec->farBufReadPos = 0;
 
   aec->inSamples = 0;
   aec->outSamples = 0;
   aec->knownDelay = 0;
 
   // Initialize buffers
@@ skipping 10 matching lines @@
   aec->noisePow = aec->dInitMinPow;
   aec->noiseEstCtr = 0;
 
   // Initial comfort noise power
   for (i = 0; i < PART_LEN1; i++) {
     aec->dMinPow[i] = 1.0e6f;
   }
 
   // Holds the last block written to
   aec->xfBufBlockPos = 0;
-  // TODO: Investigate need for these initializations. Deleting them doesn't
-  //       change the output at all and yields 0.4% overall speedup.
+  // TODO(peah): Investigate need for these initializations. Deleting them
+  // doesn't change the output at all and yields 0.4% overall speedup.
   memset(aec->xfBuf, 0, sizeof(complex_t) * kExtendedNumPartitions * PART_LEN1);
   memset(aec->wfBuf, 0, sizeof(complex_t) * kExtendedNumPartitions * PART_LEN1);
   memset(aec->sde, 0, sizeof(complex_t) * PART_LEN1);
   memset(aec->sxd, 0, sizeof(complex_t) * PART_LEN1);
   memset(aec->xfwBuf, 0,
          sizeof(complex_t) * kExtendedNumPartitions * PART_LEN1);
   memset(aec->se, 0, sizeof(float) * PART_LEN1);
 
   // To prevent numerical instability in the first block.
   for (i = 0; i < PART_LEN1; i++) {
@@ skipping 144 matching lines @@
     while (WebRtc_available_read(aec->nearFrBuf) >= PART_LEN) {
       ProcessBlock(aec);
     }
 
     // 5) Update system delay with respect to the entire frame.
     aec->system_delay -= FRAME_LEN;
 
     // 6) Update output frame.
     // Stuff the out buffer if we have less than a frame to output.
     // This should only happen for the first frame.
-    out_elements = (int)WebRtc_available_read(aec->outFrBuf);
+    out_elements = static_cast<int>(WebRtc_available_read(aec->outFrBuf));
     if (out_elements < FRAME_LEN) {
       WebRtc_MoveReadPtr(aec->outFrBuf, out_elements - FRAME_LEN);
       for (i = 0; i < num_bands - 1; ++i) {
         WebRtc_MoveReadPtr(aec->outFrBufH[i], out_elements - FRAME_LEN);
       }
     }
     // Obtain an output frame.
     WebRtc_ReadBuffer(aec->outFrBuf, NULL, &out[0][j], FRAME_LEN);
     // For H bands.
     for (i = 1; i < num_bands; ++i) {
@@ skipping 91 matching lines @@
 }
 
 int WebRtcAec_system_delay(AecCore* self) {
   return self->system_delay;
 }
 
 void WebRtcAec_SetSystemDelay(AecCore* self, int delay) {
   assert(delay >= 0);
   self->system_delay = delay;
 }