Update audio code to use size_t more correctly, webrtc/modules/audio_processing/

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 87 matching lines @@
 #ifdef WEBRTC_AEC_DEBUG_DUMP
 int webrtc_aec_instance_count = 0;
 #endif
 
 // Estimates delay to set the position of the far-end buffer read pointer
 // (controlled by knownDelay)
 static void EstBufDelayNormal(Aec* aecInst);
 static void EstBufDelayExtended(Aec* aecInst);
 static int ProcessNormal(Aec* self,
                          const float* const* near,
-                         int num_bands,
+                         size_t num_bands,
                          float* const* out,
-                         int16_t num_samples,
+                         size_t num_samples,
                          int16_t reported_delay_ms,
                          int32_t skew);
 static void ProcessExtended(Aec* self,
                             const float* const* near,
-                            int num_bands,
+                            size_t num_bands,
                             float* const* out,
-                            int16_t num_samples,
+                            size_t num_samples,
                             int16_t reported_delay_ms,
                             int32_t skew);
 
 void* WebRtcAec_Create() {
   Aec* aecpc = malloc(sizeof(Aec));
 
   if (!aecpc) {
     return NULL;
   }
 
@@ skipping 136 matching lines @@
     aecpc->lastError = AEC_UNSPECIFIED_ERROR;
     return -1;
   }
 
   return 0;
 }
 
 // only buffer L band for farend
 int32_t WebRtcAec_BufferFarend(void* aecInst,
                                const float* farend,
-                               int16_t nrOfSamples) {
+                               size_t nrOfSamples) {
   Aec* aecpc = aecInst;
-  int newNrOfSamples = nrOfSamples;
+  size_t newNrOfSamples = nrOfSamples;
   float new_farend[MAX_RESAMP_LEN];
   const float* farend_ptr = farend;
 
   if (farend == NULL) {
     aecpc->lastError = AEC_NULL_POINTER_ERROR;
     return -1;
   }
 
   if (aecpc->initFlag != initCheck) {
     aecpc->lastError = AEC_UNINITIALIZED_ERROR;
@@ skipping 11 matching lines @@
     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) + newNrOfSamples);
+  WebRtcAec_SetSystemDelay(
+      aecpc->aec, WebRtcAec_system_delay(aecpc->aec) + (int)newNrOfSamples);
 
   // Write the time-domain data to |far_pre_buf|.
-  WebRtc_WriteBuffer(aecpc->far_pre_buf, farend_ptr, (size_t)newNrOfSamples);
+  WebRtc_WriteBuffer(aecpc->far_pre_buf, farend_ptr, newNrOfSamples);
 
   // Transform to frequency domain if we have enough data.
   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);
       WebRtcAec_BufferFarendPartition(aecpc->aec, ptmp);
 #ifdef WEBRTC_AEC_DEBUG_DUMP
       WebRtc_WriteBuffer(
           WebRtcAec_far_time_buf(aecpc->aec), &ptmp[PART_LEN], 1);
 #endif
     }
 
     // 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,
-                          int num_bands,
+                          size_t num_bands,
                           float* const* out,
-                          int16_t nrOfSamples,
+                          size_t nrOfSamples,
                           int16_t msInSndCardBuf,
                           int32_t skew) {
   Aec* aecpc = aecInst;
   int32_t retVal = 0;
 
   if (out == NULL) {
     aecpc->lastError = AEC_NULL_POINTER_ERROR;
     return -1;
   }
 
@@ skipping 235 matching lines @@
 
 AecCore* WebRtcAec_aec_core(void* handle) {
   if (!handle) {
     return NULL;
   }
   return ((Aec*)handle)->aec;
 }
 
 static int ProcessNormal(Aec* aecpc,
                          const float* const* nearend,
-                         int num_bands,
+                         size_t num_bands,
                          float* const* out,
-                         int16_t nrOfSamples,
+                         size_t nrOfSamples,
                          int16_t msInSndCardBuf,
                          int32_t skew) {
   int retVal = 0;
-  short i;
-  short nBlocks10ms;
+  size_t i;
+  size_t nBlocks10ms;
   // Limit resampling to doubling/halving of signal
   const float minSkewEst = -0.5f;
   const float maxSkewEst = 1.0f;
 
   msInSndCardBuf =
       msInSndCardBuf > kMaxTrustedDelayMs ? kMaxTrustedDelayMs : msInSndCardBuf;
   // TODO(andrew): we need to investigate if this +10 is really wanted.
   msInSndCardBuf += 10;
   aecpc->msInSndCardBuf = msInSndCardBuf;
 
@@ skipping 120 matching lines @@
                             nrOfSamples,
                             aecpc->knownDelay,
                             out);
   }
 
   return retVal;
 }
 
 static void ProcessExtended(Aec* self,
                             const float* const* near,
-                            int num_bands,
+                            size_t num_bands,
                             float* const* out,
-                            int16_t num_samples,
+                            size_t num_samples,
                             int16_t reported_delay_ms,
                             int32_t skew) {
-  int i;
+  size_t i;
   const int delay_diff_offset = kDelayDiffOffsetSamples;
 #if defined(WEBRTC_UNTRUSTED_DELAY)
   reported_delay_ms = kFixedDelayMs;
 #else
   // This is the usual mode where we trust the reported system delay values.
   // Due to the longer filter, we no longer add 10 ms to the reported delay
   // to reduce chance of non-causality. Instead we apply a minimum here to avoid
   // issues with the read pointer jumping around needlessly.
   reported_delay_ms = reported_delay_ms < kMinTrustedDelayMs
                           ? kMinTrustedDelayMs
@@ skipping 155 matching lines @@
     }
   } else {
     self->timeForDelayChange = 0;
   }
   self->lastDelayDiff = delay_difference;
 
   if (self->timeForDelayChange > 25) {
     self->knownDelay = WEBRTC_SPL_MAX((int)self->filtDelay - 256, 0);
   }
 }