Update audio code to use size_t more correctly,

webrtc/modules/audio_coding/neteq/test/neteq_opus_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 85 matching lines @@
 static const bool sub_packets_dummy =
     RegisterFlagValidator(&FLAGS_sub_packets, &ValidateSubPackets);
 
 }  // namepsace
 
 class NetEqOpusQualityTest : public NetEqQualityTest {
  protected:
   NetEqOpusQualityTest();
   void SetUp() override;
   void TearDown() override;
-  virtual int EncodeBlock(int16_t* in_data, int block_size_samples,
-                          uint8_t* payload, int max_bytes);
+  virtual int EncodeBlock(int16_t* in_data, size_t block_size_samples,
+                          uint8_t* payload, size_t max_bytes);
  private:
   WebRtcOpusEncInst* opus_encoder_;
   OpusRepacketizer* repacketizer_;
-  int sub_block_size_samples_;
+  size_t sub_block_size_samples_;
   int bit_rate_kbps_;
   bool fec_;
   bool dtx_;
   int complexity_;
   int maxplaybackrate_;
   int target_loss_rate_;
   int sub_packets_;
   int application_;
 };
 
 NetEqOpusQualityTest::NetEqOpusQualityTest()
     : NetEqQualityTest(kOpusBlockDurationMs * FLAGS_sub_packets,
                        kOpusSamplingKhz,
                        kOpusSamplingKhz,
                        kDecoderOpus),
       opus_encoder_(NULL),
       repacketizer_(NULL),
-      sub_block_size_samples_(kOpusBlockDurationMs * kOpusSamplingKhz),
+      sub_block_size_samples_(
+          static_cast<size_t>(kOpusBlockDurationMs * kOpusSamplingKhz)),
       bit_rate_kbps_(FLAGS_bit_rate_kbps),
       fec_(FLAGS_fec),
       dtx_(FLAGS_dtx),
       complexity_(FLAGS_complexity),
       maxplaybackrate_(FLAGS_maxplaybackrate),
       target_loss_rate_(FLAGS_reported_loss_rate),
       sub_packets_(FLAGS_sub_packets) {
   // Redefine decoder type if input is stereo.
   if (channels_ > 1) {
     decoder_type_ = kDecoderOpus_2ch;
@@ skipping 26 matching lines @@
 }
 
 void NetEqOpusQualityTest::TearDown() {
   // Free memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   opus_repacketizer_destroy(repacketizer_);
   NetEqQualityTest::TearDown();
 }
 
 int NetEqOpusQualityTest::EncodeBlock(int16_t* in_data,
-                                      int block_size_samples,
-                                      uint8_t* payload, int max_bytes) {
+                                      size_t block_size_samples,
+                                      uint8_t* payload, size_t max_bytes) {
   EXPECT_EQ(block_size_samples, sub_block_size_samples_ * sub_packets_);
   int16_t* pointer = in_data;
   int value;
   opus_repacketizer_init(repacketizer_);
   for (int idx = 0; idx < sub_packets_; idx++) {
     value = WebRtcOpus_Encode(opus_encoder_, pointer, sub_block_size_samples_,
                               max_bytes, payload);
     Log() << "Encoded a frame with Opus mode "
           << (value == 0 ? 0 : payload[0] >> 3)
           << std::endl;
     if (OPUS_OK != opus_repacketizer_cat(repacketizer_, payload, value)) {
       opus_repacketizer_init(repacketizer_);
       // If the repacketization fails, we discard this frame.
       return 0;
     }
     pointer += sub_block_size_samples_ * channels_;
   }
-  value = opus_repacketizer_out(repacketizer_, payload, max_bytes);
+  value = opus_repacketizer_out(repacketizer_, payload,
+                                static_cast<opus_int32>(max_bytes));
   EXPECT_GE(value, 0);
   return value;
 }
 
 TEST_F(NetEqOpusQualityTest, Test) {
   Simulate();
 }
 
 }  // namespace test
 }  // namespace webrtc