Remove the type parameter to NetEq::GetAudio

webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc

Index: webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc
diff --git a/webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc b/webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc
index cb4405d16d220c7b10c42f382d02cc6c67cdee31..e1eb403022cecac01aec1273864568f3208d3438 100644
--- a/webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc
+++ b/webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc
@@ -466,11 +466,10 @@ TEST_F(NetEqImplTest, VerifyTimestampPropagation) {
   // Pull audio once.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   AudioFrame output;
-  NetEqOutputType type;
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
   ASSERT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
-  EXPECT_EQ(kOutputNormal, type);
+  EXPECT_EQ(AudioFrame::kNormalSpeech, output.speech_type_);
 
   // Start with a simple check that the fake decoder is behaving as expected.
   EXPECT_EQ(kPayloadLengthSamples,
@@ -542,11 +541,10 @@ TEST_F(NetEqImplTest, ReorderedPacket) {
   // Pull audio once.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   AudioFrame output;
-  NetEqOutputType type;
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
   ASSERT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
-  EXPECT_EQ(kOutputNormal, type);
+  EXPECT_EQ(AudioFrame::kNormalSpeech, output.speech_type_);
 
   // Insert two more packets. The first one is out of order, and is already too
   // old, the second one is the expected next packet.
@@ -571,10 +569,10 @@ TEST_F(NetEqImplTest, ReorderedPacket) {
                       Return(kPayloadLengthSamples)));
 
   // Pull audio once.
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
   ASSERT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
-  EXPECT_EQ(kOutputNormal, type);
+  EXPECT_EQ(AudioFrame::kNormalSpeech, output.speech_type_);
 
   // Now check the packet buffer, and make sure it is empty, since the
   // out-of-order packet should have been discarded.
@@ -611,12 +609,11 @@ TEST_F(NetEqImplTest, FirstPacketUnknown) {
   // Pull audio once.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   AudioFrame output;
-  NetEqOutputType type;
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
   ASSERT_LE(output.samples_per_channel_, kMaxOutputSize);
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
-  EXPECT_EQ(kOutputPLC, type);
+  EXPECT_EQ(AudioFrame::kPLC, output.speech_type_);
 
   // Register the payload type.
   EXPECT_EQ(NetEq::kOK, neteq_->RegisterPayloadType(
@@ -633,11 +630,11 @@ TEST_F(NetEqImplTest, FirstPacketUnknown) {
 
   // Pull audio repeatedly and make sure we get normal output, that is not PLC.
   for (size_t i = 0; i < 3; ++i) {
-    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
     ASSERT_LE(output.samples_per_channel_, kMaxOutputSize);
     EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
     EXPECT_EQ(1u, output.num_channels_);
-    EXPECT_EQ(kOutputNormal, type)
+    EXPECT_EQ(AudioFrame::kNormalSpeech, output.speech_type_)
         << "NetEq did not decode the packets as expected.";
   }
 }
@@ -719,12 +716,11 @@ TEST_F(NetEqImplTest, CodecInternalCng) {
   AudioFrame output;
   uint32_t timestamp;
   uint32_t last_timestamp;
-  NetEqOutputType type;
-  NetEqOutputType expected_type[8] = {
-      kOutputNormal, kOutputNormal,
-      kOutputCNG, kOutputCNG,
-      kOutputCNG, kOutputCNG,
-      kOutputNormal, kOutputNormal
+  AudioFrame::SpeechType expected_type[8] = {
+      AudioFrame::kNormalSpeech, AudioFrame::kNormalSpeech,
+      AudioFrame::kCNG, AudioFrame::kCNG,
+      AudioFrame::kCNG, AudioFrame::kCNG,
+      AudioFrame::kNormalSpeech, AudioFrame::kNormalSpeech
   };
   int expected_timestamp_increment[8] = {
       -1,  // will not be used.
@@ -734,15 +730,15 @@ TEST_F(NetEqImplTest, CodecInternalCng) {
       50 * kSampleRateKhz, 10 * kSampleRateKhz
   };
 
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
   EXPECT_TRUE(neteq_->GetPlayoutTimestamp(&last_timestamp));
 
   for (size_t i = 1; i < 6; ++i) {
     ASSERT_EQ(kMaxOutputSize, output.samples_per_channel_);
     EXPECT_EQ(1u, output.num_channels_);
-    EXPECT_EQ(expected_type[i - 1], type);
+    EXPECT_EQ(expected_type[i - 1], output.speech_type_);
     EXPECT_TRUE(neteq_->GetPlayoutTimestamp(&timestamp));
-    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
     EXPECT_TRUE(neteq_->GetPlayoutTimestamp(&timestamp));
     EXPECT_EQ(timestamp, last_timestamp + expected_timestamp_increment[i]);
     last_timestamp = timestamp;
@@ -758,8 +754,8 @@ TEST_F(NetEqImplTest, CodecInternalCng) {
   for (size_t i = 6; i < 8; ++i) {
     ASSERT_EQ(kMaxOutputSize, output.samples_per_channel_);
     EXPECT_EQ(1u, output.num_channels_);
-    EXPECT_EQ(expected_type[i - 1], type);
-    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+    EXPECT_EQ(expected_type[i - 1], output.speech_type_);
+    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
     EXPECT_TRUE(neteq_->GetPlayoutTimestamp(&timestamp));
     EXPECT_EQ(timestamp, last_timestamp + expected_timestamp_increment[i]);
     last_timestamp = timestamp;
@@ -848,10 +844,9 @@ TEST_F(NetEqImplTest, UnsupportedDecoder) {
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
 
   AudioFrame output;
-  NetEqOutputType type;
   // First call to GetAudio will try to decode the "faulty" packet.
   // Expect kFail return value...
-  EXPECT_EQ(NetEq::kFail, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kFail, neteq_->GetAudio(&output));
   // ... and kOtherDecoderError error code.
   EXPECT_EQ(NetEq::kOtherDecoderError, neteq_->LastError());
   // Output size and number of channels should be correct.
@@ -861,7 +856,7 @@ TEST_F(NetEqImplTest, UnsupportedDecoder) {
 
   // Second call to GetAudio will decode the packet that is ok. No errors are
   // expected.
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
   EXPECT_EQ(kExpectedOutputSize, output.samples_per_channel_ * kChannels);
   EXPECT_EQ(kChannels, output.num_channels_);
 }
@@ -954,11 +949,10 @@ TEST_F(NetEqImplTest, DecodedPayloadTooShort) {
   // Pull audio once.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   AudioFrame output;
-  NetEqOutputType type;
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
   ASSERT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
-  EXPECT_EQ(kOutputNormal, type);
+  EXPECT_EQ(AudioFrame::kNormalSpeech, output.speech_type_);
 
   EXPECT_CALL(mock_decoder, Die());
 }
@@ -1047,33 +1041,31 @@ TEST_F(NetEqImplTest, DecodingError) {
   // Pull audio.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   AudioFrame output;
-  NetEqOutputType type;
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
-  EXPECT_EQ(kOutputNormal, type);
+  EXPECT_EQ(AudioFrame::kNormalSpeech, output.speech_type_);
 
   // Pull audio again. Decoder fails.
-  EXPECT_EQ(NetEq::kFail, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kFail, neteq_->GetAudio(&output));
   EXPECT_EQ(NetEq::kDecoderErrorCode, neteq_->LastError());
   EXPECT_EQ(kDecoderErrorCode, neteq_->LastDecoderError());
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
-  // TODO(minyue): should NetEq better give kOutputPLC, since it is actually an
-  // expansion.
-  EXPECT_EQ(kOutputNormal, type);

[ivoc, 2016/03/07 16:26:22]

Is this change caused by the refactoring in this CL or is it just a general
improvement of the test?

[hlundin-webrtc, 2016/03/08 08:05:33]

A bit of both. In the old code, the output type was not set when the GetAudio
call failed; the type variable remained the same it was before the call (which
happened to be kOutputNormal in this case). The new code also does not guarantee
that all fields in the AudioFrame are set when an error happens (I specified
that in the function comment), so the correct thing to do in the test is to not
look at the type at all; it can be anything and that is by design.

[ivoc, 2016/03/08 08:26:29]

Ok, that makes sense.

+  // We are not expecting anything for output.speech_type_, since an error was
+  // returned.
 
   // Pull audio again, should continue an expansion.
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
-  EXPECT_EQ(kOutputPLC, type);
+  EXPECT_EQ(AudioFrame::kPLC, output.speech_type_);
 
   // Pull audio again, should behave normal.
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
-  EXPECT_EQ(kOutputNormal, type);
+  EXPECT_EQ(AudioFrame::kNormalSpeech, output.speech_type_);
 
   EXPECT_CALL(mock_decoder, Die());
 }
@@ -1158,27 +1150,25 @@ TEST_F(NetEqImplTest, DecodingErrorDuringInternalCng) {
   // Pull audio.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   AudioFrame output;
-  NetEqOutputType type;
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
-  EXPECT_EQ(kOutputCNG, type);
+  EXPECT_EQ(AudioFrame::kCNG, output.speech_type_);
 
   // Pull audio again. Decoder fails.
-  EXPECT_EQ(NetEq::kFail, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kFail, neteq_->GetAudio(&output));
   EXPECT_EQ(NetEq::kDecoderErrorCode, neteq_->LastError());
   EXPECT_EQ(kDecoderErrorCode, neteq_->LastDecoderError());
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
-  // TODO(minyue): should NetEq better give kOutputPLC, since it is actually an
-  // expansion.
-  EXPECT_EQ(kOutputCNG, type);
+  // We are not expecting anything for output.speech_type_, since an error was
+  // returned.
 
   // Pull audio again, should resume codec CNG.
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &type));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
-  EXPECT_EQ(kOutputCNG, type);
+  EXPECT_EQ(AudioFrame::kCNG, output.speech_type_);
 
   EXPECT_CALL(mock_decoder, Die());
 }