Change NetEq::GetAudio to use AudioFrame

webrtc/modules/audio_coding/neteq/neteq_external_decoder_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 operation for externally created decoders.
 
 #include <memory>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "webrtc/modules/audio_coding/neteq/mock/mock_external_decoder_pcm16b.h"
 #include "webrtc/modules/audio_coding/neteq/tools/input_audio_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/neteq_external_decoder_test.h"
 #include "webrtc/modules/audio_coding/neteq/tools/rtp_generator.h"
+#include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/test/testsupport/fileutils.h"
 
 namespace webrtc {
 
 using ::testing::_;
 using ::testing::Return;
 
 class NetEqExternalDecoderUnitTest : public test::NetEqExternalDecoderTest {
  protected:
   static const int kFrameSizeMs = 10;  // Frame size of Pcm16B.
@@ skipping 151 matching lines @@
   }
 
   void SetUp() override {
     ASSERT_EQ(NetEq::kOK, neteq_internal_->RegisterPayloadType(
                               NetEqDecoder::kDecoderPCM16Bswb32kHz,
                               "pcm16-swb32", kPayloadType));
   }
 
   void GetAndVerifyOutput() override {
     NetEqOutputType output_type;
-    size_t samples_per_channel;
-    size_t num_channels;
     // Get audio from internal decoder instance.
     EXPECT_EQ(NetEq::kOK,
-              neteq_internal_->GetAudio(kMaxBlockSize,
-                                        output_internal_,
-                                        &samples_per_channel,
-                                        &num_channels,
-                                        &output_type));
-    EXPECT_EQ(1u, num_channels);
+              neteq_internal_->GetAudio(&output_internal_, &output_type));
+    EXPECT_EQ(1u, output_internal_.num_channels_);
     EXPECT_EQ(static_cast<size_t>(kOutputLengthMs * sample_rate_hz_ / 1000),
-              samples_per_channel);
+              output_internal_.samples_per_channel_);
 
     // Get audio from external decoder instance.
-    samples_per_channel = GetOutputAudio(kMaxBlockSize, output_, &output_type);
+    GetOutputAudio(&output_, &output_type);
 
-    for (size_t i = 0; i < samples_per_channel; ++i) {
-      ASSERT_EQ(output_[i], output_internal_[i]) <<
-          "Diff in sample " << i << ".";
+    for (size_t i = 0; i < output_.samples_per_channel_; ++i) {
+      ASSERT_EQ(output_.data_[i], output_internal_.data_[i])
+          << "Diff in sample " << i << ".";
     }
   }
 
   void InsertPacket(WebRtcRTPHeader rtp_header,
                     rtc::ArrayView<const uint8_t> payload,
                     uint32_t receive_timestamp) override {
     // Insert packet in internal decoder.
     ASSERT_EQ(NetEq::kOK, neteq_internal_->InsertPacket(rtp_header, payload,
                                                         receive_timestamp));
 
     // Insert packet in external decoder instance.
     NetEqExternalDecoderUnitTest::InsertPacket(rtp_header, payload,
                                                receive_timestamp);
   }
 
   int NumExpectedDecodeCalls(int num_loops) override { return num_loops; }
 
  private:
   int sample_rate_hz_;
   std::unique_ptr<NetEq> neteq_internal_;
-  int16_t output_internal_[kMaxBlockSize];
-  int16_t output_[kMaxBlockSize];
+  AudioFrame output_internal_;
+  AudioFrame output_;
 };
 
 TEST_F(NetEqExternalVsInternalDecoderTest, RunTest) {
   RunTest(100);  // Run 100 laps @ 10 ms each in the test loop.
 }
 
 class LargeTimestampJumpTest : public NetEqExternalDecoderUnitTest,
                                public ::testing::Test {
  protected:
   static const size_t kMaxBlockSize = 480;  // 10 ms @ 48 kHz.
@@ skipping 42 matching lines @@
         }
         break;
       }
       case kRecovered: {
         break;
       }
     }
   }
 
   void GetAndVerifyOutput() override {
-    size_t num_samples;
+    AudioFrame output;
     NetEqOutputType output_type;
-    num_samples = GetOutputAudio(kMaxBlockSize, output_, &output_type);
+    GetOutputAudio(&output, &output_type);
     UpdateState(output_type);
 
     if (test_state_ == kExpandPhase || test_state_ == kFadedExpandPhase) {
       // Don't verify the output in this phase of the test.
       return;
     }
 
-    for (size_t i = 0; i < num_samples; ++i) {
-      if (output_[i] != 0)
+    ASSERT_EQ(1u, output.num_channels_);
+    for (size_t i = 0; i < output.samples_per_channel_; ++i) {
+      if (output.data_[i] != 0)
         return;
     }
     EXPECT_TRUE(false)
         << "Expected at least one non-zero sample in each output block.";
   }
 
   int NumExpectedDecodeCalls(int num_loops) override {
     // Some packets at the end of the stream won't be decoded. When the jump in
     // timestamp happens, NetEq will do Expand during one GetAudio call. In the
     // next call it will decode the packet after the jump, but the net result is
     // that the delay increased by 1 packet. In another call, a Pre-emptive
     // Expand operation is performed, leading to delay increase by 1 packet. In
     // total, the test will end with a 2-packet delay, which results in the 2
     // last packets not being decoded.
     return num_loops - 2;
   }
 
   TestStates test_state_;
-
- private:
-  int16_t output_[kMaxBlockSize];
 };
 
 TEST_F(LargeTimestampJumpTest, JumpLongerThanHalfRange) {
   // Set the timestamp series to start at 2880, increase to 7200, then jump to
   // 2869342376. The sequence numbers start at 42076 and increase by 1 for each
   // packet, also when the timestamp jumps.
   static const uint16_t kStartSeqeunceNumber = 42076;
   static const uint32_t kStartTimestamp = 2880;
   static const uint32_t kJumpFromTimestamp = 7200;
   static const uint32_t kJumpToTimestamp = 2869342376;
@@ skipping 114 matching lines @@
                                                         kStartSeqeunceNumber,
                                                         kStartTimestamp,
                                                         kJumpFromTimestamp,
                                                         kJumpToTimestamp));
 
   RunTest(130);  // Run 130 laps @ 10 ms each in the test loop.
   EXPECT_EQ(kRecovered, test_state_);
 }
 
 }  // namespace webrtc