Changed the delay estimator to be built using C++

webrtc/modules/audio_processing/utility/delay_estimator.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 258 matching lines @@
 
   free(self);
 }
 
 BinaryDelayEstimatorFarend* WebRtc_CreateBinaryDelayEstimatorFarend(
     int history_size) {
   BinaryDelayEstimatorFarend* self = NULL;
 
   if (history_size > 1) {
     // Sanity conditions fulfilled.
-    self = malloc(sizeof(BinaryDelayEstimatorFarend));
+    self = static_cast<BinaryDelayEstimatorFarend*>(
+        malloc(sizeof(BinaryDelayEstimatorFarend)));
   }
   if (self == NULL) {
     return NULL;
   }
 
   self->history_size = 0;
   self->binary_far_history = NULL;
   self->far_bit_counts = NULL;
   if (WebRtc_AllocateFarendBufferMemory(self, history_size) == 0) {
     WebRtc_FreeBinaryDelayEstimatorFarend(self);
     self = NULL;
   }
   return self;
 }
 
 int WebRtc_AllocateFarendBufferMemory(BinaryDelayEstimatorFarend* self,
                                       int history_size) {
   assert(self != NULL);
   // (Re-)Allocate memory for history buffers.
-  self->binary_far_history =
+  self->binary_far_history = static_cast<uint32_t*>(
       realloc(self->binary_far_history,
-              history_size * sizeof(*self->binary_far_history));
-  self->far_bit_counts = realloc(self->far_bit_counts,
-                                 history_size * sizeof(*self->far_bit_counts));
+              history_size * sizeof(*self->binary_far_history)));
+  self->far_bit_counts = static_cast<int*>(
+      realloc(self->far_bit_counts,
+              history_size * sizeof(*self->far_bit_counts)));
   if ((self->binary_far_history == NULL) || (self->far_bit_counts == NULL)) {
     history_size = 0;
   }
   // Fill with zeros if we have expanded the buffers.
   if (history_size > self->history_size) {
     int size_diff = history_size - self->history_size;
     memset(&self->binary_far_history[self->history_size],
            0,
            sizeof(*self->binary_far_history) * size_diff);
     memset(&self->far_bit_counts[self->history_size],
@@ skipping 83 matching lines @@
 
   free(self);
 }
 
 BinaryDelayEstimator* WebRtc_CreateBinaryDelayEstimator(
     BinaryDelayEstimatorFarend* farend, int max_lookahead) {
   BinaryDelayEstimator* self = NULL;
 
   if ((farend != NULL) && (max_lookahead >= 0)) {
     // Sanity conditions fulfilled.
-    self = malloc(sizeof(BinaryDelayEstimator));
+    self = static_cast<BinaryDelayEstimator*>(
+        malloc(sizeof(BinaryDelayEstimator)));
   }
   if (self == NULL) {
     return NULL;
   }
 
   self->farend = farend;
   self->near_history_size = max_lookahead + 1;
   self->history_size = 0;
   self->robust_validation_enabled = 0;  // Disabled by default.
   self->allowed_offset = 0;
 
   self->lookahead = max_lookahead;
 
   // Allocate memory for spectrum and history buffers.
   self->mean_bit_counts = NULL;
   self->bit_counts = NULL;
   self->histogram = NULL;
-  self->binary_near_history =
-      malloc((max_lookahead + 1) * sizeof(*self->binary_near_history));
+  self->binary_near_history = static_cast<uint32_t*>(
+      malloc((max_lookahead + 1) * sizeof(*self->binary_near_history)));
   if (self->binary_near_history == NULL ||
       WebRtc_AllocateHistoryBufferMemory(self, farend->history_size) == 0) {
     WebRtc_FreeBinaryDelayEstimator(self);
     self = NULL;
   }
 
   return self;
 }
 
 int WebRtc_AllocateHistoryBufferMemory(BinaryDelayEstimator* self,
                                        int history_size) {
   BinaryDelayEstimatorFarend* far = self->farend;
   // (Re-)Allocate memory for spectrum and history buffers.
   if (history_size != far->history_size) {
     // Only update far-end buffers if we need.
     history_size = WebRtc_AllocateFarendBufferMemory(far, history_size);
   }
   // The extra array element in |mean_bit_counts| and |histogram| is a dummy
   // element only used while |last_delay| == -2, i.e., before we have a valid
   // estimate.
-  self->mean_bit_counts =
+  self->mean_bit_counts = static_cast<int32_t*>(
       realloc(self->mean_bit_counts,
-              (history_size + 1) * sizeof(*self->mean_bit_counts));
-  self->bit_counts =
-      realloc(self->bit_counts, history_size * sizeof(*self->bit_counts));
-  self->histogram =
-      realloc(self->histogram, (history_size + 1) * sizeof(*self->histogram));
+              (history_size + 1) * sizeof(*self->mean_bit_counts)));
+  self->bit_counts = static_cast<int32_t*>(
+      realloc(self->bit_counts, history_size * sizeof(*self->bit_counts)));
+  self->histogram = static_cast<float*>(
+      realloc(self->histogram, (history_size + 1) * sizeof(*self->histogram)));
 
   if ((self->mean_bit_counts == NULL) ||
       (self->bit_counts == NULL) ||
       (self->histogram == NULL)) {
     history_size = 0;
   }
   // Fill with zeros if we have expanded the buffers.
   if (history_size > self->history_size) {
     int size_diff = history_size - self->history_size;
     memset(&self->mean_bit_counts[self->history_size],
@@ skipping 211 matching lines @@
   int32_t diff = new_value - *mean_value;
 
   // mean_new = mean_value + ((new_value - mean_value) >> factor);
   if (diff < 0) {
     diff = -((-diff) >> factor);
   } else {
     diff = (diff >> factor);
   }
   *mean_value += diff;
 }