Update audio code to use size_t more correctly,

webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.cc

 /*
  *  Copyright (c) 2014 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 200 matching lines @@
                                    enum NetEqDecoder decoder_type)
     : decoder_type_(decoder_type),
       channels_(FLAGS_channels),
       decoded_time_ms_(0),
       decodable_time_ms_(0),
       drift_factor_(FLAGS_drift_factor),
       packet_loss_rate_(FLAGS_packet_loss_rate),
       block_duration_ms_(block_duration_ms),
       in_sampling_khz_(in_sampling_khz),
       out_sampling_khz_(out_sampling_khz),
-      in_size_samples_(in_sampling_khz_ * block_duration_ms_),
-      out_size_samples_(out_sampling_khz_ * kOutputSizeMs),
+      in_size_samples_(
+          static_cast<size_t>(in_sampling_khz_ * block_duration_ms_)),
+      out_size_samples_(static_cast<size_t>(out_sampling_khz_ * kOutputSizeMs)),
       payload_size_bytes_(0),
       max_payload_bytes_(0),
       in_file_(new ResampleInputAudioFile(FLAGS_in_filename,
                                           FLAGS_input_sample_rate,
                                           in_sampling_khz * 1000)),
       rtp_generator_(
           new RtpGenerator(in_sampling_khz_, 0, 0, decodable_time_ms_)),
       total_payload_size_bytes_(0) {
   const std::string out_filename = FLAGS_out_filename;
   const std::string log_filename = out_filename + ".log";
@@ skipping 152 matching lines @@
     } else {
       Log() << "was lost.";
     }
   }
   Log() << std::endl;
   return packet_input_time_ms;
 }
 
 int NetEqQualityTest::DecodeBlock() {
   int channels;
-  int samples;
+  size_t samples;
   int ret = neteq_->GetAudio(out_size_samples_ * channels_, &out_data_[0],
                              &samples, &channels, NULL);
 
   if (ret != NetEq::kOK) {
     return -1;
   } else {
     assert(channels == channels_);
-    assert(samples == kOutputSizeMs * out_sampling_khz_);
+    assert(samples == static_cast<size_t>(kOutputSizeMs * out_sampling_khz_));
     CHECK(output_->WriteArray(out_data_.get(), samples * channels));
-    return samples;
+    return static_cast<int>(samples);
   }
 }
 
 void NetEqQualityTest::Simulate() {
   int audio_size_samples;
 
   while (decoded_time_ms_ < FLAGS_runtime_ms) {
     // Assume 10 packets in packets buffer.
     while (decodable_time_ms_ - 10 * block_duration_ms_ < decoded_time_ms_) {
       ASSERT_TRUE(in_file_->Read(in_size_samples_ * channels_, &in_data_[0]));
       payload_size_bytes_ = EncodeBlock(&in_data_[0],
                                         in_size_samples_, &payload_[0],
                                         max_payload_bytes_);
       total_payload_size_bytes_ += payload_size_bytes_;
       decodable_time_ms_ = Transmit() + block_duration_ms_;
     }
     audio_size_samples = DecodeBlock();
     if (audio_size_samples > 0) {
       decoded_time_ms_ += audio_size_samples / out_sampling_khz_;
     }
   }
   Log() << "Average bit rate was "
         << 8.0f * total_payload_size_bytes_ / FLAGS_runtime_ms
         << " kbps"
         << std::endl;
 }
 
 }  // namespace test
 }  // namespace webrtc