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

webrtc/modules/audio_processing/aec/echo_cancellation.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.
  */
 
 /*
  * Contains the API functions for the AEC.
  */
 #include "webrtc/modules/audio_processing/aec/echo_cancellation.h"
 
 #include <math.h>
 #ifdef WEBRTC_AEC_DEBUG_DUMP
 #include <stdio.h>
 #endif
 #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_core.h"
+extern "C" {
 #include "webrtc/modules/audio_processing/aec/aec_resampler.h"
+}
 #include "webrtc/modules/audio_processing/aec/echo_cancellation_internal.h"
 #include "webrtc/typedefs.h"
 
 // Measured delays [ms]
 // Device                Chrome  GTP
 // MacBook Air           10
 // MacBook Retina        10      100
 // MacPro                30?
 //
 // Win7 Desktop          70      80?
@@ skipping 75 matching lines @@
                          int32_t skew);
 static void ProcessExtended(Aec* self,
                             const float* const* near,
                             size_t num_bands,
                             float* const* out,
                             size_t num_samples,
                             int16_t reported_delay_ms,
                             int32_t skew);
 
 void* WebRtcAec_Create() {
-  Aec* aecpc = malloc(sizeof(Aec));
+  Aec* aecpc = reinterpret_cast<Aec*>(malloc(sizeof(Aec)));
 
   if (!aecpc) {
     return NULL;
   }
 
   aecpc->aec = WebRtcAec_CreateAec();
   if (!aecpc->aec) {
     WebRtcAec_Free(aecpc);
     return NULL;
   }
@@ skipping 10 matching lines @@
   if (!aecpc->far_pre_buf) {
     WebRtcAec_Free(aecpc);
     return NULL;
   }
 
   aecpc->initFlag = 0;
 
 #ifdef WEBRTC_AEC_DEBUG_DUMP
   {
     char filename[64];
-    sprintf(filename, "aec_buf%d.dat", webrtc_aec_instance_count);
+    snprintf(filename, sizeof(filename), "aec_buf%d.dat",
+             webrtc_aec_instance_count);
     aecpc->bufFile = fopen(filename, "wb");
-    sprintf(filename, "aec_skew%d.dat", webrtc_aec_instance_count);
+    snprintf(filename, sizeof(filename), "aec_skew%d.dat",
+             webrtc_aec_instance_count);
     aecpc->skewFile = fopen(filename, "wb");
-    sprintf(filename, "aec_delay%d.dat", webrtc_aec_instance_count);
+    snprintf(filename, sizeof(filename), "aec_delay%d.dat",
+             webrtc_aec_instance_count);
     aecpc->delayFile = fopen(filename, "wb");
     webrtc_aec_instance_count++;
   }
 #endif
 
   return aecpc;
 }
 
 void WebRtcAec_Free(void* aecInst) {
-  Aec* aecpc = (Aec*)aecInst;
+  Aec* aecpc = reinterpret_cast<Aec*>(aecInst);
 
   if (aecpc == NULL) {
     return;
   }
 
   WebRtc_FreeBuffer(aecpc->far_pre_buf);
 
 #ifdef WEBRTC_AEC_DEBUG_DUMP
   fclose(aecpc->bufFile);
   fclose(aecpc->skewFile);
   fclose(aecpc->delayFile);
 #endif
 
   WebRtcAec_FreeAec(aecpc->aec);
   WebRtcAec_FreeResampler(aecpc->resampler);
   free(aecpc);
 }
 
 int32_t WebRtcAec_Init(void* aecInst, int32_t sampFreq, int32_t scSampFreq) {
-  Aec* aecpc = (Aec*)aecInst;
+  Aec* aecpc = reinterpret_cast<Aec*>(aecInst);
   AecConfig aecConfig;
 
   if (sampFreq != 8000 && sampFreq != 16000 && sampFreq != 32000 &&
       sampFreq != 48000) {
     return AEC_BAD_PARAMETER_ERROR;
   }
   aecpc->sampFreq = sampFreq;
 
   if (scSampFreq < 1 || scSampFreq > 96000) {
     return AEC_BAD_PARAMETER_ERROR;
@@ skipping 60 matching lines @@
   }
 
   return 0;
 }
 
 // Returns any error that is caused when buffering the
 // far-end signal.
 int32_t WebRtcAec_GetBufferFarendError(void* aecInst,
                                        const float* farend,
                                        size_t nrOfSamples) {
-  Aec* aecpc = (Aec*)aecInst;
+  Aec* aecpc = reinterpret_cast<Aec*>(aecInst);
 
   if (!farend)
     return AEC_NULL_POINTER_ERROR;
 
   if (aecpc->initFlag != initCheck)
     return AEC_UNINITIALIZED_ERROR;
 
   // number of samples == 160 for SWB input
   if (nrOfSamples != 80 && nrOfSamples != 160)
     return AEC_BAD_PARAMETER_ERROR;
 
   return 0;
 }
 
 // only buffer L band for farend
 int32_t WebRtcAec_BufferFarend(void* aecInst,
                                const float* farend,
                                size_t nrOfSamples) {
-  Aec* aecpc = (Aec*)aecInst;
+  Aec* aecpc = reinterpret_cast<Aec*>(aecInst);
   size_t newNrOfSamples = nrOfSamples;
   float new_farend[MAX_RESAMP_LEN];
   const float* farend_ptr = farend;
 
   // Get any error caused by buffering the farend signal.
   int32_t error_code =
       WebRtcAec_GetBufferFarendError(aecInst, farend, nrOfSamples);
 
   if (error_code != 0)
     return error_code;
 
   if (aecpc->skewMode == kAecTrue && aecpc->resample == kAecTrue) {
     // Resample and get a new number of samples
     WebRtcAec_ResampleLinear(aecpc->resampler, farend, nrOfSamples, aecpc->skew,
                              new_farend, &newNrOfSamples);
     farend_ptr = new_farend;
   }
 
   aecpc->farend_started = 1;
-  WebRtcAec_SetSystemDelay(
-      aecpc->aec, WebRtcAec_system_delay(aecpc->aec) + (int)newNrOfSamples);
+  WebRtcAec_SetSystemDelay(aecpc->aec, WebRtcAec_system_delay(aecpc->aec) +
+                           static_cast<int>(newNrOfSamples));
 
   // Write the time-domain data to |far_pre_buf|.
   WebRtc_WriteBuffer(aecpc->far_pre_buf, farend_ptr, newNrOfSamples);
 
   // TODO(minyue): reduce to |PART_LEN| samples for each buffering, when
   // WebRtcAec_BufferFarendPartition() is changed to take |PART_LEN| samples.
   while (WebRtc_available_read(aecpc->far_pre_buf) >= PART_LEN2) {
     // We have enough data to pass to the FFT, hence read PART_LEN2 samples.
     {
       float* ptmp = NULL;
       float tmp[PART_LEN2];
-      WebRtc_ReadBuffer(aecpc->far_pre_buf, (void**)&ptmp, tmp, PART_LEN2);
+      WebRtc_ReadBuffer(aecpc->far_pre_buf,
+                        reinterpret_cast<void**>(&ptmp), tmp, PART_LEN2);
       WebRtcAec_BufferFarendPartition(aecpc->aec, ptmp);
     }
 
     // Rewind |far_pre_buf| PART_LEN samples for overlap before continuing.
     WebRtc_MoveReadPtr(aecpc->far_pre_buf, -PART_LEN);
   }
 
   return 0;
 }
 
 int32_t WebRtcAec_Process(void* aecInst,
                           const float* const* nearend,
                           size_t num_bands,
                           float* const* out,
                           size_t nrOfSamples,
                           int16_t msInSndCardBuf,
                           int32_t skew) {
-  Aec* aecpc = (Aec*)aecInst;
+  Aec* aecpc = reinterpret_cast<Aec*>(aecInst);
   int32_t retVal = 0;
 
   if (out == NULL) {
     return AEC_NULL_POINTER_ERROR;
   }
 
   if (aecpc->initFlag != initCheck) {
     return AEC_UNINITIALIZED_ERROR;
   }
 
@@ skipping 26 matching lines @@
     (void)fwrite(&far_buf_size_ms, 2, 1, aecpc->bufFile);
     (void)fwrite(&aecpc->knownDelay, sizeof(aecpc->knownDelay), 1,
                  aecpc->delayFile);
   }
 #endif
 
   return retVal;
 }
 
 int WebRtcAec_set_config(void* handle, AecConfig config) {
-  Aec* self = (Aec*)handle;
+  Aec* self = reinterpret_cast<Aec*>(handle);
   if (self->initFlag != initCheck) {
     return AEC_UNINITIALIZED_ERROR;
   }
 
   if (config.skewMode != kAecFalse && config.skewMode != kAecTrue) {
     return AEC_BAD_PARAMETER_ERROR;
   }
   self->skewMode = config.skewMode;
 
   if (config.nlpMode != kAecNlpConservative &&
       config.nlpMode != kAecNlpModerate &&
       config.nlpMode != kAecNlpAggressive) {
     return AEC_BAD_PARAMETER_ERROR;
   }
 
   if (config.metricsMode != kAecFalse && config.metricsMode != kAecTrue) {
     return AEC_BAD_PARAMETER_ERROR;
   }
 
   if (config.delay_logging != kAecFalse && config.delay_logging != kAecTrue) {
     return AEC_BAD_PARAMETER_ERROR;
   }
 
   WebRtcAec_SetConfigCore(self->aec, config.nlpMode, config.metricsMode,
                           config.delay_logging);
   return 0;
 }
 
 int WebRtcAec_get_echo_status(void* handle, int* status) {
-  Aec* self = (Aec*)handle;
+  Aec* self = reinterpret_cast<Aec*>(handle);
   if (status == NULL) {
     return AEC_NULL_POINTER_ERROR;
   }
   if (self->initFlag != initCheck) {
     return AEC_UNINITIALIZED_ERROR;
   }
 
   *status = WebRtcAec_echo_state(self->aec);
 
   return 0;
 }
 
 int WebRtcAec_GetMetrics(void* handle, AecMetrics* metrics) {
   const float kUpWeight = 0.7f;
   float dtmp;
   int stmp;
-  Aec* self = (Aec*)handle;
+  Aec* self = reinterpret_cast<Aec*>(handle);
   Stats erl;
   Stats erle;
   Stats a_nlp;
 
   if (handle == NULL) {
     return -1;
   }
   if (metrics == NULL) {
     return AEC_NULL_POINTER_ERROR;
   }
   if (self->initFlag != initCheck) {
     return AEC_UNINITIALIZED_ERROR;
   }
 
   WebRtcAec_GetEchoStats(self->aec, &erl, &erle, &a_nlp);
 
   // ERL
-  metrics->erl.instant = (int)erl.instant;
+  metrics->erl.instant = static_cast<int>(erl.instant);
 
   if ((erl.himean > kOffsetLevel) && (erl.average > kOffsetLevel)) {
     // Use a mix between regular average and upper part average.
     dtmp = kUpWeight * erl.himean + (1 - kUpWeight) * erl.average;
-    metrics->erl.average = (int)dtmp;
+    metrics->erl.average = static_cast<int>(dtmp);
   } else {
     metrics->erl.average = kOffsetLevel;
   }
 
-  metrics->erl.max = (int)erl.max;
+  metrics->erl.max = static_cast<int>(erl.max);
 
   if (erl.min < (kOffsetLevel * (-1))) {
-    metrics->erl.min = (int)erl.min;
+    metrics->erl.min = static_cast<int>(erl.min);
   } else {
     metrics->erl.min = kOffsetLevel;
   }
 
   // ERLE
-  metrics->erle.instant = (int)erle.instant;
+  metrics->erle.instant = static_cast<int>(erle.instant);
 
   if ((erle.himean > kOffsetLevel) && (erle.average > kOffsetLevel)) {
     // Use a mix between regular average and upper part average.
     dtmp = kUpWeight * erle.himean + (1 - kUpWeight) * erle.average;
-    metrics->erle.average = (int)dtmp;
+    metrics->erle.average = static_cast<int>(dtmp);
   } else {
     metrics->erle.average = kOffsetLevel;
   }
 
-  metrics->erle.max = (int)erle.max;
+  metrics->erle.max = static_cast<int>(erle.max);
 
   if (erle.min < (kOffsetLevel * (-1))) {
-    metrics->erle.min = (int)erle.min;
+    metrics->erle.min = static_cast<int>(erle.min);
   } else {
     metrics->erle.min = kOffsetLevel;
   }
 
   // RERL
   if ((metrics->erl.average > kOffsetLevel) &&
       (metrics->erle.average > kOffsetLevel)) {
     stmp = metrics->erl.average + metrics->erle.average;
   } else {
     stmp = kOffsetLevel;
   }
   metrics->rerl.average = stmp;
 
   // No other statistics needed, but returned for completeness.
   metrics->rerl.instant = stmp;
   metrics->rerl.max = stmp;
   metrics->rerl.min = stmp;
 
   // A_NLP
-  metrics->aNlp.instant = (int)a_nlp.instant;
+  metrics->aNlp.instant = static_cast<int>(a_nlp.instant);
 
   if ((a_nlp.himean > kOffsetLevel) && (a_nlp.average > kOffsetLevel)) {
     // Use a mix between regular average and upper part average.
     dtmp = kUpWeight * a_nlp.himean + (1 - kUpWeight) * a_nlp.average;
-    metrics->aNlp.average = (int)dtmp;
+    metrics->aNlp.average = static_cast<int>(dtmp);
   } else {
     metrics->aNlp.average = kOffsetLevel;
   }
 
-  metrics->aNlp.max = (int)a_nlp.max;
+  metrics->aNlp.max = static_cast<int>(a_nlp.max);
 
   if (a_nlp.min < (kOffsetLevel * (-1))) {
-    metrics->aNlp.min = (int)a_nlp.min;
+    metrics->aNlp.min = static_cast<int>(a_nlp.min);
   } else {
     metrics->aNlp.min = kOffsetLevel;
   }
 
   return 0;
 }
 
 int WebRtcAec_GetDelayMetrics(void* handle,
                               int* median,
                               int* std,
                               float* fraction_poor_delays) {
-  Aec* self = (Aec*)handle;
+  Aec* self = reinterpret_cast<Aec*>(handle);
   if (median == NULL) {
     return AEC_NULL_POINTER_ERROR;
   }
   if (std == NULL) {
     return AEC_NULL_POINTER_ERROR;
   }
   if (self->initFlag != initCheck) {
     return AEC_UNINITIALIZED_ERROR;
   }
   if (WebRtcAec_GetDelayMetricsCore(self->aec, median, std,
                                     fraction_poor_delays) == -1) {
     // Logging disabled.
     return AEC_UNSUPPORTED_FUNCTION_ERROR;
   }
 
   return 0;
 }
 
 AecCore* WebRtcAec_aec_core(void* handle) {
   if (!handle) {
     return NULL;
   }
-  return ((Aec*)handle)->aec;
+  return reinterpret_cast<Aec*>(handle)->aec;
 }
 
 static int ProcessNormal(Aec* aecpc,
                          const float* const* nearend,
                          size_t num_bands,
                          float* const* out,
                          size_t nrOfSamples,
                          int16_t msInSndCardBuf,
                          int32_t skew) {
   int retVal = 0;
@@ skipping 227 matching lines @@
 
   // 3) Compensate for non-causality, if needed, by flushing one block.
   if (current_delay < PART_LEN) {
     current_delay += WebRtcAec_MoveFarReadPtr(aecpc->aec, 1) * PART_LEN;
   }
 
   // We use -1 to signal an initialized state in the "extended" implementation;
   // compensate for that.
   aecpc->filtDelay = aecpc->filtDelay < 0 ? 0 : aecpc->filtDelay;
   aecpc->filtDelay =
-      WEBRTC_SPL_MAX(0, (short)(0.8 * aecpc->filtDelay + 0.2 * current_delay));
+      WEBRTC_SPL_MAX(0, static_cast<int16_t>(0.8 *
+                                             aecpc->filtDelay +
+                                             0.2 * current_delay));
 
   delay_difference = aecpc->filtDelay - aecpc->knownDelay;
   if (delay_difference > 224) {
     if (aecpc->lastDelayDiff < 96) {
       aecpc->timeForDelayChange = 0;
     } else {
       aecpc->timeForDelayChange++;
     }
   } else if (delay_difference < 96 && aecpc->knownDelay > 0) {
     if (aecpc->lastDelayDiff > 224) {
@@ skipping 32 matching lines @@
 
   // 3) Compensate for non-causality, if needed, by flushing two blocks.
   if (current_delay < PART_LEN) {
     current_delay += WebRtcAec_MoveFarReadPtr(self->aec, 2) * PART_LEN;
   }
 
   if (self->filtDelay == -1) {
     self->filtDelay = WEBRTC_SPL_MAX(0, 0.5 * current_delay);
   } else {
     self->filtDelay = WEBRTC_SPL_MAX(
-        0, (short)(0.95 * self->filtDelay + 0.05 * current_delay));
+        0, static_cast<int16_t>(0.95 * self->filtDelay + 0.05 * current_delay));
   }
 
   delay_difference = self->filtDelay - self->knownDelay;
   if (delay_difference > 384) {
     if (self->lastDelayDiff < 128) {
       self->timeForDelayChange = 0;
     } else {
       self->timeForDelayChange++;
     }
   } else if (delay_difference < 128 && self->knownDelay > 0) {
     if (self->lastDelayDiff > 384) {
       self->timeForDelayChange = 0;
     } else {
       self->timeForDelayChange++;
     }
   } else {
     self->timeForDelayChange = 0;
   }
   self->lastDelayDiff = delay_difference;
 
   if (self->timeForDelayChange > 25) {
     self->knownDelay = WEBRTC_SPL_MAX((int)self->filtDelay - 256, 0);
   }
 }