Update audio code to use size_t more correctly,

webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc

 /*
  *  Copyright (c) 2012 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 366 matching lines @@
   WebRtcRTPHeader rtp_header;
   rtp_header.header.payloadType = kPayloadType;
   rtp_header.header.sequenceNumber = 0x1234;
   rtp_header.header.timestamp = 0x12345678;
   rtp_header.header.ssrc = 0x87654321;
 
   EXPECT_EQ(NetEq::kOK,
             neteq_->RegisterPayloadType(kDecoderPCM16B, kPayloadType));
 
   // Insert packets. The buffer should not flush.
-  for (int i = 1; i <= config_.max_packets_in_buffer; ++i) {
+  for (size_t i = 1; i <= config_.max_packets_in_buffer; ++i) {
     EXPECT_EQ(NetEq::kOK,
               neteq_->InsertPacket(
                   rtp_header, payload, kPayloadLengthBytes, kReceiveTime));
     rtp_header.header.timestamp += kPayloadLengthSamples;
     rtp_header.header.sequenceNumber += 1;
     EXPECT_EQ(i, packet_buffer_->NumPacketsInBuffer());
   }
 
   // Insert one more packet and make sure the buffer got flushed. That is, it
   // should only hold one single packet.
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(
                 rtp_header, payload, kPayloadLengthBytes, kReceiveTime));
-  EXPECT_EQ(1, packet_buffer_->NumPacketsInBuffer());
+  EXPECT_EQ(1u, packet_buffer_->NumPacketsInBuffer());
   const RTPHeader* test_header = packet_buffer_->NextRtpHeader();
   EXPECT_EQ(rtp_header.header.timestamp, test_header->timestamp);
   EXPECT_EQ(rtp_header.header.sequenceNumber, test_header->sequenceNumber);
 }
 
 // This test verifies that timestamps propagate from the incoming packets
 // through to the sync buffer and to the playout timestamp.
 TEST_F(NetEqImplTest, VerifyTimestampPropagation) {
   UseNoMocks();
   CreateInstance();
 
   const uint8_t kPayloadType = 17;   // Just an arbitrary number.
   const uint32_t kReceiveTime = 17;  // Value doesn't matter for this test.
   const int kSampleRateHz = 8000;
-  const int kPayloadLengthSamples = 10 * kSampleRateHz / 1000;  // 10 ms.
+  const size_t kPayloadLengthSamples =
+      static_cast<size_t>(10 * kSampleRateHz / 1000);  // 10 ms.
   const size_t kPayloadLengthBytes = kPayloadLengthSamples;
   uint8_t payload[kPayloadLengthBytes] = {0};
   WebRtcRTPHeader rtp_header;
   rtp_header.header.payloadType = kPayloadType;
   rtp_header.header.sequenceNumber = 0x1234;
   rtp_header.header.timestamp = 0x12345678;
   rtp_header.header.ssrc = 0x87654321;
 
   // This is a dummy decoder that produces as many output samples as the input
   // has bytes. The output is an increasing series, starting at 1 for the first
@@ skipping 32 matching lines @@
   EXPECT_EQ(NetEq::kOK,
             neteq_->RegisterExternalDecoder(&decoder_, kDecoderPCM16B,
                                             kPayloadType, kSampleRateHz));
 
   // Insert one packet.
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(
                 rtp_header, payload, kPayloadLengthBytes, kReceiveTime));
 
   // Pull audio once.
-  const int kMaxOutputSize = 10 * kSampleRateHz / 1000;
+  const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   int16_t output[kMaxOutputSize];
-  int samples_per_channel;
+  size_t samples_per_channel;
   int num_channels;
   NetEqOutputType type;
   EXPECT_EQ(
       NetEq::kOK,
       neteq_->GetAudio(
           kMaxOutputSize, output, &samples_per_channel, &num_channels, &type));
   ASSERT_EQ(kMaxOutputSize, samples_per_channel);
   EXPECT_EQ(1, num_channels);
   EXPECT_EQ(kOutputNormal, type);
 
   // Start with a simple check that the fake decoder is behaving as expected.
-  EXPECT_EQ(kPayloadLengthSamples, decoder_.next_value() - 1);
+  EXPECT_EQ(kPayloadLengthSamples,
+            static_cast<size_t>(decoder_.next_value() - 1));
 
   // The value of the last of the output samples is the same as the number of
   // samples played from the decoded packet. Thus, this number + the RTP
   // timestamp should match the playout timestamp.
   uint32_t timestamp = 0;
   EXPECT_TRUE(neteq_->GetPlayoutTimestamp(&timestamp));
   EXPECT_EQ(rtp_header.header.timestamp + output[samples_per_channel - 1],
             timestamp);
 
   // Check the timestamp for the last value in the sync buffer. This should
   // be one full frame length ahead of the RTP timestamp.
   const SyncBuffer* sync_buffer = neteq_->sync_buffer_for_test();
   ASSERT_TRUE(sync_buffer != NULL);
   EXPECT_EQ(rtp_header.header.timestamp + kPayloadLengthSamples,
             sync_buffer->end_timestamp());
 
   // Check that the number of samples still to play from the sync buffer add
   // up with what was already played out.
   EXPECT_EQ(kPayloadLengthSamples - output[samples_per_channel - 1],
-            static_cast<int>(sync_buffer->FutureLength()));
+            sync_buffer->FutureLength());
 }
 
 TEST_F(NetEqImplTest, ReorderedPacket) {
   UseNoMocks();
   CreateInstance();
 
   const uint8_t kPayloadType = 17;   // Just an arbitrary number.
   const uint32_t kReceiveTime = 17;  // Value doesn't matter for this test.
   const int kSampleRateHz = 8000;
-  const int kPayloadLengthSamples = 10 * kSampleRateHz / 1000;  // 10 ms.
+  const size_t kPayloadLengthSamples =
+      static_cast<size_t>(10 * kSampleRateHz / 1000);  // 10 ms.
   const size_t kPayloadLengthBytes = kPayloadLengthSamples;
   uint8_t payload[kPayloadLengthBytes] = {0};
   WebRtcRTPHeader rtp_header;
   rtp_header.header.payloadType = kPayloadType;
   rtp_header.header.sequenceNumber = 0x1234;
   rtp_header.header.timestamp = 0x12345678;
   rtp_header.header.ssrc = 0x87654321;
 
   // Create a mock decoder object.
   MockAudioDecoder mock_decoder;
@@ skipping 13 matching lines @@
   EXPECT_EQ(NetEq::kOK,
             neteq_->RegisterExternalDecoder(&mock_decoder, kDecoderPCM16B,
                                             kPayloadType, kSampleRateHz));
 
   // Insert one packet.
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(
                 rtp_header, payload, kPayloadLengthBytes, kReceiveTime));
 
   // Pull audio once.
-  const int kMaxOutputSize = 10 * kSampleRateHz / 1000;
+  const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   int16_t output[kMaxOutputSize];
-  int samples_per_channel;
+  size_t samples_per_channel;
   int num_channels;
   NetEqOutputType type;
   EXPECT_EQ(
       NetEq::kOK,
       neteq_->GetAudio(
           kMaxOutputSize, output, &samples_per_channel, &num_channels, &type));
   ASSERT_EQ(kMaxOutputSize, samples_per_channel);
   EXPECT_EQ(1, num_channels);
   EXPECT_EQ(kOutputNormal, type);
 
@@ skipping 39 matching lines @@
 
 // This test verifies that NetEq can handle the situation where the first
 // incoming packet is rejected.
 TEST_F(NetEqImplTest, FirstPacketUnknown) {
   UseNoMocks();
   CreateInstance();
 
   const uint8_t kPayloadType = 17;   // Just an arbitrary number.
   const uint32_t kReceiveTime = 17;  // Value doesn't matter for this test.
   const int kSampleRateHz = 8000;
-  const int kPayloadLengthSamples = 10 * kSampleRateHz / 1000;  // 10 ms.
+  const size_t kPayloadLengthSamples =
+      static_cast<size_t>(10 * kSampleRateHz / 1000);  // 10 ms.
   const size_t kPayloadLengthBytes = kPayloadLengthSamples;
   uint8_t payload[kPayloadLengthBytes] = {0};
   WebRtcRTPHeader rtp_header;
   rtp_header.header.payloadType = kPayloadType;
   rtp_header.header.sequenceNumber = 0x1234;
   rtp_header.header.timestamp = 0x12345678;
   rtp_header.header.ssrc = 0x87654321;
 
   // Insert one packet. Note that we have not registered any payload type, so
   // this packet will be rejected.
   EXPECT_EQ(NetEq::kFail,
             neteq_->InsertPacket(rtp_header, payload, kPayloadLengthBytes,
                                  kReceiveTime));
   EXPECT_EQ(NetEq::kUnknownRtpPayloadType, neteq_->LastError());
 
   // Pull audio once.
-  const int kMaxOutputSize = 10 * kSampleRateHz / 1000;
+  const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   int16_t output[kMaxOutputSize];
-  int samples_per_channel;
+  size_t samples_per_channel;
   int num_channels;
   NetEqOutputType type;
   EXPECT_EQ(NetEq::kOK,
             neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
                              &num_channels, &type));
   ASSERT_LE(samples_per_channel, kMaxOutputSize);
   EXPECT_EQ(kMaxOutputSize, samples_per_channel);
   EXPECT_EQ(1, num_channels);
   EXPECT_EQ(kOutputPLC, type);
 
   // Register the payload type.
   EXPECT_EQ(NetEq::kOK,
             neteq_->RegisterPayloadType(kDecoderPCM16B, kPayloadType));
 
   // Insert 10 packets.
-  for (int i = 0; i < 10; ++i) {
+  for (size_t i = 0; i < 10; ++i) {
     rtp_header.header.sequenceNumber++;
     rtp_header.header.timestamp += kPayloadLengthSamples;
     EXPECT_EQ(NetEq::kOK,
               neteq_->InsertPacket(rtp_header, payload, kPayloadLengthBytes,
                                    kReceiveTime));
     EXPECT_EQ(i + 1, packet_buffer_->NumPacketsInBuffer());
   }
 
   // Pull audio repeatedly and make sure we get normal output, that is not PLC.
-  for (int i = 0; i < 3; ++i) {
+  for (size_t i = 0; i < 3; ++i) {
     EXPECT_EQ(NetEq::kOK,
               neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
                                &num_channels, &type));
     ASSERT_LE(samples_per_channel, kMaxOutputSize);
     EXPECT_EQ(kMaxOutputSize, samples_per_channel);
     EXPECT_EQ(1, num_channels);
     EXPECT_EQ(kOutputNormal, type)
         << "NetEq did not decode the packets as expected.";
   }
 }
 
 // This test verifies that NetEq can handle comfort noise and enters/quits codec
 // internal CNG mode properly.
 TEST_F(NetEqImplTest, CodecInternalCng) {
   UseNoMocks();
   CreateInstance();
 
   const uint8_t kPayloadType = 17;   // Just an arbitrary number.
   const uint32_t kReceiveTime = 17;  // Value doesn't matter for this test.
   const int kSampleRateKhz = 48;
-  const int kPayloadLengthSamples = 20 * kSampleRateKhz;  // 20 ms.
-  const int kPayloadLengthBytes = 10;
+  const size_t kPayloadLengthSamples =
+      static_cast<size_t>(20 * kSampleRateKhz);  // 20 ms.
+  const size_t kPayloadLengthBytes = 10;
   uint8_t payload[kPayloadLengthBytes] = {0};
   int16_t dummy_output[kPayloadLengthSamples] = {0};
 
   WebRtcRTPHeader rtp_header;
   rtp_header.header.payloadType = kPayloadType;
   rtp_header.header.sequenceNumber = 0x1234;
   rtp_header.header.timestamp = 0x12345678;
   rtp_header.header.ssrc = 0x87654321;
 
   // Create a mock decoder object.
@@ skipping 42 matching lines @@
                 rtp_header, payload, kPayloadLengthBytes, kReceiveTime));
 
   // Insert second packet (decoder will return CNG).
   payload[0] = 1;
   rtp_header.header.sequenceNumber++;
   rtp_header.header.timestamp += kPayloadLengthSamples;
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(
                 rtp_header, payload, kPayloadLengthBytes, kReceiveTime));
 
-  const int kMaxOutputSize = 10 * kSampleRateKhz;
+  const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateKhz);
   int16_t output[kMaxOutputSize];
-  int samples_per_channel;
+  size_t samples_per_channel;
   int num_channels;
   uint32_t timestamp;
   uint32_t last_timestamp;
   NetEqOutputType type;
   NetEqOutputType expected_type[8] = {
       kOutputNormal, kOutputNormal,
       kOutputCNG, kOutputCNG,
       kOutputCNG, kOutputCNG,
       kOutputNormal, kOutputNormal
   };
   int expected_timestamp_increment[8] = {
       -1,  // will not be used.
       10 * kSampleRateKhz,
       0, 0,  // timestamp does not increase during CNG mode.
       0, 0,
       50 * kSampleRateKhz, 10 * kSampleRateKhz
   };
 
   EXPECT_EQ(NetEq::kOK,
             neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
                              &num_channels, &type));
   EXPECT_TRUE(neteq_->GetPlayoutTimestamp(&last_timestamp));
 
-  for (int i = 1; i < 6; ++i) {
+  for (size_t i = 1; i < 6; ++i) {
     ASSERT_EQ(kMaxOutputSize, samples_per_channel);
     EXPECT_EQ(1, num_channels);
     EXPECT_EQ(expected_type[i - 1], type);
     EXPECT_TRUE(neteq_->GetPlayoutTimestamp(&timestamp));
     EXPECT_EQ(NetEq::kOK,
               neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
                                &num_channels, &type));
     EXPECT_TRUE(neteq_->GetPlayoutTimestamp(&timestamp));
     EXPECT_EQ(timestamp, last_timestamp + expected_timestamp_increment[i]);
     last_timestamp = timestamp;
   }
 
   // Insert third packet, which leaves a gap from last packet.
   payload[0] = 2;
   rtp_header.header.sequenceNumber += 2;
   rtp_header.header.timestamp += 2 * kPayloadLengthSamples;
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(
                 rtp_header, payload, kPayloadLengthBytes, kReceiveTime));
 
-  for (int i = 6; i < 8; ++i) {
+  for (size_t i = 6; i < 8; ++i) {
     ASSERT_EQ(kMaxOutputSize, samples_per_channel);
     EXPECT_EQ(1, num_channels);
     EXPECT_EQ(expected_type[i - 1], type);
     EXPECT_EQ(NetEq::kOK,
               neteq_->GetAudio(kMaxOutputSize, output, &samples_per_channel,
                                &num_channels, &type));
     EXPECT_TRUE(neteq_->GetPlayoutTimestamp(&timestamp));
     EXPECT_EQ(timestamp, last_timestamp + expected_timestamp_increment[i]);
     last_timestamp = timestamp;
   }
 
   // Now check the packet buffer, and make sure it is empty.
   EXPECT_TRUE(packet_buffer_->Empty());
 
   EXPECT_CALL(mock_decoder, Die());
 }
 
 TEST_F(NetEqImplTest, UnsupportedDecoder) {
   UseNoMocks();
   CreateInstance();
   static const size_t kNetEqMaxFrameSize = 2880;  // 60 ms @ 48 kHz.
   static const int kChannels = 2;
 
   const uint8_t kPayloadType = 17;   // Just an arbitrary number.
   const uint32_t kReceiveTime = 17;  // Value doesn't matter for this test.
   const int kSampleRateHz = 8000;
 
-  const int kPayloadLengthSamples = 10 * kSampleRateHz / 1000;  // 10 ms.
+  const size_t kPayloadLengthSamples =
+      static_cast<size_t>(10 * kSampleRateHz / 1000);  // 10 ms.
   const size_t kPayloadLengthBytes = 1;
   uint8_t payload[kPayloadLengthBytes]= {0};
   int16_t dummy_output[kPayloadLengthSamples * kChannels] = {0};
   WebRtcRTPHeader rtp_header;
   rtp_header.header.payloadType = kPayloadType;
   rtp_header.header.sequenceNumber = 0x1234;
   rtp_header.header.timestamp = 0x12345678;
   rtp_header.header.ssrc = 0x87654321;
 
   class MockAudioDecoder : public AudioDecoder {
@@ skipping 20 matching lines @@
       .Times(0);
 
   EXPECT_CALL(decoder_, DecodeInternal(Pointee(kSecondPayloadValue),
                                        kPayloadLengthBytes,
                                        kSampleRateHz, _, _))
       .Times(1)
       .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
                                           dummy_output +
                                           kPayloadLengthSamples * kChannels),
                       SetArgPointee<4>(AudioDecoder::kSpeech),
-                      Return(kPayloadLengthSamples * kChannels)));
+                      Return(static_cast<int>(
+                          kPayloadLengthSamples * kChannels))));
 
   EXPECT_CALL(decoder_, PacketDuration(Pointee(kSecondPayloadValue),
                                        kPayloadLengthBytes))
     .Times(AtLeast(1))
     .WillRepeatedly(Return(kNetEqMaxFrameSize));
 
   EXPECT_EQ(NetEq::kOK,
             neteq_->RegisterExternalDecoder(&decoder_, kDecoderPCM16B,
                                             kPayloadType, kSampleRateHz));
 
   // Insert one packet.
   payload[0] = kFirstPayloadValue;  // This will make Decode() fail.
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(
                 rtp_header, payload, kPayloadLengthBytes, kReceiveTime));
 
   // Insert another packet.
   payload[0] = kSecondPayloadValue;  // This will make Decode() successful.
   rtp_header.header.sequenceNumber++;
   // The second timestamp needs to be at least 30 ms after the first to make
   // the second packet get decoded.
   rtp_header.header.timestamp += 3 * kPayloadLengthSamples;
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(
                 rtp_header, payload, kPayloadLengthBytes, kReceiveTime));
 
-  const int kMaxOutputSize = 10 * kSampleRateHz / 1000 * kChannels;
+  const size_t kMaxOutputSize =
+      static_cast<size_t>(10 * kSampleRateHz / 1000 * kChannels);
   int16_t output[kMaxOutputSize];
-  int samples_per_channel;
+  size_t samples_per_channel;
   int num_channels;
   NetEqOutputType type;
 
   EXPECT_EQ(NetEq::kFail, neteq_->GetAudio(kMaxOutputSize, output,
                                            &samples_per_channel, &num_channels,
                                            &type));
   EXPECT_EQ(NetEq::kOtherDecoderError, neteq_->LastError());
   EXPECT_EQ(kMaxOutputSize, samples_per_channel * kChannels);
   EXPECT_EQ(kChannels, num_channels);
 
   EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(kMaxOutputSize, output,
                                          &samples_per_channel, &num_channels,
                                          &type));
   EXPECT_EQ(kMaxOutputSize, samples_per_channel * kChannels);
   EXPECT_EQ(kChannels, num_channels);
 }
 
 }  // namespace webrtc