Convert channel counts to size_t.

webrtc/modules/audio_coding/neteq/neteq_stereo_unittest.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.
  */
 
 // Test to verify correct stereo and multi-channel operation.
 
 #include <algorithm>
 #include <string>
 #include <list>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/audio_coding/codecs/pcm16b/pcm16b.h"
 #include "webrtc/modules/audio_coding/neteq/include/neteq.h"
 #include "webrtc/modules/audio_coding/neteq/tools/input_audio_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/rtp_generator.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 namespace webrtc {
 
 struct TestParameters {
   int frame_size;
   int sample_rate;
-  int num_channels;
+  size_t num_channels;
 };
 
 // This is a parameterized test. The test parameters are supplied through a
 // TestParameters struct, which is obtained through the GetParam() method.
 //
 // The objective of the test is to create a mono input signal and a
 // multi-channel input signal, where each channel is identical to the mono
 // input channel. The two input signals are processed through their respective
 // NetEq instances. After that, the output signals are compared. The expected
 // result is that each channel in the multi-channel output is identical to the
@@ skipping 115 matching lines @@
     if (frame_size_samples_ * 2 * num_channels_ != multi_payload_size_bytes_) {
       return -1;
     }
     rtp_generator_.GetRtpHeader(kPayloadTypeMulti, frame_size_samples_,
                                 &rtp_header_);
     return next_send_time;
   }
 
   void VerifyOutput(size_t num_samples) {
     for (size_t i = 0; i < num_samples; ++i) {
-      for (int j = 0; j < num_channels_; ++j) {
+      for (size_t j = 0; j < num_channels_; ++j) {
         ASSERT_EQ(output_[i], output_multi_channel_[i * num_channels_ + j]) <<
             "Diff in sample " << i << ", channel " << j << ".";
       }
     }
   }
 
   virtual int GetArrivalTime(int send_time) {
     int arrival_time = last_arrival_time_ + (send_time - last_send_time_);
     last_send_time_ = send_time;
     last_arrival_time_ = arrival_time;
@@ skipping 30 matching lines @@
         // Get next input packets (mono and multi-channel).
         do {
           next_send_time = GetNewPackets();
           ASSERT_NE(-1, next_send_time);
           next_arrival_time = GetArrivalTime(next_send_time);
         } while (Lost());  // If lost, immediately read the next packet.
       }
       NetEqOutputType output_type;
       // Get audio from mono instance.
       size_t samples_per_channel;
-      int num_channels;
+      size_t num_channels;
       EXPECT_EQ(NetEq::kOK,
                 neteq_mono_->GetAudio(kMaxBlockSize, output_,
                                       &samples_per_channel, &num_channels,
                                       &output_type));
-      EXPECT_EQ(1, num_channels);
+      EXPECT_EQ(1u, num_channels);
       EXPECT_EQ(output_size_samples_, samples_per_channel);
       // Get audio from multi-channel instance.
       ASSERT_EQ(NetEq::kOK,
                 neteq_->GetAudio(kMaxBlockSize * num_channels_,
                                  output_multi_channel_,
                                  &samples_per_channel, &num_channels,
                                  &output_type));
       EXPECT_EQ(num_channels_, num_channels);
       EXPECT_EQ(output_size_samples_, samples_per_channel);
       std::ostringstream ss;
       ss << "Lap number " << k << ".";
       SCOPED_TRACE(ss.str());  // Print out the parameter values on failure.
       // Compare mono and multi-channel.
       ASSERT_NO_FATAL_FAILURE(VerifyOutput(output_size_samples_));
 
       time_now += kTimeStepMs;
     }
   }
 
-  const int num_channels_;
+  const size_t num_channels_;
   const int sample_rate_hz_;
   const int samples_per_ms_;
   const int frame_size_ms_;
   const size_t frame_size_samples_;
   const size_t output_size_samples_;
   NetEq* neteq_mono_;
   NetEq* neteq_;
   test::RtpGenerator rtp_generator_mono_;
   test::RtpGenerator rtp_generator_;
   int16_t* input_;
@@ skipping 168 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(MultiChannel,
                         NetEqStereoTestDelays,
                         ::testing::ValuesIn(GetTestParameters()));
 
 INSTANTIATE_TEST_CASE_P(MultiChannel,
                         NetEqStereoTestLosses,
                         ::testing::ValuesIn(GetTestParameters()));
 
 }  // namespace webrtc