NetEq: Implement muted output

webrtc/modules/audio_coding/neteq/neteq_impl_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 423 matching lines @@
                             &decoder_, NetEqDecoder::kDecoderPCM16B,
                             "dummy name", kPayloadType, kSampleRateHz));
 
   // Insert one packet.
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
 
   // Pull audio once.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   AudioFrame output;
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
+  ASSERT_FALSE(muted);
   ASSERT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
   EXPECT_EQ(AudioFrame::kNormalSpeech, output.speech_type_);
 
   // Start with a simple check that the fake decoder is behaving as expected.
   EXPECT_EQ(kPayloadLengthSamples,
             static_cast<size_t>(decoder_.next_value() - 1));
 
   // The value of the last of the output samples is the same as the number of
   // samples played from the decoded packet. Thus, this number + the RTP
@@ skipping 56 matching lines @@
                             &mock_decoder, NetEqDecoder::kDecoderPCM16B,
                             "dummy name", kPayloadType, kSampleRateHz));
 
   // Insert one packet.
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
 
   // Pull audio once.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   AudioFrame output;
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
   ASSERT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
   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.
   rtp_header.header.sequenceNumber -= 1;
   rtp_header.header.timestamp -= kPayloadLengthSamples;
   payload[0] = 1;
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
   rtp_header.header.sequenceNumber += 2;
   rtp_header.header.timestamp += 2 * kPayloadLengthSamples;
   payload[0] = 2;
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
 
   // Expect only the second packet to be decoded (the one with "2" as the first
   // payload byte).
   EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(2), kPayloadLengthBytes,
                                            kSampleRateHz, _, _))
       .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
                                           dummy_output + kPayloadLengthSamples),
                       SetArgPointee<4>(AudioDecoder::kSpeech),
                       Return(kPayloadLengthSamples)));
 
   // Pull audio once.
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
   ASSERT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
   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.
   EXPECT_TRUE(packet_buffer_->Empty());
 
   EXPECT_CALL(mock_decoder, Die());
 }
@@ skipping 19 matching lines @@
 
   // Insert one packet. Note that we have not registered any payload type, so
   // this packet will be rejected.
   EXPECT_EQ(NetEq::kFail,
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
   EXPECT_EQ(NetEq::kUnknownRtpPayloadType, neteq_->LastError());
 
   // Pull audio once.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   AudioFrame output;
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
   ASSERT_LE(output.samples_per_channel_, kMaxOutputSize);
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
   EXPECT_EQ(AudioFrame::kPLC, output.speech_type_);
 
   // Register the payload type.
   EXPECT_EQ(NetEq::kOK, neteq_->RegisterPayloadType(
                             NetEqDecoder::kDecoderPCM16B, "", kPayloadType));
 
   // Insert 10 packets.
   for (size_t i = 0; i < 10; ++i) {
     rtp_header.header.sequenceNumber++;
     rtp_header.header.timestamp += kPayloadLengthSamples;
     EXPECT_EQ(NetEq::kOK,
               neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
     EXPECT_EQ(i + 1, packet_buffer_->NumPacketsInBuffer());
   }
 
   // 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));
+    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
     ASSERT_LE(output.samples_per_channel_, kMaxOutputSize);
     EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
     EXPECT_EQ(1u, output.num_channels_);
     EXPECT_EQ(AudioFrame::kNormalSpeech, output.speech_type_)
         << "NetEq did not decode the packets as expected.";
   }
 }
 
 // This test verifies that NetEq can handle comfort noise and enters/quits codec
 // internal CNG mode properly.
@@ skipping 83 matching lines @@
       AudioFrame::kNormalSpeech, AudioFrame::kNormalSpeech
   };
   int expected_timestamp_increment[8] = {
       -1,  // will not be used.
       10 * kSampleRateKhz,
       -1, -1,  // timestamp will be empty during CNG mode; indicated by -1 here.
       -1, -1,
       50 * kSampleRateKhz, 10 * kSampleRateKhz
   };
 
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
   rtc::Optional<uint32_t> last_timestamp = neteq_->GetPlayoutTimestamp();
   ASSERT_TRUE(last_timestamp);
 
   // Lambda for verifying the timestamps.
   auto verify_timestamp = [&last_timestamp, &expected_timestamp_increment](
       rtc::Optional<uint32_t> ts, size_t i) {
     if (expected_timestamp_increment[i] == -1) {
       // Expect to get an empty timestamp value during CNG and PLC.
       EXPECT_FALSE(ts) << "i = " << i;
     } else {
       ASSERT_TRUE(ts) << "i = " << i;
       EXPECT_EQ(*ts, *last_timestamp + expected_timestamp_increment[i])
           << "i = " << i;
       last_timestamp = ts;
     }
   };
 
   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], output.speech_type_);
