NetEq::GetPlayoutTimestamp returns empty during CNG

webrtc/modules/audio_coding/neteq/neteq_unittest.cc

 /*
  *  Copyright (c) 2011 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 298 matching lines @@
                 bool expect_seq_no_wrap, bool expect_timestamp_wrap);
 
   void LongCngWithClockDrift(double drift_factor,
                              double network_freeze_ms,
                              bool pull_audio_during_freeze,
                              int delay_tolerance_ms,
                              int max_time_to_speech_ms);
 
   void DuplicateCng();
 
-  uint32_t PlayoutTimestamp();
+  rtc::Optional<uint32_t> PlayoutTimestamp();
 
   NetEq* neteq_;
   NetEq::Config config_;
   std::unique_ptr<test::RtpFileSource> rtp_source_;
   std::unique_ptr<test::Packet> packet_;
   unsigned int sim_clock_;
   AudioFrame out_frame_;
   int output_sample_rate_;
   int algorithmic_delay_ms_;
 };
@@ skipping 383 matching lines @@
       ++seq_no;
       timestamp += kSamples;
       next_input_time_ms += static_cast<double>(kFrameSizeMs) * drift_factor;
     }
     // Pull out data once.
     ASSERT_EQ(0, neteq_->GetAudio(&out_frame_));
     ASSERT_EQ(kBlockSize16kHz, out_frame_.samples_per_channel_);
   }
 
   EXPECT_EQ(AudioFrame::kNormalSpeech, out_frame_.speech_type_);
-  int32_t delay_before = timestamp - PlayoutTimestamp();
+  rtc::Optional<uint32_t> playout_timestamp = PlayoutTimestamp();
+  ASSERT_TRUE(playout_timestamp);
+  int32_t delay_before = timestamp - *playout_timestamp;
 
   // Insert CNG for 1 minute (= 60000 ms).
   const int kCngPeriodMs = 100;
   const int kCngPeriodSamples = kCngPeriodMs * 16;  // Period in 16 kHz samples.
   const int kCngDurationMs = 60000;
   for (; t_ms < kSpeechDurationMs + kCngDurationMs; t_ms += 10) {
     // Each turn in this for loop is 10 ms.
     while (next_input_time_ms <= t_ms) {
       // Insert one CNG frame each 100 ms.
       uint8_t payload[kPayloadBytes];
@@ skipping 69 matching lines @@
     // Pull out data once.
     ASSERT_EQ(0, neteq_->GetAudio(&out_frame_));
     ASSERT_EQ(kBlockSize16kHz, out_frame_.samples_per_channel_);
     // Increase clock.
     t_ms += 10;
   }
 
   // Check that the speech starts again within reasonable time.
   double time_until_speech_returns_ms = t_ms - speech_restart_time_ms;
   EXPECT_LT(time_until_speech_returns_ms, max_time_to_speech_ms);
-  int32_t delay_after = timestamp - PlayoutTimestamp();
+  playout_timestamp = PlayoutTimestamp();
+  ASSERT_TRUE(playout_timestamp);
+  int32_t delay_after = timestamp - *playout_timestamp;
   // Compare delay before and after, and make sure it differs less than 20 ms.
   EXPECT_LE(delay_after, delay_before + delay_tolerance_ms * 16);
   EXPECT_GE(delay_after, delay_before - delay_tolerance_ms * 16);
 }
 
 TEST_F(NetEqDecodingTest, LongCngWithNegativeClockDrift) {
   // Apply a clock drift of -25 ms / s (sender faster than receiver).
   const double kDriftFactor = 1000.0 / (1000.0 + 25.0);
   const double kNetworkFreezeTimeMs = 0.0;
   const bool kGetAudioDuringFreezeRecovery = false;
@@ skipping 582 matching lines @@
       seq_no_wrapped |= seq_no < last_seq_no;
       timestamp_wrapped |= timestamp < last_timestamp;
     }
     // Pull out data once.
     AudioFrame output;
     ASSERT_EQ(0, neteq_->GetAudio(&output));
     ASSERT_EQ(kBlockSize16kHz, output.samples_per_channel_);
     ASSERT_EQ(1u, output.num_channels_);
 
     // Expect delay (in samples) to be less than 2 packets.
-    EXPECT_LE(timestamp - PlayoutTimestamp(),
+    rtc::Optional<uint32_t> playout_timestamp = PlayoutTimestamp();
+    ASSERT_TRUE(playout_timestamp);
+    EXPECT_LE(timestamp - *playout_timestamp,
               static_cast<uint32_t>(kSamples * 2));
   }
   // Make sure we have actually tested wrap-around.
   ASSERT_EQ(expect_seq_no_wrap, seq_no_wrapped);
   ASSERT_EQ(expect_timestamp_wrap, timestamp_wrapped);
 }
 
 TEST_F(NetEqDecodingTest, SequenceNumberWrap) {
   // Start with a sequence number that will soon wrap.
   std::set<uint16_t> drop_seq_numbers;  // Don't drop any packets.
@@ skipping 55 matching lines @@
   PopulateCng(seq_no, timestamp, &rtp_info, payload, &payload_len);
   // This is the first time this CNG packet is inserted.
   ASSERT_EQ(
       0, neteq_->InsertPacket(
              rtp_info, rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
 
   // Pull audio once and make sure CNG is played.
   ASSERT_EQ(0, neteq_->GetAudio(&out_frame_));
   ASSERT_EQ(kBlockSize16kHz, out_frame_.samples_per_channel_);
   EXPECT_EQ(AudioFrame::kCNG, out_frame_.speech_type_);
-  EXPECT_EQ(timestamp - algorithmic_delay_samples, PlayoutTimestamp());
+  EXPECT_FALSE(PlayoutTimestamp());  // Returns empty value during CNG.
+  EXPECT_EQ(timestamp - algorithmic_delay_samples,
+            out_frame_.timestamp_ + out_frame_.samples_per_channel_);

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

Curious. Is it important that out_frame_.timestamp_ stays?

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

Since AudioFrame::timestamp_ is not an rtc::Optional, we must provide a value
also during CNG periods. (Changing the AudioFrame implementation is beyond the
scope of this work.) So, AudioFrame::timestamp_ retains the old behavior of
NetEq::GetPlayoutTimestamp(), i.e., the timstamp is not updated during CNG. This
test verifies that too.

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

Should it not updated during CNG?  What Is that timestamp used for?

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

It is currently not used at all (iirc), but since the timestamp_ field is
available in the AudioFrame, and it has a clear meaning in this context, I
thought it was just as well to populate it. But currently it is not updated
during CNG, just like PlayoutTimestamp used not to be (now it is empty instead
during CNG).

 
   // Insert the same CNG packet again. Note that at this point it is old, since
   // we have already decoded the first copy of it.
   ASSERT_EQ(
       0, neteq_->InsertPacket(
              rtp_info, rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
 
   // Pull audio until we have played |kCngPeriodMs| of CNG. Start at 10 ms since
   // we have already pulled out CNG once.
   for (int cng_time_ms = 10; cng_time_ms < kCngPeriodMs; cng_time_ms += 10) {
     ASSERT_EQ(0, neteq_->GetAudio(&out_frame_));
     ASSERT_EQ(kBlockSize16kHz, out_frame_.samples_per_channel_);
     EXPECT_EQ(AudioFrame::kCNG, out_frame_.speech_type_);
+    EXPECT_FALSE(PlayoutTimestamp());  // Returns empty value during CNG.
     EXPECT_EQ(timestamp - algorithmic_delay_samples,
-              PlayoutTimestamp());
+              out_frame_.timestamp_ + out_frame_.samples_per_channel_);
   }
 
   // Insert speech again.
   ++seq_no;
   timestamp += kCngPeriodSamples;
   PopulateRtpInfo(seq_no, timestamp, &rtp_info);
   ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
 
   // Pull audio once and verify that the output is speech again.
   ASSERT_EQ(0, neteq_->GetAudio(&out_frame_));
   ASSERT_EQ(kBlockSize16kHz, out_frame_.samples_per_channel_);
   EXPECT_EQ(AudioFrame::kNormalSpeech, out_frame_.speech_type_);
+  rtc::Optional<uint32_t> playout_timestamp = PlayoutTimestamp();
+  ASSERT_TRUE(playout_timestamp);
   EXPECT_EQ(timestamp + kSamples - algorithmic_delay_samples,
-            PlayoutTimestamp());
+            *playout_timestamp);
 }
 
-uint32_t NetEqDecodingTest::PlayoutTimestamp() {
-  rtc::Optional<uint32_t> playout_timestamp = neteq_->GetPlayoutTimestamp();
-  EXPECT_TRUE(playout_timestamp);
-  return playout_timestamp.value_or(0);
+rtc::Optional<uint32_t> NetEqDecodingTest::PlayoutTimestamp() {
+  return neteq_->GetPlayoutTimestamp();
 }
 
 TEST_F(NetEqDecodingTest, DiscardDuplicateCng) { DuplicateCng(); }
 
 TEST_F(NetEqDecodingTest, CngFirst) {
   uint16_t seq_no = 0;
   uint32_t timestamp = 0;
   const int kFrameSizeMs = 10;
   const int kSampleRateKhz = 16;
   const int kSamples = kFrameSizeMs * kSampleRateKhz;
@@ skipping 26 matching lines @@
     timestamp += kSamples;
 
     // Pull audio once.
     ASSERT_EQ(0, neteq_->GetAudio(&out_frame_));
     ASSERT_EQ(kBlockSize16kHz, out_frame_.samples_per_channel_);
   }
   // Verify speech output.
   EXPECT_EQ(AudioFrame::kNormalSpeech, out_frame_.speech_type_);
 }
 }  // namespace webrtc