Use CallStats for RTT in Call, rather than VideoSendStream::GetRtt()

webrtc/video/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 14 matching lines @@
 #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/modules/video_processing/include/video_processing.h"
 #include "webrtc/modules/video_render/video_render_defines.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/video/call_stats.h"
 #include "webrtc/video/payload_router.h"
 #include "webrtc/video/receive_statistics_proxy.h"
-#include "webrtc/video/report_block_stats.h"
 
 namespace webrtc {
 
 const int kMaxDecodeWaitTimeMs = 50;
 static const int kMaxTargetDelayMs = 10000;
 const int kMinSendSidePacketHistorySize = 600;
 const int kMaxPacketAgeToNack = 450;
 const int kMaxNackListSize = 250;
 
 // Helper class receiving statistics callbacks.
@@ skipping 59 matching lines @@
       intra_frame_observer_(intra_frame_observer),
       rtt_stats_(rtt_stats),
       paced_sender_(paced_sender),
       packet_router_(packet_router),
       bandwidth_observer_(bandwidth_observer),
       transport_feedback_observer_(transport_feedback_observer),
       decode_thread_(ChannelDecodeThreadFunction, this, "DecodingThread"),
       nack_history_size_sender_(kMinSendSidePacketHistorySize),
       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),
       last_rtt_ms_(0),
-      num_rtts_(0),
       rtp_rtcp_modules_(
           CreateRtpRtcpModules(!sender,
                                vie_receiver_.GetReceiveStatistics(),
                                transport,
                                intra_frame_observer_,
                                bandwidth_observer_.get(),
                                transport_feedback_observer_,
                                rtt_stats_,
                                &rtcp_packet_type_counter_observer_,
                                remote_bitrate_estimator,
@@ skipping 61 matching lines @@
     module_process_thread_->DeRegisterModule(rtp_rtcp);
     delete rtp_rtcp;
   }
   if (!sender_)
     StopDecodeThread();
 }
 
 void ViEChannel::UpdateHistograms() {
   int64_t now = Clock::GetRealTimeClock()->TimeInMilliseconds();
 
-  {
-    rtc::CritScope lock(&crit_);
-    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",
                                  rtcp_counter.pli_packets * 60 / elapsed_sec);
       if (rtcp_counter.nack_requests > 0) {
         RTC_HISTOGRAM_PERCENTAGE(
             "WebRTC.Video.UniqueNackRequestsReceivedInPercent",
             rtcp_counter.UniqueNackRequestsInPercent());
       }
-      int fraction_lost = report_block_stats_sender_->FractionLostInPercent();
-      if (fraction_lost != -1) {
-        RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.SentPacketsLostInPercent",
-                                 fraction_lost);
-      }
     }
 
     StreamDataCounters rtp;
     StreamDataCounters rtx;
     GetSendStreamDataCounters(&rtp, &rtx);
     StreamDataCounters rtp_rtx = rtp;
     rtp_rtx.Add(rtx);
     elapsed_sec = rtp_rtx.TimeSinceFirstPacketInMs(
                       Clock::GetRealTimeClock()->TimeInMilliseconds()) /
                   1000;
@@ skipping 483 matching lines @@
 int32_t ViEChannel::SetRTCPCName(const char* rtcp_cname) {
   RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending());
   return rtp_rtcp_modules_[0]->SetCNAME(rtcp_cname);
 }
 
 int32_t ViEChannel::GetRemoteRTCPCName(char rtcp_cname[]) {
   uint32_t remoteSSRC = vie_receiver_.GetRemoteSsrc();
   return rtp_rtcp_modules_[0]->RemoteCNAME(remoteSSRC, rtcp_cname);
 }
 
-int32_t ViEChannel::GetSendRtcpStatistics(uint16_t* fraction_lost,
-                                          uint32_t* cumulative_lost,
-                                          uint32_t* extended_max,
-                                          uint32_t* jitter_samples,
-                                          int64_t* rtt_ms) {
-  // Aggregate the report blocks associated with streams sent on this channel.
-  std::vector<RTCPReportBlock> report_blocks;
-  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
-    rtp_rtcp->RemoteRTCPStat(&report_blocks);
-
-  if (report_blocks.empty())
-    return -1;
-
-  uint32_t remote_ssrc = vie_receiver_.GetRemoteSsrc();
-  std::vector<RTCPReportBlock>::const_iterator it = report_blocks.begin();
-  for (; it != report_blocks.end(); ++it) {
-    if (it->remoteSSRC == remote_ssrc)
-      break;
-  }
-  if (it == report_blocks.end()) {
-    // We have not received packets with an SSRC matching the report blocks. To
-    // have a chance of calculating an RTT we will try with the SSRC of the
-    // first report block received.
-    // This is very important for send-only channels where we don't know the
-    // SSRC of the other end.
-    remote_ssrc = report_blocks[0].remoteSSRC;
-  }
-
-  // TODO(asapersson): Change report_block_stats to not rely on
-  // GetSendRtcpStatistics to be called.
-  RTCPReportBlock report =
-      report_block_stats_sender_->AggregateAndStore(report_blocks);
-  *fraction_lost = report.fractionLost;
-  *cumulative_lost = report.cumulativeLost;
-  *extended_max = report.extendedHighSeqNum;
-  *jitter_samples = report.jitter;
-
-  int64_t dummy;
-  int64_t rtt = 0;
-  if (rtp_rtcp_modules_[0]->RTT(remote_ssrc, &rtt, &dummy, &dummy, &dummy) !=
-      0) {
-    return -1;
-  }
-  *rtt_ms = rtt;
-  return 0;
-}
-
 void ViEChannel::RegisterSendChannelRtcpStatisticsCallback(
     RtcpStatisticsCallback* callback) {
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     rtp_rtcp->RegisterRtcpStatisticsCallback(callback);
 }
 
 void ViEChannel::RegisterReceiveChannelRtcpStatisticsCallback(
     RtcpStatisticsCallback* callback) {
   vie_receiver_.GetReceiveStatistics()->RegisterRtcpStatisticsCallback(
       callback);
@@ skipping 248 matching lines @@
   RTC_DCHECK(!sender_);
   vcm_->Decode(kMaxDecodeWaitTimeMs);
   return true;
 }
 
 void ViEChannel::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
   if (!sender_)
     vcm_->SetReceiveChannelParameters(max_rtt_ms);
 
   rtc::CritScope lock(&crit_);
-  if (time_of_first_rtt_ms_ == -1)
-    time_of_first_rtt_ms_ = Clock::GetRealTimeClock()->TimeInMilliseconds();
-  rtt_sum_ms_ += avg_rtt_ms;
   last_rtt_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 132 matching lines @@
   rtc::CritScope lock(&crit_);
   receive_stats_callback_ = receive_statistics_proxy;
 }
 
 void ViEChannel::SetIncomingVideoStream(
     IncomingVideoStream* incoming_video_stream) {
   rtc::CritScope lock(&crit_);
   incoming_video_stream_ = incoming_video_stream;
 }
 }  // namespace webrtc