-    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
+    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
     SCOPED_TRACE("");
     verify_timestamp(neteq_->GetPlayoutTimestamp(), i);
   }
 
   // Insert third packet, which leaves a gap from last packet.
   payload[0] = 2;
   rtp_header.header.sequenceNumber += 2;
   rtp_header.header.timestamp += 2 * kPayloadLengthSamples;
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
 
   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], output.speech_type_);
-    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
+    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
     SCOPED_TRACE("");
     verify_timestamp(neteq_->GetPlayoutTimestamp(), i);
   }
 
   // Now check the packet buffer, and make sure it is empty.
   EXPECT_TRUE(packet_buffer_->Empty());
 
   EXPECT_CALL(mock_decoder, Die());
 }
 
@@ skipping 71 matching lines @@
   // Insert another packet.
   payload[0] = kSecondPayloadValue;  // This will make Decode() successful.
   rtp_header.header.sequenceNumber++;
   // The second timestamp needs to be at least 30 ms after the first to make
   // the second packet get decoded.
   rtp_header.header.timestamp += 3 * kPayloadLengthSamples;
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
 
   AudioFrame output;
+  bool muted;
   // First call to GetAudio will try to decode the "faulty" packet.
   // Expect kFail return value...
-  EXPECT_EQ(NetEq::kFail, neteq_->GetAudio(&output));
+  EXPECT_EQ(NetEq::kFail, neteq_->GetAudio(&output, &muted));
   // ... and kOtherDecoderError error code.
   EXPECT_EQ(NetEq::kOtherDecoderError, neteq_->LastError());
   // Output size and number of channels should be correct.
   const size_t kExpectedOutputSize = 10 * (kSampleRateHz / 1000) * kChannels;
   EXPECT_EQ(kExpectedOutputSize, output.samples_per_channel_ * kChannels);
   EXPECT_EQ(kChannels, output.num_channels_);
 
   // Second call to GetAudio will decode the packet that is ok. No errors are
   // expected.
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
   EXPECT_EQ(kExpectedOutputSize, output.samples_per_channel_ * kChannels);
   EXPECT_EQ(kChannels, output.num_channels_);
 }
 
 // This test inserts packets until the buffer is flushed. After that, it asks
 // NetEq for the network statistics. The purpose of the test is to make sure
 // that even though the buffer size increment is negative (which it becomes when
 // the packet causing a flush is inserted), the packet length stored in the
 // decision logic remains valid.
 TEST_F(NetEqImplTest, FloodBufferAndGetNetworkStats) {
@@ skipping 72 matching lines @@
 
   // Insert one packet.
   EXPECT_EQ(NetEq::kOK,
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
 
   EXPECT_EQ(5u, neteq_->sync_buffer_for_test()->FutureLength());
 
   // Pull audio once.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   AudioFrame output;
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
   ASSERT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
   EXPECT_EQ(AudioFrame::kNormalSpeech, output.speech_type_);
 
   EXPECT_CALL(mock_decoder, Die());
 }
 
 // This test checks the behavior of NetEq when audio decoder fails.
 TEST_F(NetEqImplTest, DecodingError) {
   UseNoMocks();
@@ skipping 71 matching lines @@
   for (int i = 0; i < 6; ++i) {
     rtp_header.header.sequenceNumber += 1;
     rtp_header.header.timestamp += kFrameLengthSamples;
     EXPECT_EQ(NetEq::kOK,
               neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
   }
 
   // Pull audio.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   AudioFrame output;
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
   EXPECT_EQ(AudioFrame::kNormalSpeech, output.speech_type_);
 
   // Pull audio again. Decoder fails.
-  EXPECT_EQ(NetEq::kFail, neteq_->GetAudio(&output));
+  EXPECT_EQ(NetEq::kFail, neteq_->GetAudio(&output, &muted));
   EXPECT_EQ(NetEq::kDecoderErrorCode, neteq_->LastError());
   EXPECT_EQ(kDecoderErrorCode, neteq_->LastDecoderError());
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
   // 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));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
   EXPECT_EQ(AudioFrame::kPLC, output.speech_type_);
 
   // Pull audio again, should behave normal.
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
   EXPECT_EQ(AudioFrame::kNormalSpeech, output.speech_type_);
 
   EXPECT_CALL(mock_decoder, Die());
 }
 
 // This test checks the behavior of NetEq when audio decoder fails during CNG.
 TEST_F(NetEqImplTest, DecodingErrorDuringInternalCng) {
   UseNoMocks();
@@ skipping 67 matching lines @@
   for (int i = 0; i < 2; ++i) {
     rtp_header.header.sequenceNumber += 1;
     rtp_header.header.timestamp += kFrameLengthSamples;
     EXPECT_EQ(NetEq::kOK,
               neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
   }
 
   // Pull audio.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
   AudioFrame output;
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
   EXPECT_EQ(AudioFrame::kCNG, output.speech_type_);
 
   // Pull audio again. Decoder fails.
-  EXPECT_EQ(NetEq::kFail, neteq_->GetAudio(&output));
+  EXPECT_EQ(NetEq::kFail, neteq_->GetAudio(&output, &muted));
   EXPECT_EQ(NetEq::kDecoderErrorCode, neteq_->LastError());
   EXPECT_EQ(kDecoderErrorCode, neteq_->LastDecoderError());
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
   // 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));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
   EXPECT_EQ(kMaxOutputSize, output.samples_per_channel_);
   EXPECT_EQ(1u, output.num_channels_);
   EXPECT_EQ(AudioFrame::kCNG, output.speech_type_);
 
   EXPECT_CALL(mock_decoder, Die());
 }
 
 // Tests that the return value from last_output_sample_rate_hz() is equal to the
 // configured inital sample rate.
 TEST_F(NetEqImplTest, InitialLastOutputSampleRate) {
   UseNoMocks();
   config_.sample_rate_hz = 48000;
   CreateInstance();
   EXPECT_EQ(48000, neteq_->last_output_sample_rate_hz());
 }
 
 TEST_F(NetEqImplTest, TickTimerIncrement) {
   UseNoMocks();
   CreateInstance();
   ASSERT_TRUE(tick_timer_);
   EXPECT_EQ(0u, tick_timer_->ticks());
   AudioFrame output;
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output, &muted));
   EXPECT_EQ(1u, tick_timer_->ticks());
 }
 
 class Decoder120ms : public AudioDecoder {
  public:
   Decoder120ms(SpeechType speech_type)
       : next_value_(1),
         speech_type_(speech_type) {}
 
   int DecodeInternal(const uint8_t* encoded,
@@ skipping 34 matching lines @@
     CreateInstance();
   }
 
   uint32_t timestamp_diff_between_packets() const {
     return rtc::CheckedDivExact(kSamplingFreq_, 1000u) * 120;
   }
 
   uint32_t first_timestamp() const { return 10u; }
 
   void GetFirstPacket() {
+    bool muted;
     for (int i = 0; i < 12; i++) {
-      EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_));
+      EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_, &muted));
+      EXPECT_FALSE(muted);
     }
   }
 
   void InsertPacket(uint32_t timestamp) {
     WebRtcRTPHeader rtp_header;
     rtp_header.header.payloadType = kPayloadType;
     rtp_header.header.sequenceNumber = sequence_number_;
     rtp_header.header.timestamp = timestamp;
     rtp_header.header.ssrc = 15;
     const size_t kPayloadLengthBytes = 1;  // This can be arbitrary.
@@ skipping 18 matching lines @@
 };
 
 TEST_F(NetEqImplTest120ms, AudioRepetition) {
   config_.playout_mode = kPlayoutFax;
   CreateInstanceNoMocks();
   Register120msCodec(AudioDecoder::kSpeech);
 
   InsertPacket(first_timestamp());
   GetFirstPacket();
 
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_, &muted));
   EXPECT_EQ(kAudioRepetition, neteq_->last_operation_for_test());
 }
 
 TEST_F(NetEqImplTest120ms, AlternativePlc) {
   config_.playout_mode = kPlayoutOff;
   CreateInstanceNoMocks();
   Register120msCodec(AudioDecoder::kSpeech);
 
   InsertPacket(first_timestamp());
   GetFirstPacket();
 
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_, &muted));
   EXPECT_EQ(kAlternativePlc, neteq_->last_operation_for_test());
 }
 
 TEST_F(NetEqImplTest120ms, CodecInternalCng) {
   CreateInstanceNoMocks();
   Register120msCodec(AudioDecoder::kComfortNoise);
 
   InsertPacket(first_timestamp());
   GetFirstPacket();
 
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_, &muted));
   EXPECT_EQ(kCodecInternalCng, neteq_->last_operation_for_test());
 }
 
 TEST_F(NetEqImplTest120ms, Normal) {
   CreateInstanceNoMocks();
   Register120msCodec(AudioDecoder::kSpeech);
 
   InsertPacket(first_timestamp());
   GetFirstPacket();
 
   EXPECT_EQ(kNormal, neteq_->last_operation_for_test());
 }
 
 TEST_F(NetEqImplTest120ms, Merge) {
   CreateInstanceWithDelayManagerMock();
 
   Register120msCodec(AudioDecoder::kSpeech);
   InsertPacket(first_timestamp());
 
   GetFirstPacket();
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_, &muted));
 
   InsertPacket(first_timestamp() + 2 * timestamp_diff_between_packets());
 
   // Delay manager reports a target level which should cause a Merge.
   EXPECT_CALL(*mock_delay_manager_, TargetLevel()).WillOnce(Return(-10));
 
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_));
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_, &muted));
   EXPECT_EQ(kMerge, neteq_->last_operation_for_test());
 }
 
 TEST_F(NetEqImplTest120ms, Expand) {
   CreateInstanceNoMocks();
   Register120msCodec(AudioDecoder::kSpeech);
 
   InsertPacket(first_timestamp());
   GetFirstPacket();
 
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_, &muted));
   EXPECT_EQ(kExpand, neteq_->last_operation_for_test());
 }
 
 TEST_F(NetEqImplTest120ms, FastAccelerate) {
   CreateInstanceWithDelayManagerMock();
   Register120msCodec(AudioDecoder::kSpeech);
 
   InsertPacket(first_timestamp());
   GetFirstPacket();
   InsertPacket(first_timestamp() + timestamp_diff_between_packets());
 
   // Delay manager report buffer limit which should cause a FastAccelerate.
   EXPECT_CALL(*mock_delay_manager_, BufferLimits(_, _))
       .Times(1)
       .WillOnce(DoAll(SetArgPointee<0>(0), SetArgPointee<1>(0)));
 
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_, &muted));
   EXPECT_EQ(kFastAccelerate, neteq_->last_operation_for_test());
 }
 
 TEST_F(NetEqImplTest120ms, PreemptiveExpand) {
   CreateInstanceWithDelayManagerMock();
   Register120msCodec(AudioDecoder::kSpeech);
 
   InsertPacket(first_timestamp());
   GetFirstPacket();
 
   InsertPacket(first_timestamp() + timestamp_diff_between_packets());
 
   // Delay manager report buffer limit which should cause a PreemptiveExpand.
   EXPECT_CALL(*mock_delay_manager_, BufferLimits(_, _))
       .Times(1)
       .WillOnce(DoAll(SetArgPointee<0>(100), SetArgPointee<1>(100)));
 
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_, &muted));
   EXPECT_EQ(kPreemptiveExpand, neteq_->last_operation_for_test());
 }
 
 TEST_F(NetEqImplTest120ms, Accelerate) {
   CreateInstanceWithDelayManagerMock();
   Register120msCodec(AudioDecoder::kSpeech);
 
   InsertPacket(first_timestamp());
   GetFirstPacket();
 
   InsertPacket(first_timestamp() + timestamp_diff_between_packets());
 
   // Delay manager report buffer limit which should cause a Accelerate.
   EXPECT_CALL(*mock_delay_manager_, BufferLimits(_, _))
       .Times(1)
       .WillOnce(DoAll(SetArgPointee<0>(1), SetArgPointee<1>(2)));
 
-  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_));
+  bool muted;
+  EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output_, &muted));
   EXPECT_EQ(kAccelerate, neteq_->last_operation_for_test());
 }
 
 }// namespace webrtc