NetEq: Add functionality to assist with delay analysis and tooling

webrtc/modules/audio_coding/neteq/neteq_impl.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 346 matching lines @@
 int NetEqImpl::LeastRequiredDelayMs() const {
   rtc::CritScope lock(&crit_sect_);
   assert(delay_manager_.get());
   return delay_manager_->least_required_delay_ms();
 }
 
 int NetEqImpl::SetTargetDelay() {
   return kNotImplemented;
 }
 
-int NetEqImpl::TargetDelay() {
-  return kNotImplemented;
+int NetEqImpl::TargetDelayMs() {
+  rtc::CritScope lock(&crit_sect_);
+  RTC_DCHECK(delay_manager_.get());
+  // The value from TargetLevel() is in number of packets, represented in Q8.
+  const size_t target_delay_samples =
+      (delay_manager_->TargetLevel() * decoder_frame_length_) >> 8;
+  return static_cast<int>(target_delay_samples) /
+         rtc::CheckedDivExact(fs_hz_, 1000);
 }
 
 int NetEqImpl::CurrentDelayMs() const {
   rtc::CritScope lock(&crit_sect_);
   if (fs_hz_ == 0)
     return 0;
   // Sum up the samples in the packet buffer with the future length of the sync
   // buffer, and divide the sum by the sample rate.
   const size_t delay_samples =
       packet_buffer_->NumSamplesInBuffer(decoder_frame_length_) +
@@ skipping 183 matching lines @@
 
 std::vector<uint16_t> NetEqImpl::GetNackList(int64_t round_trip_time_ms) const {
   rtc::CritScope lock(&crit_sect_);
   if (!nack_enabled_) {
     return std::vector<uint16_t>();
   }
   RTC_DCHECK(nack_.get());
   return nack_->GetNackList(round_trip_time_ms);
 }
 
+std::vector<uint32_t> NetEqImpl::LastDecodedTimestamps() const {
+  rtc::CritScope lock(&crit_sect_);
+  return last_decoded_timestamps_;
+}
+
+size_t NetEqImpl::SyncBufferSizeMs() const {
+  rtc::CritScope lock(&crit_sect_);
+  return sync_buffer_->FutureLength() / rtc::CheckedDivExact(fs_hz_, 1000);
+}
+
 const SyncBuffer* NetEqImpl::sync_buffer_for_test() const {
   rtc::CritScope lock(&crit_sect_);
   return sync_buffer_.get();
 }
 
 Operations NetEqImpl::last_operation_for_test() const {
   rtc::CritScope lock(&crit_sect_);
   return last_operation_;
 }
 
@@ skipping 284 matching lines @@
   }
   return 0;
 }
 
 int NetEqImpl::GetAudioInternal(AudioFrame* audio_frame, bool* muted) {
   PacketList packet_list;
   DtmfEvent dtmf_event;
   Operations operation;
   bool play_dtmf;
   *muted = false;
+  last_decoded_timestamps_.clear();
   tick_timer_->Increment();
   stats_.IncreaseCounter(output_size_samples_, fs_hz_);
 
   // Check for muted state.
   if (enable_muted_state_ && expand_->Muted() && packet_buffer_->Empty()) {
     RTC_DCHECK_EQ(last_mode_, kModeExpand);
     playout_timestamp_ += static_cast<uint32_t>(output_size_samples_);
     audio_frame->sample_rate_hz_ = fs_hz_;
     audio_frame->samples_per_channel_ = output_size_samples_;
     audio_frame->timestamp_ =
@@ skipping 605 matching lines @@
       LOG(LS_WARNING) << "Decoded too much CNG.";
       return kDecodedTooMuch;
     }
   }
   return 0;
 }
 
 int NetEqImpl::DecodeLoop(PacketList* packet_list, const Operations& operation,
                           AudioDecoder* decoder, int* decoded_length,
                           AudioDecoder::SpeechType* speech_type) {
+  RTC_DCHECK(last_decoded_timestamps_.empty());

[ivoc, 2017/04/26 12:23:43]

Couldn't this function be called back-to-back without any calls to
GetAudioInternal in between?

[hlundin-webrtc, 2017/04/26 14:11:38]

I hope not.

NetEqImpl::GetAudioInternal calls NetEqImpl::Decode at most one time.
NetEqImpl::Decode calls NetEqImpl::DecodeLoop at most one time.

+
   // Do decoding.
   while (
       !packet_list->empty() &&
       !decoder_database_->IsComfortNoise(packet_list->front().payload_type)) {
     assert(decoder);  // At this point, we must have a decoder object.
     // The number of channels in the |sync_buffer_| should be the same as the
     // number decoder channels.
     assert(sync_buffer_->Channels() == decoder->Channels());
     assert(decoded_buffer_length_ >= kMaxFrameSize * decoder->Channels());
     assert(operation == kNormal || operation == kAccelerate ||
            operation == kFastAccelerate || operation == kMerge ||
            operation == kPreemptiveExpand);
 
     auto opt_result = packet_list->front().frame->Decode(
         rtc::ArrayView<int16_t>(&decoded_buffer_[*decoded_length],
                                 decoded_buffer_length_ - *decoded_length));
+    last_decoded_timestamps_.push_back(packet_list->front().timestamp);
     packet_list->pop_front();
     if (opt_result) {
       const auto& result = *opt_result;
       *speech_type = result.speech_type;
       if (result.num_decoded_samples > 0) {
         *decoded_length += rtc::dchecked_cast<int>(result.num_decoded_samples);
         // Update |decoder_frame_length_| with number of samples per channel.
         decoder_frame_length_ =
             result.num_decoded_samples / decoder->Channels();
       }
@@ skipping 622 matching lines @@
   }
 }
 
 void NetEqImpl::CreateDecisionLogic() {
   decision_logic_.reset(DecisionLogic::Create(
       fs_hz_, output_size_samples_, playout_mode_, decoder_database_.get(),
       *packet_buffer_.get(), delay_manager_.get(), buffer_level_filter_.get(),
       tick_timer_.get()));
 }
 }  // namespace webrtc