Update a ton of audio code to use size_t more correctly and in general reduce

webrtc/modules/audio_processing/aec/system_delay_unittest.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 15 matching lines @@
   virtual void TearDown();
 
   // Initialization of AEC handle with respect to |sample_rate_hz|. Since the
   // device sample rate is unimportant we set that value to 48000 Hz.
   void Init(int sample_rate_hz);
 
   // Makes one render call and one capture call in that specific order.
   void RenderAndCapture(int device_buffer_ms);
 
   // Fills up the far-end buffer with respect to the default device buffer size.
-  int BufferFillUp();
+  size_t BufferFillUp();
 
   // Runs and verifies the behavior in a stable startup procedure.
   void RunStableStartup();
 
   // Maps buffer size in ms into samples, taking the unprocessed frame into
   // account.
   int MapBufferSizeToSamples(int size_in_ms, bool extended_filter);
 
   void* handle_;
   Aec* self_;
-  int samples_per_frame_;
+  size_t samples_per_frame_;
   // Dummy input/output speech data.
   static const int kSamplesPerChunk = 160;
   float far_[kSamplesPerChunk];
   float near_[kSamplesPerChunk];
   float out_[kSamplesPerChunk];
   const float* near_ptr_;
   float* out_ptr_;
 };
 
 SystemDelayTest::SystemDelayTest()
@@ skipping 37 matching lines @@
 // phase after |kMaxConvergenceMs| independent of device buffer stability
 // conditions.
 static const int kMaxConvergenceMs = 500;
 
 void SystemDelayTest::Init(int sample_rate_hz) {
   // Initialize AEC
   EXPECT_EQ(0, WebRtcAec_Init(handle_, sample_rate_hz, 48000));
   EXPECT_EQ(0, WebRtcAec_system_delay(self_->aec));
 
   // One frame equals 10 ms of data.
-  samples_per_frame_ = sample_rate_hz / 100;
+  samples_per_frame_ = static_cast<size_t>(sample_rate_hz / 100);
 }
 
 void SystemDelayTest::RenderAndCapture(int device_buffer_ms) {
   EXPECT_EQ(0, WebRtcAec_BufferFarend(handle_, far_, samples_per_frame_));
   EXPECT_EQ(0,
             WebRtcAec_Process(handle_,
                               &near_ptr_,
                               1,
                               &out_ptr_,
                               samples_per_frame_,
                               device_buffer_ms,
                               0));
 }
 
