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

webrtc/common_audio/resampler/sinc_resampler_unittest.cc

 /*
  *  Copyright (c) 2013 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 18 matching lines @@
 using testing::_;
 
 namespace webrtc {
 
 static const double kSampleRateRatio = 192000.0 / 44100.0;
 static const double kKernelInterpolationFactor = 0.5;
 
 // Helper class to ensure ChunkedResample() functions properly.
 class MockSource : public SincResamplerCallback {
  public:
-  MOCK_METHOD2(Run, void(int frames, float* destination));
+  MOCK_METHOD2(Run, void(size_t frames, float* destination));
 };
 
 ACTION(ClearBuffer) {
   memset(arg1, 0, arg0 * sizeof(float));
 }
 
 ACTION(FillBuffer) {
   // Value chosen arbitrarily such that SincResampler resamples it to something
   // easily representable on all platforms; e.g., using kSampleRateRatio this
   // becomes 1.81219.
   memset(arg1, 64, arg0 * sizeof(float));
 }
 
 // Test requesting multiples of ChunkSize() frames results in the proper number
 // of callbacks.
 TEST(SincResamplerTest, ChunkedResample) {
   MockSource mock_source;
 
   // Choose a high ratio of input to output samples which will result in quick
   // exhaustion of SincResampler's internal buffers.
   SincResampler resampler(kSampleRateRatio, SincResampler::kDefaultRequestSize,
                           &mock_source);
 
   static const int kChunks = 2;
-  int max_chunk_size = resampler.ChunkSize() * kChunks;
+  size_t max_chunk_size = resampler.ChunkSize() * kChunks;
   rtc::scoped_ptr<float[]> resampled_destination(new float[max_chunk_size]);
 
   // Verify requesting ChunkSize() frames causes a single callback.
   EXPECT_CALL(mock_source, Run(_, _))
       .Times(1).WillOnce(ClearBuffer());
   resampler.Resample(resampler.ChunkSize(), resampled_destination.get());
 
   // Verify requesting kChunks * ChunkSize() frames causes kChunks callbacks.
   testing::Mock::VerifyAndClear(&mock_source);
   EXPECT_CALL(mock_source, Run(_, _))
@@ skipping 14 matching lines @@
       .Times(1).WillOnce(FillBuffer());
   resampler.Resample(resampler.ChunkSize() / 2, resampled_destination.get());
   ASSERT_NE(resampled_destination[0], 0);
 
   // Flush and request more data, which should all be zeros now.
   resampler.Flush();
   testing::Mock::VerifyAndClear(&mock_source);
   EXPECT_CALL(mock_source, Run(_, _))
       .Times(1).WillOnce(ClearBuffer());
   resampler.Resample(resampler.ChunkSize() / 2, resampled_destination.get());
-  for (int i = 0; i < resampler.ChunkSize() / 2; ++i)
+  for (size_t i = 0; i < resampler.ChunkSize() / 2; ++i)
     ASSERT_FLOAT_EQ(resampled_destination[i], 0);
 }
 
 // Test flush resets the internal state properly.
 TEST(SincResamplerTest, DISABLED_SetRatioBench) {
   MockSource mock_source;
   SincResampler resampler(kSampleRateRatio, SincResampler::kDefaultRequestSize,
                           &mock_source);
 
   TickTime start = TickTime::Now();
@@ skipping 134 matching lines @@
   int input_rate_;
   int output_rate_;
   double rms_error_;
   double low_freq_error_;
 };
 
 // Tests resampling using a given input and output sample rate.
 TEST_P(SincResamplerTest, Resample) {
   // Make comparisons using one second of data.
   static const double kTestDurationSecs = 1;
-  const int input_samples = kTestDurationSecs * input_rate_;
-  const int output_samples = kTestDurationSecs * output_rate_;
+  const size_t input_samples =
+      static_cast<size_t>(kTestDurationSecs * input_rate_);
+  const size_t output_samples =
+      static_cast<size_t>(kTestDurationSecs * output_rate_);
 
   // Nyquist frequency for the input sampling rate.
   const double input_nyquist_freq = 0.5 * input_rate_;
 
   // Source for data to be resampled.
   SinusoidalLinearChirpSource resampler_source(
       input_rate_, input_samples, input_nyquist_freq, 0);
 
   const double io_ratio = input_rate_ / static_cast<double>(output_rate_);
   SincResampler resampler(io_ratio, SincResampler::kDefaultRequestSize,
@@ skipping 29 matching lines @@
   static const double kLowFrequencyNyquistRange = 0.7;
   static const double kHighFrequencyNyquistRange = 0.9;
 
   // Calculate Root-Mean-Square-Error and maximum error for the resampling.
   double sum_of_squares = 0;
   double low_freq_max_error = 0;
   double high_freq_max_error = 0;
   int minimum_rate = std::min(input_rate_, output_rate_);
   double low_frequency_range = kLowFrequencyNyquistRange * 0.5 * minimum_rate;
   double high_frequency_range = kHighFrequencyNyquistRange * 0.5 * minimum_rate;
-  for (int i = 0; i < output_samples; ++i) {
+  for (size_t i = 0; i < output_samples; ++i) {
     double error = fabs(resampled_destination[i] - pure_destination[i]);
 
     if (pure_source.Frequency(i) < low_frequency_range) {
       if (error > low_freq_max_error)
         low_freq_max_error = error;
     } else if (pure_source.Frequency(i) < high_frequency_range) {
       if (error > high_freq_max_error)
         high_freq_max_error = error;
     }
     // TODO(dalecurtis): Sanity check frequencies > kHighFrequencyNyquistRange.
@@ skipping 62 matching lines @@
         std::tr1::make_tuple(11025, 192000, kResamplingRMSError, -62.61),
         std::tr1::make_tuple(16000, 192000, kResamplingRMSError, -63.14),
         std::tr1::make_tuple(22050, 192000, kResamplingRMSError, -62.42),
         std::tr1::make_tuple(32000, 192000, kResamplingRMSError, -63.38),
         std::tr1::make_tuple(44100, 192000, kResamplingRMSError, -62.63),
         std::tr1::make_tuple(48000, 192000, kResamplingRMSError, -73.44),
         std::tr1::make_tuple(96000, 192000, kResamplingRMSError, -73.52),
         std::tr1::make_tuple(192000, 192000, kResamplingRMSError, -73.52)));
 
 }  // namespace webrtc