Update audio code to use size_t more correctly,

webrtc/modules/audio_coding/neteq/neteq_unittest.cc

 /*
  *  Copyright (c) 2011 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 19 matching lines @@
 #include "webrtc/modules/audio_coding/neteq/tools/rtp_file_source.h"
 #include "webrtc/modules/audio_coding/codecs/pcm16b/include/pcm16b.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/gtest_disable.h"
 #include "webrtc/typedefs.h"
 
 DEFINE_bool(gen_ref, false, "Generate reference files.");
 
 namespace webrtc {
 
-static bool IsAllZero(const int16_t* buf, int buf_length) {
+static bool IsAllZero(const int16_t* buf, size_t buf_length) {
   bool all_zero = true;
-  for (int n = 0; n < buf_length && all_zero; ++n)
+  for (size_t n = 0; n < buf_length && all_zero; ++n)
     all_zero = buf[n] == 0;
   return all_zero;
 }
 
-static bool IsAllNonZero(const int16_t* buf, int buf_length) {
+static bool IsAllNonZero(const int16_t* buf, size_t buf_length) {
   bool all_non_zero = true;
-  for (int n = 0; n < buf_length && all_non_zero; ++n)
+  for (size_t n = 0; n < buf_length && all_non_zero; ++n)
     all_non_zero = buf[n] != 0;
   return all_non_zero;
 }
 
 class RefFiles {
  public:
   RefFiles(const std::string& input_file, const std::string& output_file);
   ~RefFiles();
   template<class T> void ProcessReference(const T& test_results);
   template<typename T, size_t n> void ProcessReference(
@@ skipping 105 matching lines @@
     ASSERT_EQ(stats.current_buffer_size_ms, ref_stats.current_buffer_size_ms);
     ASSERT_EQ(stats.preferred_buffer_size_ms,
               ref_stats.preferred_buffer_size_ms);
     ASSERT_EQ(stats.jitter_peaks_found, ref_stats.jitter_peaks_found);
     ASSERT_EQ(stats.packet_loss_rate, ref_stats.packet_loss_rate);
     ASSERT_EQ(stats.packet_discard_rate, ref_stats.packet_discard_rate);
     ASSERT_EQ(stats.expand_rate, ref_stats.expand_rate);
     ASSERT_EQ(stats.preemptive_rate, ref_stats.preemptive_rate);
     ASSERT_EQ(stats.accelerate_rate, ref_stats.accelerate_rate);
     ASSERT_EQ(stats.clockdrift_ppm, ref_stats.clockdrift_ppm);
-    ASSERT_EQ(stats.added_zero_samples, ref_stats.added_zero_samples);
+    ASSERT_EQ(stats.added_zero_samples,
+              static_cast<size_t>(ref_stats.added_zero_samples));
     ASSERT_EQ(stats.secondary_decoded_rate, 0);
     ASSERT_LE(stats.speech_expand_rate, ref_stats.expand_rate);
   }
 }
 
 void RefFiles::WriteToFile(const RtcpStatistics& stats) {
   if (output_fp_) {
     ASSERT_EQ(1u, fwrite(&(stats.fraction_lost), sizeof(stats.fraction_lost), 1,
                          output_fp_));
     ASSERT_EQ(1u, fwrite(&(stats.cumulative_lost),
@@ skipping 27 matching lines @@
               stats.extended_max_sequence_number);
     ASSERT_EQ(ref_stats.jitter, stats.jitter);
   }
 }
 
 class NetEqDecodingTest : public ::testing::Test {
  protected:
   // NetEQ must be polled for data once every 10 ms. Thus, neither of the
   // constants below can be changed.
   static const int kTimeStepMs = 10;
-  static const int kBlockSize8kHz = kTimeStepMs * 8;
-  static const int kBlockSize16kHz = kTimeStepMs * 16;
-  static const int kBlockSize32kHz = kTimeStepMs * 32;
+  static const size_t kBlockSize8kHz = kTimeStepMs * 8;
+  static const size_t kBlockSize16kHz = kTimeStepMs * 16;
+  static const size_t kBlockSize32kHz = kTimeStepMs * 32;
   static const size_t kMaxBlockSize = kBlockSize32kHz;
   static const int kInitSampleRateHz = 8000;
 
   NetEqDecodingTest();
   virtual void SetUp();
   virtual void TearDown();
   void SelectDecoders(NetEqDecoder* used_codec);
   void LoadDecoders();
   void OpenInputFile(const std::string &rtp_file);
-  void Process(int* out_len);
+  void Process(size_t* out_len);
   void DecodeAndCompare(const std::string& rtp_file,
                         const std::string& ref_file,
                         const std::string& stat_ref_file,
                         const std::string& rtcp_ref_file);
   static void PopulateRtpInfo(int frame_index,
                               int timestamp,
                               WebRtcRTPHeader* rtp_info);
   static void PopulateCng(int frame_index,
                           int timestamp,
                           WebRtcRTPHeader* rtp_info,
@@ skipping 19 matching lines @@
   rtc::scoped_ptr<test::RtpFileSource> rtp_source_;
   rtc::scoped_ptr<test::Packet> packet_;
   unsigned int sim_clock_;
   int16_t out_data_[kMaxBlockSize];
   int output_sample_rate_;
   int algorithmic_delay_ms_;
 };
 
 // Allocating the static const so that it can be passed by reference.
 const int NetEqDecodingTest::kTimeStepMs;
-const int NetEqDecodingTest::kBlockSize8kHz;
-const int NetEqDecodingTest::kBlockSize16kHz;
-const int NetEqDecodingTest::kBlockSize32kHz;
+const size_t NetEqDecodingTest::kBlockSize8kHz;
+const size_t NetEqDecodingTest::kBlockSize16kHz;
+const size_t NetEqDecodingTest::kBlockSize32kHz;
 const size_t NetEqDecodingTest::kMaxBlockSize;
 const int NetEqDecodingTest::kInitSampleRateHz;
 
 NetEqDecodingTest::NetEqDecodingTest()
     : neteq_(NULL),
       config_(),
       sim_clock_(0),
       output_sample_rate_(kInitSampleRateHz),
       algorithmic_delay_ms_(0) {
   config_.sample_rate_hz = kInitSampleRateHz;
@@ skipping 39 matching lines @@
   // Load CNG 8 kHz.
   ASSERT_EQ(0, neteq_->RegisterPayloadType(kDecoderCNGnb, 13));
   // Load CNG 16 kHz.
   ASSERT_EQ(0, neteq_->RegisterPayloadType(kDecoderCNGwb, 98));
 }
 
 void NetEqDecodingTest::OpenInputFile(const std::string &rtp_file) {
   rtp_source_.reset(test::RtpFileSource::Create(rtp_file));
 }
 
-void NetEqDecodingTest::Process(int* out_len) {
+void NetEqDecodingTest::Process(size_t* out_len) {
   // Check if time to receive.
   while (packet_ && sim_clock_ >= packet_->time_ms()) {
     if (packet_->payload_length_bytes() > 0) {
       WebRtcRTPHeader rtp_header;
       packet_->ConvertHeader(&rtp_header);
       ASSERT_EQ(0, neteq_->InsertPacket(
                        rtp_header, packet_->payload(),
                        packet_->payload_length_bytes(),
                        static_cast<uint32_t>(
                            packet_->time_ms() * (output_sample_rate_ / 1000))));
     }
     // Get next packet.
     packet_.reset(rtp_source_->NextPacket());
   }
 
   // Get audio from NetEq.
   NetEqOutputType type;
   int num_channels;
   ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, out_len,
                                 &num_channels, &type));
   ASSERT_TRUE((*out_len == kBlockSize8kHz) ||
               (*out_len == kBlockSize16kHz) ||
               (*out_len == kBlockSize32kHz));
-  output_sample_rate_ = *out_len / 10 * 1000;
+  output_sample_rate_ = static_cast<int>(*out_len / 10 * 1000);

[hlundin-webrtc, 2015/08/10 11:30:01]

rtc::checked_cast

[Peter Kasting, 2015/08/17 22:49:47]

This shouldn't be necessary, as the ASSERT_TRUE just above guarantees that the
value of this expression is at most 32000.

[hlundin-webrtc, 2015/08/18 07:19:18]

Acknowledged.

 
   // Increase time.
   sim_clock_ += kTimeStepMs;
 }
 
 void NetEqDecodingTest::DecodeAndCompare(const std::string& rtp_file,
                                          const std::string& ref_file,
                                          const std::string& stat_ref_file,
                                          const std::string& rtcp_ref_file) {
   OpenInputFile(rtp_file);
@@ skipping 15 matching lines @@
     rtcp_out_file = webrtc::test::OutputPath() + "neteq_rtcp_stats.dat";
   }
   RefFiles rtcp_stat_files(rtcp_ref_file, rtcp_out_file);
 
   packet_.reset(rtp_source_->NextPacket());
   int i = 0;
   while (packet_) {
     std::ostringstream ss;
     ss << "Lap number " << i++ << " in DecodeAndCompare while loop";
     SCOPED_TRACE(ss.str());  // Print out the parameter values on failure.
-    int out_len = 0;
+    size_t out_len = 0;
     ASSERT_NO_FATAL_FAILURE(Process(&out_len));
     ASSERT_NO_FATAL_FAILURE(ref_files.ProcessReference(out_data_, out_len));
 
     // Query the network statistics API once per second
     if (sim_clock_ % 1000 == 0) {
       // Process NetworkStatistics.
       NetEqNetworkStatistics network_stats;
       ASSERT_EQ(0, neteq_->NetworkStatistics(&network_stats));
       ASSERT_NO_FATAL_FAILURE(
           network_stat_files.ProcessReference(network_stats));
@@ skipping 83 matching lines @@
     rtp_info.header.ssrc = 0x1234;  // Just an arbitrary SSRC.
     rtp_info.header.payloadType = 94;  // PCM16b WB codec.
     rtp_info.header.markerBit = 0;
     ASSERT_EQ(0, neteq_->InsertPacket(
         rtp_info,
         reinterpret_cast<uint8_t*>(payload),
         kPayloadBytes, 0));
   }
   // Pull out all data.
   for (size_t i = 0; i < num_frames; ++i) {
-    int out_len;
+    size_t out_len;
     int num_channels;
     NetEqOutputType type;
     ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                   &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
   }
 
   std::vector<int> waiting_times;
   neteq_->WaitingTimes(&waiting_times);
   EXPECT_EQ(num_frames, waiting_times.size());
@@ skipping 17 matching lines @@
     WebRtcRTPHeader rtp_info;
     rtp_info.header.sequenceNumber = i;
     rtp_info.header.timestamp = i * kSamples;
     rtp_info.header.ssrc = 0x1235;  // Just an arbitrary SSRC.
     rtp_info.header.payloadType = 94;  // PCM16b WB codec.
     rtp_info.header.markerBit = 0;
     ASSERT_EQ(0, neteq_->InsertPacket(
         rtp_info,
         reinterpret_cast<uint8_t*>(payload),
         kPayloadBytes, 0));
-    int out_len;
+    size_t out_len;
     int num_channels;
     NetEqOutputType type;
     ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                   &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
   }
 
   neteq_->WaitingTimes(&waiting_times);
   EXPECT_EQ(100u, waiting_times.size());
 }
 
 TEST_F(NetEqDecodingTest, TestAverageInterArrivalTimeNegative) {
   const int kNumFrames = 3000;  // Needed for convergence.
   int frame_index = 0;
   const size_t kSamples = 10 * 16;
   const size_t kPayloadBytes = kSamples * 2;
   while (frame_index < kNumFrames) {
     // Insert one packet each time, except every 10th time where we insert two
     // packets at once. This will create a negative clock-drift of approx. 10%.
     int num_packets = (frame_index % 10 == 0 ? 2 : 1);
     for (int n = 0; n < num_packets; ++n) {
       uint8_t payload[kPayloadBytes] = {0};
       WebRtcRTPHeader rtp_info;
       PopulateRtpInfo(frame_index, frame_index * kSamples, &rtp_info);
       ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes, 0));
       ++frame_index;
     }
 
     // Pull out data once.
-    int out_len;
+    size_t out_len;
     int num_channels;
     NetEqOutputType type;
     ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                   &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
   }
 
   NetEqNetworkStatistics network_stats;
   ASSERT_EQ(0, neteq_->NetworkStatistics(&network_stats));
   EXPECT_EQ(-103196, network_stats.clockdrift_ppm);
@@ skipping 10 matching lines @@
     int num_packets = (i % 10 == 9 ? 0 : 1);
     for (int n = 0; n < num_packets; ++n) {
       uint8_t payload[kPayloadBytes] = {0};
       WebRtcRTPHeader rtp_info;
       PopulateRtpInfo(frame_index, frame_index * kSamples, &rtp_info);
       ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes, 0));
       ++frame_index;
     }
 
     // Pull out data once.
-    int out_len;
+    size_t out_len;
     int num_channels;
     NetEqOutputType type;
     ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                   &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
   }
 
   NetEqNetworkStatistics network_stats;
   ASSERT_EQ(0, neteq_->NetworkStatistics(&network_stats));
   EXPECT_EQ(110946, network_stats.clockdrift_ppm);
 }
 
 void NetEqDecodingTest::LongCngWithClockDrift(double drift_factor,
                                               double network_freeze_ms,
                                               bool pull_audio_during_freeze,
                                               int delay_tolerance_ms,
                                               int max_time_to_speech_ms) {
   uint16_t seq_no = 0;
   uint32_t timestamp = 0;
   const int kFrameSizeMs = 30;
   const size_t kSamples = kFrameSizeMs * 16;
   const size_t kPayloadBytes = kSamples * 2;
   double next_input_time_ms = 0.0;
   double t_ms;
-  int out_len;
+  size_t out_len;
   int num_channels;
   NetEqOutputType type;
 
   // Insert speech for 5 seconds.
   const int kSpeechDurationMs = 5000;
   for (t_ms = 0; t_ms < kSpeechDurationMs; t_ms += 10) {
     // Each turn in this for loop is 10 ms.
     while (next_input_time_ms <= t_ms) {
       // Insert one 30 ms speech frame.
       uint8_t payload[kPayloadBytes] = {0};
@@ skipping 211 matching lines @@
   PopulateRtpInfo(0, 0, &rtp_info);
   rtp_info.header.payloadType = 103;  // iSAC, but the payload is invalid.
   EXPECT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes, 0));
   NetEqOutputType type;
   // Set all of |out_data_| to 1, and verify that it was set to 0 by the call
   // to GetAudio.
   for (size_t i = 0; i < kMaxBlockSize; ++i) {
     out_data_[i] = 1;
   }
   int num_channels;
-  int samples_per_channel;
+  size_t samples_per_channel;
   EXPECT_EQ(NetEq::kFail,
             neteq_->GetAudio(kMaxBlockSize, out_data_,
                              &samples_per_channel, &num_channels, &type));
   // Verify that there is a decoder error to check.
   EXPECT_EQ(NetEq::kDecoderErrorCode, neteq_->LastError());
   // Code 6730 is an iSAC error code.
   EXPECT_EQ(6730, neteq_->LastDecoderError());
   // Verify that the first 160 samples are set to 0, and that the remaining
   // samples are left unmodified.
   static const int kExpectedOutputLength = 160;  // 10 ms at 16 kHz sample rate.
@@ skipping 12 matching lines @@
 }
 
 TEST_F(NetEqDecodingTest, GetAudioBeforeInsertPacket) {
   NetEqOutputType type;
   // Set all of |out_data_| to 1, and verify that it was set to 0 by the call
   // to GetAudio.
   for (size_t i = 0; i < kMaxBlockSize; ++i) {
     out_data_[i] = 1;
   }
   int num_channels;
-  int samples_per_channel;
+  size_t samples_per_channel;
   EXPECT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_,
                                 &samples_per_channel,
                                 &num_channels, &type));
   // Verify that the first block of samples is set to 0.
   static const int kExpectedOutputLength =
       kInitSampleRateHz / 100;  // 10 ms at initial sample rate.
   for (int i = 0; i < kExpectedOutputLength; ++i) {
     std::ostringstream ss;
     ss << "i = " << i;
     SCOPED_TRACE(ss.str());  // Print out the parameter values on failure.
     EXPECT_EQ(0, out_data_[i]);
   }
 }
 
 class NetEqBgnTest : public NetEqDecodingTest {
  protected:
   virtual void TestCondition(double sum_squared_noise,
                              bool should_be_faded) = 0;
 
   void CheckBgn(int sampling_rate_hz) {
-    int16_t expected_samples_per_channel = 0;
+    size_t expected_samples_per_channel = 0;
     uint8_t payload_type = 0xFF;  // Invalid.
     if (sampling_rate_hz == 8000) {
       expected_samples_per_channel = kBlockSize8kHz;
       payload_type = 93;  // PCM 16, 8 kHz.
     } else if (sampling_rate_hz == 16000) {
       expected_samples_per_channel = kBlockSize16kHz;
       payload_type = 94;  // PCM 16, 16 kHZ.
     } else if (sampling_rate_hz == 32000) {
       expected_samples_per_channel = kBlockSize32kHz;
       payload_type = 95;  // PCM 16, 32 kHz.
     } else {
       ASSERT_TRUE(false);  // Unsupported test case.
     }
 
     NetEqOutputType type;
     int16_t output[kBlockSize32kHz];  // Maximum size is chosen.
     test::AudioLoop input;
     // We are using the same 32 kHz input file for all tests, regardless of
     // |sampling_rate_hz|. The output may sound weird, but the test is still
     // valid.
     ASSERT_TRUE(input.Init(
         webrtc::test::ResourcePath("audio_coding/testfile32kHz", "pcm"),
         10 * sampling_rate_hz,  // Max 10 seconds loop length.
-        static_cast<size_t>(expected_samples_per_channel)));
+        expected_samples_per_channel));
 
     // Payload of 10 ms of PCM16 32 kHz.
     uint8_t payload[kBlockSize32kHz * sizeof(int16_t)];
     WebRtcRTPHeader rtp_info;
     PopulateRtpInfo(0, 0, &rtp_info);
     rtp_info.header.payloadType = payload_type;
 
     int number_channels = 0;
-    int samples_per_channel = 0;
+    size_t samples_per_channel = 0;
 
     uint32_t receive_timestamp = 0;
     for (int n = 0; n < 10; ++n) {  // Insert few packets and get audio.
-      int16_t enc_len_bytes = WebRtcPcm16b_Encode(
+      size_t enc_len_bytes = WebRtcPcm16b_Encode(
           input.GetNextBlock(), expected_samples_per_channel, payload);
       ASSERT_EQ(enc_len_bytes, expected_samples_per_channel * 2);
 
       number_channels = 0;
       samples_per_channel = 0;
       ASSERT_EQ(0,
-                neteq_->InsertPacket(rtp_info, payload,
-                                     static_cast<size_t>(enc_len_bytes),
+                neteq_->InsertPacket(rtp_info, payload, enc_len_bytes,
                                      receive_timestamp));
       ASSERT_EQ(0,
                 neteq_->GetAudio(kBlockSize32kHz,
                                  output,
                                  &samples_per_channel,
                                  &number_channels,
                                  &type));
       ASSERT_EQ(1, number_channels);
       ASSERT_EQ(expected_samples_per_channel, samples_per_channel);
       ASSERT_EQ(kOutputNormal, type);
@@ skipping 35 matching lines @@
                 neteq_->GetAudio(kBlockSize32kHz,
                                  output,
                                  &samples_per_channel,
                                  &number_channels,
                                  &type));
       ASSERT_EQ(1, number_channels);
       ASSERT_EQ(expected_samples_per_channel, samples_per_channel);
       if (type == kOutputPLCtoCNG) {
         plc_to_cng = true;
         double sum_squared = 0;
-        for (int k = 0; k < number_channels * samples_per_channel; ++k)
+        for (size_t k = 0; k < number_channels * samples_per_channel; ++k)
           sum_squared += output[k] * output[k];
         TestCondition(sum_squared, n > kFadingThreshold);
       } else {
         EXPECT_EQ(kOutputPLC, type);
       }
     }
     EXPECT_TRUE(plc_to_cng);  // Just to be sure that PLC-to-CNG has occurred.
   }
 };
 
@@ skipping 138 matching lines @@
   uint8_t payload[kPayloadBytes];
   int16_t decoded[kBlockSize16kHz];
   int algorithmic_frame_delay = algorithmic_delay_ms_ / 10 + 1;
   for (size_t n = 0; n < kPayloadBytes; ++n) {
     payload[n] = (rand() & 0xF0) + 1;  // Non-zero random sequence.
   }
   // Insert some packets which decode to noise. We are not interested in
   // actual decoded values.
   NetEqOutputType output_type;
   int num_channels;
-  int samples_per_channel;
+  size_t samples_per_channel;
   uint32_t receive_timestamp = 0;
   for (int n = 0; n < 100; ++n) {
     ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes,
                                       receive_timestamp));
     ASSERT_EQ(0, neteq_->GetAudio(kBlockSize16kHz, decoded,
                                   &samples_per_channel, &num_channels,
                                   &output_type));
     ASSERT_EQ(kBlockSize16kHz, samples_per_channel);
     ASSERT_EQ(1, num_channels);
 
@@ skipping 57 matching lines @@
   const size_t kPayloadBytes = kBlockSize16kHz * sizeof(int16_t);
   uint8_t payload[kPayloadBytes];
   int16_t decoded[kBlockSize16kHz];
   for (size_t n = 0; n < kPayloadBytes; ++n) {
     payload[n] = (rand() & 0xF0) + 1;  // Non-zero random sequence.
   }
   // Insert some packets which decode to noise. We are not interested in
   // actual decoded values.
   NetEqOutputType output_type;
   int num_channels;
-  int samples_per_channel;
+  size_t samples_per_channel;
   uint32_t receive_timestamp = 0;
   int algorithmic_frame_delay = algorithmic_delay_ms_ / 10 + 1;
   for (int n = 0; n < algorithmic_frame_delay; ++n) {
     ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes,
                                       receive_timestamp));
     ASSERT_EQ(0, neteq_->GetAudio(kBlockSize16kHz, decoded,
                                   &samples_per_channel, &num_channels,
                                   &output_type));
     ASSERT_EQ(kBlockSize16kHz, samples_per_channel);
     ASSERT_EQ(1, num_channels);
@@ skipping 48 matching lines @@
                                  bool expect_timestamp_wrap) {
   uint16_t seq_no = start_seq_no;
   uint32_t timestamp = start_timestamp;
   const int kBlocksPerFrame = 3;  // Number of 10 ms blocks per frame.
   const int kFrameSizeMs = kBlocksPerFrame * kTimeStepMs;
   const int kSamples = kBlockSize16kHz * kBlocksPerFrame;
   const size_t kPayloadBytes = kSamples * sizeof(int16_t);
   double next_input_time_ms = 0.0;
   int16_t decoded[kBlockSize16kHz];
   int num_channels;
-  int samples_per_channel;
+  size_t samples_per_channel;
   NetEqOutputType output_type;
   uint32_t receive_timestamp = 0;
 
   // Insert speech for 2 seconds.
   const int kSpeechDurationMs = 2000;
   int packets_inserted = 0;
   uint16_t last_seq_no;
   uint32_t last_timestamp;
   bool timestamp_wrapped = false;
   bool seq_no_wrapped = false;
@@ skipping 82 matching lines @@
   uint32_t timestamp = 0;
   const int kFrameSizeMs = 10;
   const int kSampleRateKhz = 16;
   const int kSamples = kFrameSizeMs * kSampleRateKhz;
   const size_t kPayloadBytes = kSamples * 2;
 
   const int algorithmic_delay_samples = std::max(
       algorithmic_delay_ms_ * kSampleRateKhz, 5 * kSampleRateKhz / 8);
   // Insert three speech packets. Three are needed to get the frame length
   // correct.
-  int out_len;
+  size_t out_len;
   int num_channels;
   NetEqOutputType type;
   uint8_t payload[kPayloadBytes] = {0};
   WebRtcRTPHeader rtp_info;
   for (int i = 0; i < 3; ++i) {
     PopulateRtpInfo(seq_no, timestamp, &rtp_info);
     ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes, 0));
     ++seq_no;
     timestamp += kSamples;
 
@@ skipping 76 matching lines @@
   uint8_t payload[kPayloadBytes] = {0};
   WebRtcRTPHeader rtp_info;
 
   PopulateCng(seq_no, timestamp, &rtp_info, payload, &payload_len);
   ASSERT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_info, payload, payload_len, 0));
   ++seq_no;
   timestamp += kCngPeriodSamples;
 
   // Pull audio once and make sure CNG is played.
-  int out_len;
+  size_t out_len;
   int num_channels;
   NetEqOutputType type;
   ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                 &num_channels, &type));
   ASSERT_EQ(kBlockSize16kHz, out_len);
   EXPECT_EQ(kOutputCNG, type);
 
   // Insert some speech packets.
   for (int i = 0; i < 3; ++i) {
     PopulateRtpInfo(seq_no, timestamp, &rtp_info);
     ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, kPayloadBytes, 0));
     ++seq_no;
     timestamp += kSamples;
 
     // Pull audio once.
     ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                   &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
   }
   // Verify speech output.
   EXPECT_EQ(kOutputNormal, type);
 }
 
 }  // namespace webrtc