-int SystemDelayTest::BufferFillUp() {
+size_t SystemDelayTest::BufferFillUp() {
   // To make sure we have a full buffer when we verify stability we first fill
   // up the far-end buffer with the same amount as we will report in through
   // Process().
-  int buffer_size = 0;
+  size_t buffer_size = 0;
   for (int i = 0; i < kDeviceBufMs / 10; i++) {
     EXPECT_EQ(0, WebRtcAec_BufferFarend(handle_, far_, samples_per_frame_));
     buffer_size += samples_per_frame_;
-    EXPECT_EQ(buffer_size, WebRtcAec_system_delay(self_->aec));
+    EXPECT_EQ(static_cast<int>(buffer_size),
+              WebRtcAec_system_delay(self_->aec));
   }
   return buffer_size;
 }
 
 void SystemDelayTest::RunStableStartup() {
   // To make sure we have a full buffer when we verify stability we first fill
   // up the far-end buffer with the same amount as we will report in through
   // Process().
-  int buffer_size = BufferFillUp();
+  size_t buffer_size = BufferFillUp();
 
   if (WebRtcAec_delay_agnostic_enabled(self_->aec) == 1) {
     // In extended_filter mode we set the buffer size after the first processed
     // 10 ms chunk. Hence, we don't need to wait for the reported system delay
     // values to become stable.
     RenderAndCapture(kDeviceBufMs);
     buffer_size += samples_per_frame_;
     EXPECT_EQ(0, self_->startup_phase);
   } else {
     // A stable device should be accepted and put in a regular process mode
     // within |kStableConvergenceMs|.
     int process_time_ms = 0;
     for (; process_time_ms < kStableConvergenceMs; process_time_ms += 10) {
       RenderAndCapture(kDeviceBufMs);
       buffer_size += samples_per_frame_;
       if (self_->startup_phase == 0) {
         // We have left the startup phase.
         break;
       }
     }
     // Verify convergence time.
     EXPECT_GT(kStableConvergenceMs, process_time_ms);
   }
   // Verify that the buffer has been flushed.
-  EXPECT_GE(buffer_size, WebRtcAec_system_delay(self_->aec));
+  EXPECT_GE(static_cast<int>(buffer_size),
+            WebRtcAec_system_delay(self_->aec));
 }
 
   int SystemDelayTest::MapBufferSizeToSamples(int size_in_ms,
                                               bool extended_filter) {
   // If extended_filter is disabled we add an extra 10 ms for the unprocessed
   // frame. That is simply how the algorithm is constructed.
-  return (size_in_ms + (extended_filter ? 0 : 10)) * samples_per_frame_ / 10;
+  return static_cast<int>(
+      (size_in_ms + (extended_filter ? 0 : 10)) * samples_per_frame_ / 10);
 }
 
 // The tests should meet basic requirements and not be adjusted to what is
 // actually implemented. If we don't get good code coverage this way we either
 // lack in tests or have unnecessary code.
 // General requirements:
 // 1) If we add far-end data the system delay should be increased with the same
 //    amount we add.
 // 2) If the far-end buffer is full we should flush the oldest data to make room
 //    for the new. In this case the system delay is unaffected.
@@ skipping 20 matching lines @@
     for (int da_aec = 0; da_aec <= 1; ++da_aec) {
       WebRtcAec_enable_delay_agnostic(self_->aec, da_aec);
       EXPECT_EQ(da_aec, WebRtcAec_delay_agnostic_enabled(self_->aec));
       for (size_t i = 0; i < kNumSampleRates; i++) {
         Init(kSampleRateHz[i]);
         // Loop through a couple of calls to make sure the system delay
         // increments correctly.
         for (int j = 1; j <= 5; j++) {
           EXPECT_EQ(0,
                     WebRtcAec_BufferFarend(handle_, far_, samples_per_frame_));
-          EXPECT_EQ(j * samples_per_frame_, WebRtcAec_system_delay(self_->aec));
+          EXPECT_EQ(static_cast<int>(j * samples_per_frame_),
+                    WebRtcAec_system_delay(self_->aec));
         }
       }
     }
   }
 }
 
 // TODO(bjornv): Add a test to verify behavior if the far-end buffer is full
 // when adding new data.
 
 TEST_F(SystemDelayTest, CorrectDelayAfterStableStartup) {
   // We run the system in a stable startup. After that we verify that the system
   // delay meets the requirements.
   // This process should be independent of DA-AEC and extended_filter mode.
   for (int extended_filter = 0; extended_filter <= 1; ++extended_filter) {
     WebRtcAec_enable_extended_filter(self_->aec, extended_filter);
     EXPECT_EQ(extended_filter, WebRtcAec_extended_filter_enabled(self_->aec));
     for (int da_aec = 0; da_aec <= 1; ++da_aec) {
       WebRtcAec_enable_delay_agnostic(self_->aec, da_aec);
       EXPECT_EQ(da_aec, WebRtcAec_delay_agnostic_enabled(self_->aec));
       for (size_t i = 0; i < kNumSampleRates; i++) {
         Init(kSampleRateHz[i]);
         RunStableStartup();
 
         // Verify system delay with respect to requirements, i.e., the
         // |system_delay| is in the interval [75%, 100%] of what's reported on
         // the average.
         // In extended_filter mode we target 50% and measure after one processed
         // 10 ms chunk.
-        int average_reported_delay = kDeviceBufMs * samples_per_frame_ / 10;
+        int average_reported_delay =
+            static_cast<int>(kDeviceBufMs * samples_per_frame_ / 10);
         EXPECT_GE(average_reported_delay, WebRtcAec_system_delay(self_->aec));
         int lower_bound = WebRtcAec_extended_filter_enabled(self_->aec)
                               ? average_reported_delay / 2 - samples_per_frame_
                               : average_reported_delay * 3 / 4;
         EXPECT_LE(lower_bound, WebRtcAec_system_delay(self_->aec));
       }
     }
   }
 }
 
