Changed AudioEncoder::Encode to take an rtc::Buffer* instead of uint8_t* and a maximum size.

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 82 matching lines @@
 }
 }  // namespace
 
 class AudioDecoderTest : public ::testing::Test {
  protected:
   AudioDecoderTest()
       : input_audio_(
             webrtc::test::ResourcePath("audio_coding/testfile32kHz", "pcm"),
             32000),
         codec_input_rate_hz_(32000),  // Legacy default value.
-        encoded_(NULL),
         frame_size_(0),
         data_length_(0),
         encoded_bytes_(0),
         channels_(1),
         payload_type_(17),
         decoder_(NULL) {}
 
   virtual ~AudioDecoderTest() {}
 
   virtual void SetUp() {
     if (audio_encoder_)
       codec_input_rate_hz_ = audio_encoder_->SampleRateHz();
     // Create arrays.
     ASSERT_GT(data_length_, 0u) << "The test must set data_length_ > 0";
-    // Longest encoded data is produced by PCM16b with 2 bytes per sample.
-    encoded_ = new uint8_t[data_length_ * 2];
+    // Make sure the encode buffer is empty at the start of each test.
+    encoded_.Clear();

[kwiberg-webrtc, 2016/02/25 00:29:04]

Can you allocate a Buffer on the stack for each test instead? Reducing the state
is always good.

[ossu, 2016/02/25 10:39:51]

Sure.

     // Logging to view input and output in Matlab.
     // Use 'gyp -Denable_data_logging=1' to enable logging.
     DataLog::CreateLog();
     DataLog::AddTable("CodecTest");
     DataLog::AddColumn("CodecTest", "input", 1);
     DataLog::AddColumn("CodecTest", "output", 1);
   }
 
   virtual void TearDown() {
     delete decoder_;
     decoder_ = NULL;
-    // Delete arrays.
-    delete [] encoded_;
-    encoded_ = NULL;
     // Close log.
     DataLog::ReturnLog();
   }
 
   virtual void InitEncoder() { }
 
   // TODO(henrik.lundin) Change return type to size_t once most/all overriding
   // implementations are gone.
   virtual int EncodeFrame(const int16_t* input,
                           size_t input_len_samples,
-                          uint8_t* output) {
+                          rtc::Buffer* output) {
     encoded_info_.encoded_bytes = 0;
     const size_t samples_per_10ms = audio_encoder_->SampleRateHz() / 100;
     RTC_CHECK_EQ(samples_per_10ms * audio_encoder_->Num10MsFramesInNextPacket(),
                  input_len_samples);
     std::unique_ptr<int16_t[]> interleaved_input(
         new int16_t[channels_ * samples_per_10ms]);
     for (size_t i = 0; i < audio_encoder_->Num10MsFramesInNextPacket(); ++i) {
       EXPECT_EQ(0u, encoded_info_.encoded_bytes);
 
       // Duplicate the mono input signal to however many channels the test
       // wants.
       test::InputAudioFile::DuplicateInterleaved(input + i * samples_per_10ms,
                                                  samples_per_10ms, channels_,
                                                  interleaved_input.get());
 
       encoded_info_ = audio_encoder_->Encode(
           0, rtc::ArrayView<const int16_t>(interleaved_input.get(),
                                            audio_encoder_->NumChannels() *
                                                audio_encoder_->SampleRateHz() /
                                                100),
-          data_length_ * 2, output);
+          output);
     }
     EXPECT_EQ(payload_type_, encoded_info_.payload_type);
     return static_cast<int>(encoded_info_.encoded_bytes);
   }
 
   // Encodes and decodes audio. The absolute difference between the input and
   // output is compared vs |tolerance|, and the mean-squared error is compared
   // with |mse|. The encoded stream should contain |expected_bytes|. For stereo
   // 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_.Clear();
     encoded_bytes_ = 0u;
     InitEncoder();
     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(
-          &input[processed_samples], frame_size_, &encoded_[encoded_bytes_]);
+          &input[processed_samples], frame_size_, &encoded_);
       // Make sure that frame_size_ * channels_ samples are allocated and free.
       decoded.resize((processed_samples + frame_size_) * channels_, 0);
       AudioDecoder::SpeechType speech_type;
       size_t dec_len = decoder_->Decode(
-          &encoded_[encoded_bytes_], enc_len, codec_input_rate_hz_,
+          &encoded_.data()[encoded_bytes_], enc_len, codec_input_rate_hz_,
           frame_size_ * channels_ * sizeof(int16_t),
           &decoded[processed_samples * channels_], &speech_type);
       EXPECT_EQ(frame_size_ * channels_, dec_len);
       encoded_bytes_ += enc_len;
       processed_samples += frame_size_;
     }
     // For some codecs it doesn't make sense to check expected number of bytes,
     // since the number can vary for different platforms. Opus and iSAC are
     // such codecs. In this case expected_bytes is set to 0.
     if (expected_bytes) {
       EXPECT_EQ(expected_bytes, encoded_bytes_);
     }
     CompareInputOutput(
         input, decoded, processed_samples, channels_, tolerance, delay);
     if (channels_ == 2)
       CompareTwoChannels(
           decoded, processed_samples, channels_, channel_diff_tolerance);
     EXPECT_LE(
         MseInputOutput(input, decoded, processed_samples, channels_, delay),
         mse);
   }
 
   // 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();
     std::unique_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_);
