Calculate JitterBufferDelayInMs in the new jitter buffer.

webrtc/modules/video_coding/frame_buffer2.cc

 /*
  *  Copyright (c) 2016 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 27 matching lines @@
     : clock_(clock),
       new_countinuous_frame_event_(false, false),
       jitter_estimator_(jitter_estimator),
       timing_(timing),
       inter_frame_delay_(clock_->TimeInMilliseconds()),
       last_decoded_frame_it_(frames_.end()),
       last_continuous_frame_it_(frames_.end()),
       num_frames_history_(0),
       num_frames_buffered_(0),
       stopped_(false),
-      protection_mode_(kProtectionNack),
-      num_total_frames_(0),
-      num_key_frames_(0) {}
+      protection_mode_(kProtectionNack) {}
 
 FrameBuffer::~FrameBuffer() {
   UpdateHistograms();
 }
 
 FrameBuffer::ReturnReason FrameBuffer::NextFrame(
     int64_t max_wait_time_ms,
     std::unique_ptr<FrameObject>* frame_out) {
   int64_t latest_return_time = clock_->TimeInMilliseconds() + max_wait_time_ms;
   int64_t wait_ms = max_wait_time_ms;
@@ skipping 65 matching lines @@
     int64_t frame_delay;
     if (inter_frame_delay_.CalculateDelay(timestamp, &frame_delay,
                                           received_time)) {
       jitter_estimator_->UpdateEstimate(frame_delay, frame->size());
     }
     float rtt_mult = protection_mode_ == kProtectionNackFEC ? 0.0 : 1.0;
     timing_->SetJitterDelay(jitter_estimator_->GetJitterEstimate(rtt_mult));
     timing_->UpdateCurrentDelay(frame->RenderTime(),
                                 clock_->TimeInMilliseconds());
 
+    UpdateJitterDelay();
+
     PropagateDecodability(next_frame_it->second);
     AdvanceLastDecodedFrame(next_frame_it);
     *frame_out = std::move(frame);
     return kFrameFound;
   } else {
     return kTimeout;
   }
 }
 
 void FrameBuffer::SetProtectionMode(VCMVideoProtection mode) {
@@ skipping 211 matching lines @@
     RTC_DCHECK_LE(ref_info->second.num_missing_continuous,
                   ref_info->second.num_missing_decodable);
   }
 
   RTC_DCHECK_LE(info->second.num_missing_continuous,
                 info->second.num_missing_decodable);
 
   return true;
 }
 
+void FrameBuffer::UpdateJitterDelay() {
+  int unused;
+  int delay;
+  timing_->GetTimings(&unused, &unused, &unused, &unused, &delay, &unused,
+                      &unused);
+
+  accumulated_delay_ += delay;
+  ++accumulated_delay_samples_;
+}
+
 void FrameBuffer::UpdateHistograms() const {
   rtc::CritScope lock(&crit_);
   if (num_total_frames_ > 0) {
     int key_frames_permille = (static_cast<float>(num_key_frames_) * 1000.0f /
                                    static_cast<float>(num_total_frames_) +
                                0.5f);
     RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.KeyFramesReceivedInPermille",
                               key_frames_permille);
   }
+
+  if (accumulated_delay_samples_ > 0) {
+    RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.JitterBufferDelayInMs",
+                               accumulated_delay_ / accumulated_delay_samples_);
+  }
 }
 
 }  // namespace video_coding
 }  // namespace webrtc