@@ skipping 10 matching lines @@
   // On the last frame the AEC buffer is adjusted to 60% of the last reported
   // device buffer size.
   // We construct an unstable system by altering the device buffer size between
   // two values |kDeviceBufMs| +- 25 ms.
   for (size_t i = 0; i < kNumSampleRates; i++) {
     Init(kSampleRateHz[i]);
 
     // To make sure we have a full buffer when we verify stability we first fill
     // up the far-end buffer with the same amount as we will report in on the
     // average through Process().
-    int buffer_size = BufferFillUp();
+    size_t buffer_size = BufferFillUp();
 
     int buffer_offset_ms = 25;
     int reported_delay_ms = 0;
     int process_time_ms = 0;
     for (; process_time_ms <= kMaxConvergenceMs; process_time_ms += 10) {
       reported_delay_ms = kDeviceBufMs + buffer_offset_ms;
       RenderAndCapture(reported_delay_ms);
       buffer_size += samples_per_frame_;
       buffer_offset_ms = -buffer_offset_ms;
       if (self_->startup_phase == 0) {
         // We have left the startup phase.
         break;
       }
     }
     // Verify convergence time.
     EXPECT_GE(kMaxConvergenceMs, process_time_ms);
     // Verify that the buffer has been flushed.
-    EXPECT_GE(buffer_size, WebRtcAec_system_delay(self_->aec));
+    EXPECT_GE(static_cast<int>(buffer_size),
+              WebRtcAec_system_delay(self_->aec));
 
     // Verify system delay with respect to requirements, i.e., the
     // |system_delay| is in the interval [60%, 100%] of what's last reported.
-    EXPECT_GE(reported_delay_ms * samples_per_frame_ / 10,
+    EXPECT_GE(static_cast<int>(reported_delay_ms * samples_per_frame_ / 10),
               WebRtcAec_system_delay(self_->aec));
-    EXPECT_LE(reported_delay_ms * samples_per_frame_ / 10 * 3 / 5,
-              WebRtcAec_system_delay(self_->aec));
+    EXPECT_LE(
+        static_cast<int>(reported_delay_ms * samples_per_frame_ / 10 * 3 / 5),
+        WebRtcAec_system_delay(self_->aec));
   }
 }
 
 TEST_F(SystemDelayTest, CorrectDelayAfterStableBufferBuildUp) {
   // This test does not apply in extended_filter mode, since we only use the
   // the first 10 ms chunk to determine a reasonable buffer size. Neither does
   // it apply if DA-AEC is on because that overrides the startup procedure.
   WebRtcAec_enable_extended_filter(self_->aec, 0);
   EXPECT_EQ(0, WebRtcAec_extended_filter_enabled(self_->aec));
   WebRtcAec_enable_delay_agnostic(self_->aec, 0);
@@ skipping 18 matching lines @@
                                   &out_ptr_,
                                   samples_per_frame_,
                                   kDeviceBufMs,
                                   0));
     }
     // Verify that a buffer size has been established.
     EXPECT_EQ(0, self_->checkBuffSize);
 
     // We now have established the required buffer size. Let us verify that we
     // fill up before leaving the startup phase for normal processing.
-    int buffer_size = 0;
-    int target_buffer_size = kDeviceBufMs * samples_per_frame_ / 10 * 3 / 4;
+    size_t buffer_size = 0;
+    size_t target_buffer_size = kDeviceBufMs * samples_per_frame_ / 10 * 3 / 4;
     process_time_ms = 0;
     for (; process_time_ms <= kMaxConvergenceMs; process_time_ms += 10) {
       RenderAndCapture(kDeviceBufMs);
       buffer_size += samples_per_frame_;
       if (self_->startup_phase == 0) {
         // We have left the startup phase.
         break;
       }
     }
     // Verify convergence time.
     EXPECT_GT(kMaxConvergenceMs, process_time_ms);
     // Verify that the buffer has reached the desired size.
-    EXPECT_LE(target_buffer_size, WebRtcAec_system_delay(self_->aec));
+    EXPECT_LE(static_cast<int>(target_buffer_size),
+              WebRtcAec_system_delay(self_->aec));
 
     // Verify normal behavior (system delay is kept constant) after startup by
     // running a couple of calls to BufferFarend() and Process().
     for (int j = 0; j < 6; j++) {
       int system_delay_before_calls = WebRtcAec_system_delay(self_->aec);
       RenderAndCapture(kDeviceBufMs);
       EXPECT_EQ(system_delay_before_calls, WebRtcAec_system_delay(self_->aec));
     }
   }
 }
@@ skipping 226 matching lines @@
           EXPECT_LE(0, WebRtcAec_system_delay(self_->aec));
         }
         // Verify we are not in a non-causal state.
         EXPECT_FALSE(non_causal);
       }
     }
   }
 }
 
 }  // namespace