Misc. small cleanups

webrtc/modules/audio_coding/test/opus_test.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 188 matching lines @@
 
   // Close the files.
   in_file_stereo_.Close();
   in_file_mono_.Close();
   out_file_.Close();
   out_file_standalone_.Close();
 #endif
 }
 
 void OpusTest::Run(TestPackStereo* channel, int channels, int bitrate,
-                   int frame_length, int percent_loss) {
+                   size_t frame_length, int percent_loss) {
   AudioFrame audio_frame;
   int32_t out_freq_hz_b = out_file_.SamplingFrequency();
-  const int kBufferSizeSamples = 480 * 12 * 2;  // Can hold 120 ms stereo audio.
+  const size_t kBufferSizeSamples = 480 * 12 * 2;  // 120 ms stereo audio.
   int16_t audio[kBufferSizeSamples];
   int16_t out_audio[kBufferSizeSamples];
   int16_t audio_type;
-  int written_samples = 0;
-  int read_samples = 0;
-  int decoded_samples = 0;
+  size_t written_samples = 0;
+  size_t read_samples = 0;
+  size_t decoded_samples = 0;
   bool first_packet = true;
   uint32_t start_time_stamp = 0;
 
   channel->reset_payload_size();
   counter_ = 0;
 
   // Set encoder rate.
   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, bitrate));
   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, bitrate));
 
@@ skipping 32 matching lines @@
               resampler_.Resample10Msec(audio_frame.data_,
                                         audio_frame.sample_rate_hz_,
                                         48000,
                                         channels,
                                         kBufferSizeSamples - written_samples,
                                         &audio[written_samples]));
     written_samples += 480 * channels;
 
     // Sometimes we need to loop over the audio vector to produce the right
     // number of packets.
-    int loop_encode = (written_samples - read_samples) /
+    size_t loop_encode = (written_samples - read_samples) /
         (channels * frame_length);
 
     if (loop_encode > 0) {
-      const int kMaxBytes = 1000;  // Maximum number of bytes for one packet.
+      const size_t kMaxBytes = 1000;  // Maximum number of bytes for one packet.
       size_t bitstream_len_byte;
       uint8_t bitstream[kMaxBytes];
-      for (int i = 0; i < loop_encode; i++) {
+      for (size_t i = 0; i < loop_encode; i++) {
         int bitstream_len_byte_int = WebRtcOpus_Encode(
             (channels == 1) ? opus_mono_encoder_ : opus_stereo_encoder_,
             &audio[read_samples], frame_length, kMaxBytes, bitstream);
         ASSERT_GE(bitstream_len_byte_int, 0);
         bitstream_len_byte = static_cast<size_t>(bitstream_len_byte_int);
 
         // Simulate packet loss by setting |packet_loss_| to "true" in
         // |percent_loss| percent of the loops.
         // TODO(tlegrand): Move handling of loss simulation to TestPackStereo.
         if (percent_loss > 0) {
@@ skipping 30 matching lines @@
           }
         }
 
         // Send data to the channel. "channel" will handle the loss simulation.
         channel->SendData(kAudioFrameSpeech, payload_type_, rtp_timestamp_,
                           bitstream, bitstream_len_byte, NULL);
         if (first_packet) {
           first_packet = false;
           start_time_stamp = rtp_timestamp_;
         }
-        rtp_timestamp_ += frame_length;
+        rtp_timestamp_ += static_cast<uint32_t>(frame_length);
         read_samples += frame_length * channels;
       }
       if (read_samples == written_samples) {
         read_samples = 0;
         written_samples = 0;
       }
     }
 
     // Run received side of ACM.
     ASSERT_EQ(0, acm_receiver_->PlayoutData10Ms(out_freq_hz_b, &audio_frame));
 
     // Write output speech to file.
     out_file_.Write10MsData(
         audio_frame.data_,
         audio_frame.samples_per_channel_ * audio_frame.num_channels_);
 
     // Write stand-alone speech to file.
-    out_file_standalone_.Write10MsData(
-        out_audio, static_cast<size_t>(decoded_samples) * channels);
+    out_file_standalone_.Write10MsData(out_audio, decoded_samples * channels);
 
     if (audio_frame.timestamp_ > start_time_stamp) {
       // Number of channels should be the same for both stand-alone and
       // ACM-decoding.
       EXPECT_EQ(audio_frame.num_channels_, channels);
     }
 
     decoded_samples = 0;
   }
 
@@ skipping 16 matching lines @@
   out_file_.Open(file_name, 48000, "wb");
   file_stream.str("");
   file_name = file_stream.str();
   file_stream << webrtc::test::OutputPath() << "opusstandalone_out_"
       << test_number << ".pcm";
   file_name = file_stream.str();
   out_file_standalone_.Open(file_name, 48000, "wb");
 }
 
 }  // namespace webrtc