+    encoded_.Clear();
+    size_t enc_len = EncodeFrame(input.get(), frame_size_, &encoded_);
     size_t dec_len;
     AudioDecoder::SpeechType speech_type1, speech_type2;
     decoder_->Reset();
     std::unique_ptr<int16_t[]> output1(new int16_t[frame_size_ * channels_]);
-    dec_len = decoder_->Decode(encoded_, enc_len, codec_input_rate_hz_,
+    dec_len = decoder_->Decode(encoded_.data(), 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.
     decoder_->Reset();
     std::unique_ptr<int16_t[]> output2(new int16_t[frame_size_ * channels_]);
-    dec_len = decoder_->Decode(encoded_, enc_len, codec_input_rate_hz_,
+    dec_len = decoder_->Decode(encoded_.data(), 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();
     std::unique_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_);
+    encoded_.Clear();
+    size_t enc_len = EncodeFrame(input.get(), frame_size_, &encoded_);
     AudioDecoder::SpeechType speech_type;
     decoder_->Reset();
     std::unique_ptr<int16_t[]> output(new int16_t[frame_size_ * channels_]);
-    size_t dec_len = decoder_->Decode(encoded_, enc_len, codec_input_rate_hz_,
+    size_t dec_len = decoder_->Decode(encoded_.data(), 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);
   }
 
   test::ResampleInputAudioFile input_audio_;
   int codec_input_rate_hz_;
-  uint8_t* encoded_;
+  rtc::Buffer encoded_;
   size_t frame_size_;
   size_t data_length_;
   size_t encoded_bytes_;
   size_t channels_;
   const int payload_type_;
   AudioEncoder::EncodedInfo encoded_info_;
   AudioDecoder* decoder_;
   std::unique_ptr<AudioEncoder> audio_encoder_;
 };
 
@@ skipping 54 matching lines @@
     audio_encoder_.reset(new AudioEncoderIlbc(config));
   }
 
   // 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();
     std::unique_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_);
+    encoded_.Clear();
+    size_t enc_len = EncodeFrame(input.get(), frame_size_, &encoded_);
     AudioDecoder::SpeechType speech_type;
     decoder_->Reset();
     std::unique_ptr<int16_t[]> output(new int16_t[frame_size_ * channels_]);
-    size_t dec_len = decoder_->Decode(encoded_, enc_len, codec_input_rate_hz_,
+    size_t dec_len = decoder_->Decode(encoded_.data(), 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()));
   }
 };
 
 class AudioDecoderIsacFloatTest : public AudioDecoderTest {
  protected:
@@ skipping 376 matching lines @@
   EXPECT_TRUE(CodecSupported(NetEqDecoder::kDecoderCNGnb));
   EXPECT_TRUE(CodecSupported(NetEqDecoder::kDecoderCNGwb));
   EXPECT_TRUE(CodecSupported(NetEqDecoder::kDecoderCNGswb32kHz));
   EXPECT_TRUE(CodecSupported(NetEqDecoder::kDecoderCNGswb48kHz));
   EXPECT_TRUE(CodecSupported(NetEqDecoder::kDecoderArbitrary));
   EXPECT_EQ(has_opus, CodecSupported(NetEqDecoder::kDecoderOpus));
   EXPECT_EQ(has_opus, CodecSupported(NetEqDecoder::kDecoderOpus_2ch));
 }
 
 }  // namespace webrtc