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

webrtc/modules/audio_coding/neteq/neteq_stereo_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 25 matching lines @@
 //
 // The objective of the test is to create a mono input signal and a
 // multi-channel input signal, where each channel is identical to the mono
 // input channel. The two input signals are processed through their respective
 // NetEq instances. After that, the output signals are compared. The expected
 // result is that each channel in the multi-channel output is identical to the
 // mono output.
 class NetEqStereoTest : public ::testing::TestWithParam<TestParameters> {
  protected:
   static const int kTimeStepMs = 10;
-  static const int kMaxBlockSize = 480;  // 10 ms @ 48 kHz.
+  static const size_t kMaxBlockSize = 480;  // 10 ms @ 48 kHz.
   static const uint8_t kPayloadTypeMono = 95;
   static const uint8_t kPayloadTypeMulti = 96;
 
   NetEqStereoTest()
       : num_channels_(GetParam().num_channels),
         sample_rate_hz_(GetParam().sample_rate),
         samples_per_ms_(sample_rate_hz_ / 1000),
         frame_size_ms_(GetParam().frame_size),
-        frame_size_samples_(frame_size_ms_ * samples_per_ms_),
+        frame_size_samples_(
+            static_cast<size_t>(frame_size_ms_ * samples_per_ms_)),
         output_size_samples_(10 * samples_per_ms_),
         rtp_generator_mono_(samples_per_ms_),
         rtp_generator_(samples_per_ms_),
         payload_size_bytes_(0),
         multi_payload_size_bytes_(0),
         last_send_time_(0),
         last_arrival_time_(0) {
     NetEq::Config config;
     config.sample_rate_hz = sample_rate_hz_;
     neteq_mono_ = NetEq::Create(config);
@@ skipping 139 matching lines @@
                                        next_arrival_time));
         // Get next input packets (mono and multi-channel).
         do {
           next_send_time = GetNewPackets();
           ASSERT_NE(-1, next_send_time);
           next_arrival_time = GetArrivalTime(next_send_time);
         } while (Lost());  // If lost, immediately read the next packet.
       }
       NetEqOutputType output_type;
       // Get audio from mono instance.
-      int samples_per_channel;
+      size_t samples_per_channel;
       int num_channels;
       EXPECT_EQ(NetEq::kOK,
                 neteq_mono_->GetAudio(kMaxBlockSize, output_,
                                       &samples_per_channel, &num_channels,
                                       &output_type));
       EXPECT_EQ(1, num_channels);
       EXPECT_EQ(output_size_samples_, samples_per_channel);
       // Get audio from multi-channel instance.
       ASSERT_EQ(NetEq::kOK,
                 neteq_->GetAudio(kMaxBlockSize * num_channels_,
                                  output_multi_channel_,
                                  &samples_per_channel, &num_channels,
                                  &output_type));
       EXPECT_EQ(num_channels_, num_channels);
       EXPECT_EQ(output_size_samples_, samples_per_channel);
       std::ostringstream ss;
       ss << "Lap number " << k << ".";
       SCOPED_TRACE(ss.str());  // Print out the parameter values on failure.
       // Compare mono and multi-channel.
       ASSERT_NO_FATAL_FAILURE(VerifyOutput(output_size_samples_));
 
       time_now += kTimeStepMs;
     }
   }
 
   const int num_channels_;
   const int sample_rate_hz_;
   const int samples_per_ms_;
   const int frame_size_ms_;
-  const int frame_size_samples_;
-  const int output_size_samples_;
+  const size_t frame_size_samples_;
+  const size_t output_size_samples_;
   NetEq* neteq_mono_;
   NetEq* neteq_;
   test::RtpGenerator rtp_generator_mono_;
   test::RtpGenerator rtp_generator_;
   int16_t* input_;
   int16_t* input_multi_channel_;
   uint8_t* encoded_;
   uint8_t* encoded_multi_channel_;
   int16_t output_[kMaxBlockSize];
   int16_t* output_multi_channel_;
   WebRtcRTPHeader rtp_header_mono_;
   WebRtcRTPHeader rtp_header_;
-  int payload_size_bytes_;
-  int multi_payload_size_bytes_;
+  size_t payload_size_bytes_;
+  size_t multi_payload_size_bytes_;
   int last_send_time_;
   int last_arrival_time_;
   rtc::scoped_ptr<test::InputAudioFile> input_file_;
 };
 
 class NetEqStereoTestNoJitter : public NetEqStereoTest {
  protected:
   NetEqStereoTestNoJitter()
       : NetEqStereoTest() {
     // Start the sender 100 ms before the receiver to pre-fill the buffer.
@@ skipping 141 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(MultiChannel,
                         NetEqStereoTestDelays,
                         ::testing::ValuesIn(GetTestParameters()));
 
 INSTANTIATE_TEST_CASE_P(MultiChannel,
                         NetEqStereoTestLosses,
                         ::testing::ValuesIn(GetTestParameters()));
 
 }  // namespace webrtc