NetEq::GetPlayoutTimestamp returns empty during CNG

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 648 matching lines @@
   rtp_header.header.sequenceNumber = 0x1234;
   rtp_header.header.timestamp = 0x12345678;
   rtp_header.header.ssrc = 0x87654321;
 
   // Create a mock decoder object.
   MockAudioDecoder mock_decoder;
   EXPECT_CALL(mock_decoder, Reset()).WillRepeatedly(Return());
   EXPECT_CALL(mock_decoder, Channels()).WillRepeatedly(Return(1));
   EXPECT_CALL(mock_decoder, IncomingPacket(_, kPayloadLengthBytes, _, _, _))
       .WillRepeatedly(Return(0));
+  EXPECT_CALL(mock_decoder, PacketDuration(_, kPayloadLengthBytes))

[hlundin-webrtc, 2016/04/06 11:13:58]

These new EXPEC_CALLs are unrelated to this CL, but I added them to silence a
noisy test output.

+      .WillRepeatedly(Return(kPayloadLengthSamples));
+  // Packed duration when asking the decoder for more CNG data (without a new
+  // packet).
+  EXPECT_CALL(mock_decoder, PacketDuration(nullptr, 0))
+      .WillRepeatedly(Return(kPayloadLengthSamples));
 
   // Pointee(x) verifies that first byte of the payload equals x, this makes it
   // possible to verify that the correct payload is fed to Decode().
   EXPECT_CALL(mock_decoder, DecodeInternal(Pointee(0), kPayloadLengthBytes,
                                            kSampleRateKhz * 1000, _, _))
       .WillOnce(DoAll(SetArrayArgument<3>(dummy_output,
                                           dummy_output + kPayloadLengthSamples),
                       SetArgPointee<4>(AudioDecoder::kSpeech),
                       Return(kPayloadLengthSamples)));
 
@@ skipping 34 matching lines @@
             neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
 
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateKhz);
   AudioFrame output;
   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] = {

[minyue-webrtc, 2016/04/06 13:39:42]

Is there a better to change this.

[hlundin-webrtc, 2016/04/06 15:27:56]

How about now?

       -1,  // will not be used.
       10 * kSampleRateKhz,
       0, 0,  // timestamp does not increase during CNG mode.
       0, 0,
       50 * kSampleRateKhz, 10 * kSampleRateKhz
   };
 
   EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
   rtc::Optional<uint32_t> last_timestamp = neteq_->GetPlayoutTimestamp();
   ASSERT_TRUE(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], output.speech_type_);
+    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
     rtc::Optional<uint32_t> timestamp = neteq_->GetPlayoutTimestamp();
-    EXPECT_TRUE(timestamp);
-    EXPECT_EQ(NetEq::kOK, neteq_->GetAudio(&output));
-    timestamp = neteq_->GetPlayoutTimestamp();
-    ASSERT_TRUE(timestamp);
-    EXPECT_EQ(*timestamp, *last_timestamp + expected_timestamp_increment[i]);
-    last_timestamp = timestamp;
+    if (output.speech_type_ == AudioFrame::kNormalSpeech) {
+      ASSERT_TRUE(timestamp);
+      EXPECT_EQ(*timestamp, *last_timestamp + expected_timestamp_increment[i]);
+      last_timestamp = timestamp;
+    } else {
+      // Expect to get an empty timestamp value during CNG and PLC.
+      EXPECT_FALSE(timestamp);
+    }
   }
 
   // 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) {
@@ skipping 422 matching lines @@
 // 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());
 }
 
 }// namespace webrtc