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

webrtc/modules/audio_processing/test/audio_processing_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 106 matching lines @@
   }
 }
 
 void VerifyChannelsAreEqual(int16_t* stereo, int samples_per_channel) {
   for (int i = 0; i < samples_per_channel; i++) {
     EXPECT_EQ(stereo[i * 2 + 1], stereo[i * 2]);
   }
 }
 
 void SetFrameTo(AudioFrame* frame, int16_t value) {
-  for (int i = 0; i < frame->samples_per_channel_ * frame->num_channels_; ++i) {
+  for (size_t i = 0; i < frame->samples_per_channel_ * frame->num_channels_;
+       ++i) {
     frame->data_[i] = value;
   }
 }
 
 void SetFrameTo(AudioFrame* frame, int16_t left, int16_t right) {
   ASSERT_EQ(2, frame->num_channels_);
-  for (int i = 0; i < frame->samples_per_channel_ * 2; i += 2) {
+  for (size_t i = 0; i < frame->samples_per_channel_ * 2; i += 2) {
     frame->data_[i] = left;
     frame->data_[i + 1] = right;
   }
 }
 
 void ScaleFrame(AudioFrame* frame, float scale) {
-  for (int i = 0; i < frame->samples_per_channel_ * frame->num_channels_; ++i) {
+  for (size_t i = 0; i < frame->samples_per_channel_ * frame->num_channels_;
+       ++i) {
     frame->data_[i] = FloatS16ToS16(frame->data_[i] * scale);
   }
 }
 
 bool FrameDataAreEqual(const AudioFrame& frame1, const AudioFrame& frame2) {
   if (frame1.samples_per_channel_ != frame2.samples_per_channel_) {
     return false;
   }
   if (frame1.num_channels_ != frame2.num_channels_) {
     return false;
@@ skipping 498 matching lines @@
   }
 
   rewind(near_file_);
   while (!frame_queue.empty()) {
     AudioFrame* frame = frame_queue.front();
     frame_queue.pop();
     delete frame;
   }
   // Calculate expected delay estimate and acceptable regions. Further,
   // limit them w.r.t. AEC delay estimation support.
-  const int samples_per_ms = std::min(16, frame_->samples_per_channel_ / 10);
+  const size_t samples_per_ms =
+      std::min(static_cast<size_t>(16), frame_->samples_per_channel_ / 10);
   int expected_median = std::min(std::max(delay_ms - system_delay_ms,
                                           delay_min), delay_max);
-  int expected_median_high = std::min(std::max(
-      expected_median + 96 / samples_per_ms, delay_min), delay_max);
-  int expected_median_low = std::min(std::max(
-      expected_median - 96 / samples_per_ms, delay_min), delay_max);
+  int expected_median_high = std::min(
+      std::max(expected_median + static_cast<int>(96 / samples_per_ms),
+               delay_min),
+      delay_max);
+  int expected_median_low = std::min(
+      std::max(expected_median - static_cast<int>(96 / samples_per_ms),
+               delay_min),
+      delay_max);
   // Verify delay metrics.
   int median;
   int std;
   float poor_fraction;
   EXPECT_EQ(apm_->kNoError,
             apm_->echo_cancellation()->GetDelayMetrics(&median, &std,
                                                        &poor_fraction));
   EXPECT_GE(expected_median_high, median);
   EXPECT_LE(expected_median_low, median);
 }
@@ skipping 239 matching lines @@
   // sampling frequency dependent.
   for (size_t i = 0; i < kProcessSampleRatesSize; i++) {
     Init(kProcessSampleRates[i],
          kProcessSampleRates[i],
          kProcessSampleRates[i],
          2,
          2,
          2,
          false);
     // Sampling frequency dependent variables.
-    const int num_ms_per_block = std::max(4,
-                                          640 / frame_->samples_per_channel_);
+    const int num_ms_per_block =
+        std::max(4, static_cast<int>(640 / frame_->samples_per_channel_));
     const int delay_min_ms = -kLookaheadBlocks * num_ms_per_block;
     const int delay_max_ms = (kMaxDelayBlocks - 1) * num_ms_per_block;
 
     // 1) Verify correct delay estimate at lookahead boundary.
     int delay_ms = TruncateToMultipleOf10(kSystemDelayMs + delay_min_ms);
     ProcessDelayVerificationTest(delay_ms, kSystemDelayMs, delay_min_ms,
                                  delay_max_ms);
     // 2) A delay less than maximum lookahead should give an delay estimate at
     //    the boundary (= -kLookaheadBlocks * num_ms_per_block).
     delay_ms -= 20;
@@ skipping 1682 matching lines @@
         std::tr1::make_tuple(16000, 16000, 32000, 40),
         std::tr1::make_tuple(16000, 16000, 16000, 0)));
 #endif
 
 // TODO(henrike): re-implement functionality lost when removing the old main
 //                function. See
 //                https://code.google.com/p/webrtc/issues/detail?id=1981
 
 }  // namespace
 }  // namespace webrtc