Made implicit casts in the echo canceller explicit.

webrtc/modules/audio_processing/aec/echo_cancellation.c

 /*
  *  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 146 matching lines @@
     sprintf(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 = aecInst;
+  Aec* aecpc = (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 = aecInst;
+  Aec* aecpc = (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 = aecInst;
+  Aec* aecpc = (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 = aecInst;
+  Aec* aecpc = (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;
@@ skipping 30 matching lines @@
   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 = aecInst;
+  Aec* aecpc = (Aec*)aecInst;
   int32_t retVal = 0;
 
   if (out == NULL) {
     return AEC_NULL_POINTER_ERROR;
   }
 
   if (aecpc->initFlag != initCheck) {
     return AEC_UNINITIALIZED_ERROR;
   }
 
@@ skipping 168 matching lines @@
     metrics->aNlp.min = kOffsetLevel;
   }
 
   return 0;
 }
 
 int WebRtcAec_GetDelayMetrics(void* handle,
                               int* median,
                               int* std,
                               float* fraction_poor_delays) {
-  Aec* self = handle;
+  Aec* self = (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,
@@ skipping 328 matching lines @@
     }
   } else {
     self->timeForDelayChange = 0;
   }
   self->lastDelayDiff = delay_difference;
 
   if (self->timeForDelayChange > 25) {
     self->knownDelay = WEBRTC_SPL_MAX((int)self->filtDelay - 256, 0);
   }
 }