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))
+      .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 37 matching lines @@
   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] = {
       -1,  // will not be used.
       10 * kSampleRateKhz,
-      0, 0,  // timestamp does not increase during CNG mode.
-      0, 0,
+      -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));
   rtc::Optional<uint32_t> last_timestamp = neteq_->GetPlayoutTimestamp();
   ASSERT_TRUE(last_timestamp);
 
+  // Lambda for verifying the timestamps.

[minyue-webrtc, 2016/04/06 18:13:07]

I like it

+  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_);
-    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;
+    SCOPED_TRACE("");

[minyue-webrtc, 2016/04/06 18:13:07]

what does this do?

[hlundin-webrtc, 2016/04/06 18:21:39]

If a failure happens in the lambda, a printout will be triggered from this
SCOPED_TRACE, too. Like this:

../../webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc:750: Failure
Value of: ts
  Actual: false
Expected: true
i = 2
Google Test trace:
../../webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc:762: 

That is, you get one line number from within the lambda (750 in this example),
but also a line number from this SCOPED_TRACE (762), which helps the user figure
out which invokation of the lambda failed. (You can also provide a string to
print to the SCOPED_TRACE, but I thought that didn't help in this case.)

+    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));
-    rtc::Optional<uint32_t> timestamp = neteq_->GetPlayoutTimestamp();
-    ASSERT_TRUE(timestamp);
-    EXPECT_EQ(*timestamp, *last_timestamp + expected_timestamp_increment[i]);
-    last_timestamp = timestamp;
+    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());
 }
 
 TEST_F(NetEqImplTest, UnsupportedDecoder) {
   UseNoMocks();
@@ skipping 404 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