Move aec_resampler.c to be built using C++

webrtc/modules/audio_processing/aec/aec_resampler.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.
  */
 
@@ skipping 25 matching lines @@
 static int EstimateSkew(const int* rawSkew,
                         int size,
                         int absLimit,
                         float* skewEst);
 
 void* WebRtcAec_CreateResampler() {
   return malloc(sizeof(AecResampler));
 }
 
 int WebRtcAec_InitResampler(void* resampInst, int deviceSampleRateHz) {
-  AecResampler* obj = (AecResampler*)resampInst;
+  AecResampler* obj = static_cast<AecResampler*>(resampInst);
   memset(obj->buffer, 0, sizeof(obj->buffer));
   obj->position = 0.0;
 
   obj->deviceSampleRateHz = deviceSampleRateHz;
   memset(obj->skewData, 0, sizeof(obj->skewData));
   obj->skewDataIndex = 0;
   obj->skewEstimate = 0.0;
 
   return 0;
 }
 
 void WebRtcAec_FreeResampler(void* resampInst) {
-  AecResampler* obj = (AecResampler*)resampInst;
+  AecResampler* obj = static_cast<AecResampler*>(resampInst);
   free(obj);
 }
 
 void WebRtcAec_ResampleLinear(void* resampInst,
                               const float* inspeech,
                               size_t size,
                               float skew,
                               float* outspeech,
                               size_t* size_out) {
-  AecResampler* obj = (AecResampler*)resampInst;
+  AecResampler* obj = static_cast<AecResampler*>(resampInst);
 
   float* y;
   float be, tnew;
   size_t tn, mm;
 
   assert(size <= 2 * FRAME_LEN);
   assert(resampInst != NULL);
   assert(inspeech != NULL);
   assert(outspeech != NULL);
   assert(size_out != NULL);
@@ skipping 11 matching lines @@
 
   tnew = be * mm + obj->position;
   tn = (size_t)tnew;
 
   while (tn < size) {
     // Interpolation
     outspeech[mm] = y[tn] + (tnew - tn) * (y[tn + 1] - y[tn]);
     mm++;
 
     tnew = be * mm + obj->position;
-    tn = (int)tnew;
+    tn = static_cast<int>(tnew);
   }
 
   *size_out = mm;
   obj->position += (*size_out) * be - size;
 
   // Shift buffer
   memmove(obj->buffer, &obj->buffer[size],
           (kResamplerBufferSize - size) * sizeof(obj->buffer[0]));
 }
 
 int WebRtcAec_GetSkew(void* resampInst, int rawSkew, float* skewEst) {
-  AecResampler* obj = (AecResampler*)resampInst;
+  AecResampler* obj = static_cast<AecResampler*>(resampInst);
   int err = 0;
 
   if (obj->skewDataIndex < kEstimateLengthFrames) {
     obj->skewData[obj->skewDataIndex] = rawSkew;
     obj->skewDataIndex++;
   } else if (obj->skewDataIndex == kEstimateLengthFrames) {
     err = EstimateSkew(obj->skewData, kEstimateLengthFrames,
                        obj->deviceSampleRateHz, skewEst);
     obj->skewEstimate = *skewEst;
     obj->skewDataIndex++;
   } else {
     *skewEst = obj->skewEstimate;
   }
 
   return err;
 }
 
 int EstimateSkew(const int* rawSkew,
                  int size,
                  int deviceSampleRateHz,
                  float* skewEst) {
-  const int absLimitOuter = (int)(0.04f * deviceSampleRateHz);
-  const int absLimitInner = (int)(0.0025f * deviceSampleRateHz);
+  const int absLimitOuter = static_cast<int>(0.04f * deviceSampleRateHz);
+  const int absLimitInner = static_cast<int>(0.0025f * deviceSampleRateHz);
   int i = 0;
   int n = 0;
   float rawAvg = 0;
   float err = 0;
   float rawAbsDev = 0;
   int upperLimit = 0;
   int lowerLimit = 0;
   float cumSum = 0;
   float x = 0;
   float x2 = 0;
@@ skipping 18 matching lines @@
   rawAvg /= n;
 
   for (i = 0; i < size; i++) {
     if ((rawSkew[i] < absLimitOuter && rawSkew[i] > -absLimitOuter)) {
       err = rawSkew[i] - rawAvg;
       rawAbsDev += err >= 0 ? err : -err;
     }
   }
   assert(n > 0);
   rawAbsDev /= n;
-  upperLimit = (int)(rawAvg + 5 * rawAbsDev + 1);  // +1 for ceiling.
-  lowerLimit = (int)(rawAvg - 5 * rawAbsDev - 1);  // -1 for floor.
+  upperLimit = static_cast<int>(rawAvg + 5 * rawAbsDev + 1);  // +1 for ceiling.
+  lowerLimit = static_cast<int>(rawAvg - 5 * rawAbsDev - 1);  // -1 for floor.
 
   n = 0;
   for (i = 0; i < size; i++) {
     if ((rawSkew[i] < absLimitInner && rawSkew[i] > -absLimitInner) ||
         (rawSkew[i] < upperLimit && rawSkew[i] > lowerLimit)) {
       n++;
       cumSum += rawSkew[i];
       x += n;
       x2 += n * n;
       y += cumSum;
       xy += n * cumSum;
     }
   }
 
   if (n == 0) {
     return -1;
   }
   assert(n > 0);
   xAvg = x / n;
   denom = x2 - xAvg * x;
 
   if (denom != 0) {
     skew = (xy - xAvg * y) / denom;
   }
 
   *skewEst = skew;
   return 0;
 }