Convert channel counts to size_t.

webrtc/modules/audio_coding/codecs/opus/opus_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.
  */
 #include <string>
@@ skipping 24 matching lines @@
 class OpusTest : public TestWithParam<::testing::tuple<int, int>> {
  protected:
   OpusTest();
 
   void TestDtxEffect(bool dtx, int block_length_ms);
 
   // Prepare |speech_data_| for encoding, read from a hard-coded file.
   // After preparation, |speech_data_.GetNextBlock()| returns a pointer to a
   // block of |block_length_ms| milliseconds. The data is looped every
   // |loop_length_ms| milliseconds.
-  void PrepareSpeechData(int channel, int block_length_ms, int loop_length_ms);
+  void PrepareSpeechData(size_t channel,
+                         int block_length_ms,
+                         int loop_length_ms);
 
   int EncodeDecode(WebRtcOpusEncInst* encoder,
                    rtc::ArrayView<const int16_t> input_audio,
                    WebRtcOpusDecInst* decoder,
                    int16_t* output_audio,
                    int16_t* audio_type);
 
   void SetMaxPlaybackRate(WebRtcOpusEncInst* encoder,
                           opus_int32 expect, int32_t set);
 
-  void CheckAudioBounded(const int16_t* audio, size_t samples, int channels,
+  void CheckAudioBounded(const int16_t* audio, size_t samples, size_t channels,
                          uint16_t bound) const;
 
   WebRtcOpusEncInst* opus_encoder_;
   WebRtcOpusDecInst* opus_decoder_;
 
   AudioLoop speech_data_;
   uint8_t bitstream_[kMaxBytes];
   size_t encoded_bytes_;
-  int channels_;
+  size_t channels_;
   int application_;
 };
 
 OpusTest::OpusTest()
     : opus_encoder_(NULL),
       opus_decoder_(NULL),
       encoded_bytes_(0),
-      channels_(::testing::get<0>(GetParam())),
+      channels_(static_cast<size_t>(::testing::get<0>(GetParam()))),
       application_(::testing::get<1>(GetParam())) {
 }
 
-void OpusTest::PrepareSpeechData(int channel, int block_length_ms,
+void OpusTest::PrepareSpeechData(size_t channel, int block_length_ms,
                                  int loop_length_ms) {
   const std::string file_name =
         webrtc::test::ResourcePath((channel == 1) ?
             "audio_coding/testfile32kHz" :
             "audio_coding/teststereo32kHz", "pcm");
   if (loop_length_ms < block_length_ms) {
     loop_length_ms = block_length_ms;
   }
   EXPECT_TRUE(speech_data_.Init(file_name,
                                 loop_length_ms * kOpusRateKhz * channel,
                                 block_length_ms * kOpusRateKhz * channel));
 }
 
 void OpusTest::SetMaxPlaybackRate(WebRtcOpusEncInst* encoder,
                                   opus_int32 expect,
                                   int32_t set) {
   opus_int32 bandwidth;
   EXPECT_EQ(0, WebRtcOpus_SetMaxPlaybackRate(opus_encoder_, set));
   opus_encoder_ctl(opus_encoder_->encoder,
                    OPUS_GET_MAX_BANDWIDTH(&bandwidth));
   EXPECT_EQ(expect, bandwidth);
 }
 
 void OpusTest::CheckAudioBounded(const int16_t* audio, size_t samples,
-                                 int channels, uint16_t bound) const {
+                                 size_t channels, uint16_t bound) const {
   for (size_t i = 0; i < samples; ++i) {
-    for (int c = 0; c < channels; ++c) {
+    for (size_t c = 0; c < channels; ++c) {
       ASSERT_GE(audio[i * channels + c], -bound);
       ASSERT_LE(audio[i * channels + c], bound);
     }
   }
 }
 
 int OpusTest::EncodeDecode(WebRtcOpusEncInst* encoder,
                            rtc::ArrayView<const int16_t> input_audio,
                            WebRtcOpusDecInst* decoder,
                            int16_t* output_audio,
                            int16_t* audio_type) {
   int encoded_bytes_int = WebRtcOpus_Encode(
       encoder, input_audio.data(),
-      rtc::CheckedDivExact(input_audio.size(), static_cast<size_t>(channels_)),
+      rtc::CheckedDivExact(input_audio.size(), channels_),
       kMaxBytes, bitstream_);
   EXPECT_GE(encoded_bytes_int, 0);
   encoded_bytes_ = static_cast<size_t>(encoded_bytes_int);
   int est_len = WebRtcOpus_DurationEst(decoder, bitstream_, encoded_bytes_);
   int act_len = WebRtcOpus_Decode(decoder, bitstream_,
                                   encoded_bytes_, output_audio,
                                   audio_type);
   EXPECT_EQ(est_len, act_len);
   return act_len;
 }
@@ skipping 452 matching lines @@
   // Create.
   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_, channels_));
 
   // 10 ms. We use only first 10 ms of a 20 ms block.
   auto speech_block = speech_data_.GetNextBlock();
   int encoded_bytes_int = WebRtcOpus_Encode(
       opus_encoder_, speech_block.data(),
-      rtc::CheckedDivExact(speech_block.size(),
-                           2 * static_cast<size_t>(channels_)),
+      rtc::CheckedDivExact(speech_block.size(), 2 * channels_),
       kMaxBytes, bitstream_);
   EXPECT_GE(encoded_bytes_int, 0);
   EXPECT_EQ(kOpus10msFrameSamples,
             static_cast<size_t>(WebRtcOpus_DurationEst(
                 opus_decoder_, bitstream_,
                 static_cast<size_t>(encoded_bytes_int))));
 
   // 20 ms
   speech_block = speech_data_.GetNextBlock();
   encoded_bytes_int = WebRtcOpus_Encode(
       opus_encoder_, speech_block.data(),
-      rtc::CheckedDivExact(speech_block.size(), static_cast<size_t>(channels_)),
+      rtc::CheckedDivExact(speech_block.size(), channels_),
       kMaxBytes, bitstream_);
   EXPECT_GE(encoded_bytes_int, 0);
   EXPECT_EQ(kOpus20msFrameSamples,
             static_cast<size_t>(WebRtcOpus_DurationEst(
                 opus_decoder_, bitstream_,
                 static_cast<size_t>(encoded_bytes_int))));
 
   // Free memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
@@ skipping 21 matching lines @@
   // Encode & decode.
   int16_t audio_type;
   rtc::scoped_ptr<int16_t[]> output_data_decode(
       new int16_t[kPackets * kOpus20msFrameSamples * channels_]);
   OpusRepacketizer* rp = opus_repacketizer_create();
 
   for (int idx = 0; idx < kPackets; idx++) {
     auto speech_block = speech_data_.GetNextBlock();
     encoded_bytes_ =
         WebRtcOpus_Encode(opus_encoder_, speech_block.data(),
-                          rtc::CheckedDivExact(speech_block.size(),
-                                               static_cast<size_t>(channels_)),
+                          rtc::CheckedDivExact(speech_block.size(), channels_),
                           kMaxBytes, bitstream_);
     EXPECT_EQ(OPUS_OK, opus_repacketizer_cat(rp, bitstream_, encoded_bytes_));
   }
 
   encoded_bytes_ = opus_repacketizer_out(rp, bitstream_, kMaxBytes);
 
   EXPECT_EQ(kOpus20msFrameSamples * kPackets,
             static_cast<size_t>(WebRtcOpus_DurationEst(
                 opus_decoder_, bitstream_, encoded_bytes_)));
 
   EXPECT_EQ(kOpus20msFrameSamples * kPackets,
             static_cast<size_t>(WebRtcOpus_Decode(
                 opus_decoder_, bitstream_, encoded_bytes_,
                 output_data_decode.get(), &audio_type)));
 
   // Free memory.
   opus_repacketizer_destroy(rp);
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
 }
 
 INSTANTIATE_TEST_CASE_P(VariousMode,
                         OpusTest,
                         Combine(Values(1, 2), Values(0, 1)));
 
 
 }  // namespace webrtc