Add average rtt to CallStatsObserver and an average rtt histogram.

webrtc/video_engine/vie_channel.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 32 matching lines @@
 static const int kMaxTargetDelayMs = 10000;
 static const float kMaxIncompleteTimeMultiplier = 3.5f;
 
 // Helper class receiving statistics callbacks.
 class ChannelStatsObserver : public CallStatsObserver {
  public:
   explicit ChannelStatsObserver(ViEChannel* owner) : owner_(owner) {}
   virtual ~ChannelStatsObserver() {}
 
   // Implements StatsObserver.
-  virtual void OnRttUpdate(int64_t rtt) {
-    owner_->OnRttUpdate(rtt);
+  virtual void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
+    owner_->OnRttUpdate(avg_rtt_ms, max_rtt_ms);
   }
 
  private:
   ViEChannel* const owner_;
 };
 
 class ViEChannelProtectionCallback : public VCMProtectionCallback {
  public:
   ViEChannelProtectionCallback(ViEChannel* owner) : owner_(owner) {}
   ~ViEChannelProtectionCallback() {}
@@ skipping 47 matching lines @@
       intra_frame_observer_(intra_frame_observer),
       rtt_stats_(rtt_stats),
       paced_sender_(paced_sender),
       packet_router_(packet_router),
       bandwidth_observer_(bandwidth_observer),
       decoder_reset_(true),
       nack_history_size_sender_(kSendSidePacketHistorySize),
       max_nack_reordering_threshold_(kMaxPacketAgeToNack),
       pre_render_callback_(NULL),
       report_block_stats_sender_(new ReportBlockStats()),
+      time_of_first_rtt_ms_(-1),
+      rtt_sum_ms_(0),
+      num_rtts_(0),
       rtp_rtcp_modules_(
           CreateRtpRtcpModules(ViEModuleId(engine_id_, channel_id_),
                                !sender,
                                vie_receiver_.GetReceiveStatistics(),
                                transport,
                                sender ? intra_frame_observer_ : nullptr,
                                sender ? bandwidth_observer_.get() : nullptr,
                                rtt_stats_,
                                &rtcp_packet_type_counter_observer_,
                                remote_bitrate_estimator,
@@ skipping 57 matching lines @@
   if (decode_thread_) {
     StopDecodeThread();
   }
   // Release modules.
   VideoCodingModule::Destroy(vcm_);
 }
 
 void ViEChannel::UpdateHistograms() {
   int64_t now = Clock::GetRealTimeClock()->TimeInMilliseconds();
 
+  {
+    CriticalSectionScoped cs(crit_.get());
+    int64_t elapsed_sec = (now - time_of_first_rtt_ms_) / 1000;
+    if (time_of_first_rtt_ms_ != -1 && num_rtts_ > 0 &&
+        elapsed_sec > metrics::kMinRunTimeInSeconds) {
+      int64_t avg_rtt_ms = (rtt_sum_ms_ + num_rtts_ / 2) / num_rtts_;
+      RTC_HISTOGRAM_COUNTS_10000(
+          "WebRTC.Video.AverageRoundTripTimeInMilliseconds", avg_rtt_ms);
+    }
+  }
+
   if (sender_) {
     RtcpPacketTypeCounter rtcp_counter;
     GetSendRtcpPacketTypeCounter(&rtcp_counter);
     int64_t elapsed_sec = rtcp_counter.TimeSinceFirstPacketInMs(now) / 1000;
     if (elapsed_sec > metrics::kMinRunTimeInSeconds) {
       RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.NackPacketsReceivedPerMinute",
                                  rtcp_counter.nack_packets * 60 / elapsed_sec);
       RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.FirPacketsReceivedPerMinute",
                                  rtcp_counter.fir_packets * 60 / elapsed_sec);
       RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.PliPacketsReceivedPerMinute",
@@ skipping 876 matching lines @@
 
 bool ViEChannel::ChannelDecodeThreadFunction(void* obj) {
   return static_cast<ViEChannel*>(obj)->ChannelDecodeProcess();
 }
 
 bool ViEChannel::ChannelDecodeProcess() {
   vcm_->Decode(kMaxDecodeWaitTimeMs);
   return true;
 }
 
-void ViEChannel::OnRttUpdate(int64_t rtt) {
-  vcm_->SetReceiveChannelParameters(rtt);
+void ViEChannel::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
+  vcm_->SetReceiveChannelParameters(max_rtt_ms);
+
+  CriticalSectionScoped cs(crit_.get());
+  if (time_of_first_rtt_ms_ == -1)
+    time_of_first_rtt_ms_ = Clock::GetRealTimeClock()->TimeInMilliseconds();
+  rtt_sum_ms_ += avg_rtt_ms;
+  ++num_rtts_;
 }
 
 int ViEChannel::ProtectionRequest(const FecProtectionParams* delta_fec_params,
                                   const FecProtectionParams* key_fec_params,
                                   uint32_t* video_rate_bps,
                                   uint32_t* nack_rate_bps,
                                   uint32_t* fec_rate_bps) {
   *video_rate_bps = 0;
   *nack_rate_bps = 0;
   *fec_rate_bps = 0;
@@ skipping 141 matching lines @@
   CriticalSectionScoped cs(crit_.get());
   vcm_receive_stats_callback_ = receive_statistics_proxy;
 }
 
 void ViEChannel::SetIncomingVideoStream(
     IncomingVideoStream* incoming_video_stream) {
   CriticalSectionScoped cs(crit_.get());
   incoming_video_stream_ = incoming_video_stream;
 }
 }  // namespace webrtc