AudioDecoder: Replace Init() with Reset()

webrtc/modules/audio_coding/neteq/audio_decoder_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 153 matching lines @@
   // audio, the absolute difference between the two channels is compared vs
   // |channel_diff_tolerance|.
   void EncodeDecodeTest(size_t expected_bytes, int tolerance, double mse,
                         int delay = 0, int channel_diff_tolerance = 0) {
     ASSERT_GE(tolerance, 0) << "Test must define a tolerance >= 0";
     ASSERT_GE(channel_diff_tolerance, 0) <<
         "Test must define a channel_diff_tolerance >= 0";
     size_t processed_samples = 0u;
     encoded_bytes_ = 0u;
     InitEncoder();
-    EXPECT_EQ(0, decoder_->Init());
     std::vector<int16_t> input;
     std::vector<int16_t> decoded;
     while (processed_samples + frame_size_ <= data_length_) {
       // Extend input vector with |frame_size_|.
       input.resize(input.size() + frame_size_, 0);
       // Read from input file.
       ASSERT_GE(input.size() - processed_samples, frame_size_);
       ASSERT_TRUE(input_audio_.Read(
           frame_size_, codec_input_rate_hz_, &input[processed_samples]));
       size_t enc_len = EncodeFrame(
@@ skipping 28 matching lines @@
   // Encodes a payload and decodes it twice with decoder re-init before each
   // decode. Verifies that the decoded result is the same.
   void ReInitTest() {
     InitEncoder();
     rtc::scoped_ptr<int16_t[]> input(new int16_t[frame_size_]);
     ASSERT_TRUE(
         input_audio_.Read(frame_size_, codec_input_rate_hz_, input.get()));
     size_t enc_len = EncodeFrame(input.get(), frame_size_, encoded_);
     size_t dec_len;
     AudioDecoder::SpeechType speech_type1, speech_type2;
-    EXPECT_EQ(0, decoder_->Init());
+    decoder_->Reset();
     rtc::scoped_ptr<int16_t[]> output1(new int16_t[frame_size_ * channels_]);
     dec_len = decoder_->Decode(encoded_, enc_len, codec_input_rate_hz_,
                                frame_size_ * channels_ * sizeof(int16_t),
                                output1.get(), &speech_type1);
     ASSERT_LE(dec_len, frame_size_ * channels_);
     EXPECT_EQ(frame_size_ * channels_, dec_len);
     // Re-init decoder and decode again.
-    EXPECT_EQ(0, decoder_->Init());
+    decoder_->Reset();
     rtc::scoped_ptr<int16_t[]> output2(new int16_t[frame_size_ * channels_]);
     dec_len = decoder_->Decode(encoded_, enc_len, codec_input_rate_hz_,
                                frame_size_ * channels_ * sizeof(int16_t),
                                output2.get(), &speech_type2);
     ASSERT_LE(dec_len, frame_size_ * channels_);
     EXPECT_EQ(frame_size_ * channels_, dec_len);
     for (unsigned int n = 0; n < frame_size_; ++n) {
       ASSERT_EQ(output1[n], output2[n]) << "Exit test on first diff; n = " << n;
     }
     EXPECT_EQ(speech_type1, speech_type2);
   }
 
   // Call DecodePlc and verify that the correct number of samples is produced.
   void DecodePlcTest() {
     InitEncoder();
     rtc::scoped_ptr<int16_t[]> input(new int16_t[frame_size_]);
     ASSERT_TRUE(
         input_audio_.Read(frame_size_, codec_input_rate_hz_, input.get()));
     size_t enc_len = EncodeFrame(input.get(), frame_size_, encoded_);
     AudioDecoder::SpeechType speech_type;
-    EXPECT_EQ(0, decoder_->Init());
+    decoder_->Reset();
     rtc::scoped_ptr<int16_t[]> output(new int16_t[frame_size_ * channels_]);
     size_t dec_len = decoder_->Decode(encoded_, enc_len, codec_input_rate_hz_,
                                       frame_size_ * channels_ * sizeof(int16_t),
                                       output.get(), &speech_type);
     EXPECT_EQ(frame_size_ * channels_, dec_len);
     // Call DecodePlc and verify that we get one frame of data.
     // (Overwrite the output from the above Decode call, but that does not
     // matter.)
     dec_len = decoder_->DecodePlc(1, output.get());
     EXPECT_EQ(frame_size_ * channels_, dec_len);
@@ skipping 71 matching lines @@
 
   // Overload the default test since iLBC's function WebRtcIlbcfix_NetEqPlc does
   // not return any data. It simply resets a few states and returns 0.
   void DecodePlcTest() {
     InitEncoder();
     rtc::scoped_ptr<int16_t[]> input(new int16_t[frame_size_]);
     ASSERT_TRUE(
         input_audio_.Read(frame_size_, codec_input_rate_hz_, input.get()));
     size_t enc_len = EncodeFrame(input.get(), frame_size_, encoded_);
     AudioDecoder::SpeechType speech_type;
-    EXPECT_EQ(0, decoder_->Init());
+    decoder_->Reset();
     rtc::scoped_ptr<int16_t[]> output(new int16_t[frame_size_ * channels_]);
     size_t dec_len = decoder_->Decode(encoded_, enc_len, codec_input_rate_hz_,
                                       frame_size_ * channels_ * sizeof(int16_t),
                                       output.get(), &speech_type);
     EXPECT_EQ(frame_size_, dec_len);
     // Simply call DecodePlc and verify that we get 0 as return value.
     EXPECT_EQ(0U, decoder_->DecodePlc(1, output.get()));
   }
 };
 
@@ skipping 365 matching lines @@
   EXPECT_TRUE(CodecSupported(kDecoderCNGnb));
   EXPECT_TRUE(CodecSupported(kDecoderCNGwb));
   EXPECT_TRUE(CodecSupported(kDecoderCNGswb32kHz));
   EXPECT_TRUE(CodecSupported(kDecoderCNGswb48kHz));
   EXPECT_TRUE(CodecSupported(kDecoderArbitrary));
   EXPECT_TRUE(CodecSupported(kDecoderOpus));
   EXPECT_TRUE(CodecSupported(kDecoderOpus_2ch));
 }
 
 }  // namespace webrtc