[rtp_rtcp] RTT intermidiate calculation use ntp time instead of milliseconds.

webrtc/modules/rtp_rtcp/source/rtcp_sender.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 177 matching lines @@
       tmmbr_send_(0),
       packet_oh_send_(0),
 
       app_sub_type_(0),
       app_name_(0),
       app_data_(nullptr),
       app_length_(0),
 
       xr_send_receiver_reference_time_enabled_(false),
       packet_type_counter_observer_(packet_type_counter_observer) {
-  memset(last_send_report_, 0, sizeof(last_send_report_));
-  memset(last_rtcp_time_, 0, sizeof(last_rtcp_time_));
   RTC_DCHECK(transport_ != nullptr);
 
   builders_[kRtcpSr] = &RTCPSender::BuildSR;
   builders_[kRtcpRr] = &RTCPSender::BuildRR;
   builders_[kRtcpSdes] = &RTCPSender::BuildSDES;
   builders_[kRtcpPli] = &RTCPSender::BuildPLI;
   builders_[kRtcpFir] = &RTCPSender::BuildFIR;
   builders_[kRtcpSli] = &RTCPSender::BuildSLI;
   builders_[kRtcpRpsi] = &RTCPSender::BuildRPSI;
   builders_[kRtcpRemb] = &RTCPSender::BuildREMB;
@@ skipping 228 matching lines @@
   if (now >= next_time_to_send_rtcp_) {
     return true;
   } else if (now < 0x0000ffff &&
              next_time_to_send_rtcp_ > 0xffff0000) {  // 65 sec margin
     // wrap
     return true;
   }
   return false;
 }
 
-int64_t RTCPSender::SendTimeOfSendReport(uint32_t sendReport) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
-
-  // This is only saved when we are the sender
-  if ((last_send_report_[0] == 0) || (sendReport == 0)) {
-    return 0;  // will be ignored
-  } else {
-    for (int i = 0; i < RTCP_NUMBER_OF_SR; ++i) {
-      if (last_send_report_[i] == sendReport)
-        return last_rtcp_time_[i];
-    }
-  }
-  return 0;
-}
-
-bool RTCPSender::SendTimeOfXrRrReport(uint32_t mid_ntp,
-                                      int64_t* time_ms) const {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
-
-  if (last_xr_rr_.empty()) {
-    return false;
-  }
-  std::map<uint32_t, int64_t>::const_iterator it = last_xr_rr_.find(mid_ntp);
-  if (it == last_xr_rr_.end()) {
-    return false;
-  }
-  *time_ms = it->second;
-  return true;
-}
-
 rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildSR(const RtcpContext& ctx) {
-  for (int i = (RTCP_NUMBER_OF_SR - 2); i >= 0; i--) {
-    // shift old
-    last_send_report_[i + 1] = last_send_report_[i];
-    last_rtcp_time_[i + 1] = last_rtcp_time_[i];
-  }
-
-  last_rtcp_time_[0] = Clock::NtpToMs(ctx.ntp_sec_, ctx.ntp_frac_);
-  last_send_report_[0] = (ctx.ntp_sec_ << 16) + (ctx.ntp_frac_ >> 16);
-
   // The timestamp of this RTCP packet should be estimated as the timestamp of
   // the frame being captured at this moment. We are calculating that
   // timestamp as the last frame's timestamp + the time since the last frame
   // was captured.
   uint32_t rtp_timestamp =
       start_timestamp_ + last_rtp_timestamp_ +
       (clock_->TimeInMilliseconds() - last_frame_capture_time_ms_) *
           (ctx.feedback_state_.frequency_hz / 1000);
 
   rtcp::SenderReport* report = new rtcp::SenderReport();
@@ skipping 247 matching lines @@
   rtcp::Bye* bye = new rtcp::Bye();
   bye->From(ssrc_);
   for (uint32_t csrc : csrcs_)
     bye->WithCsrc(csrc);
 
   return rtc::scoped_ptr<rtcp::Bye>(bye);
 }
 
 rtc::scoped_ptr<rtcp::RtcpPacket> RTCPSender::BuildReceiverReferenceTime(
     const RtcpContext& ctx) {
-  if (last_xr_rr_.size() >= RTCP_NUMBER_OF_SR)
-    last_xr_rr_.erase(last_xr_rr_.begin());
-  last_xr_rr_.insert(std::pair<uint32_t, int64_t>(
-      RTCPUtility::MidNtp(ctx.ntp_sec_, ctx.ntp_frac_),
-      Clock::NtpToMs(ctx.ntp_sec_, ctx.ntp_frac_)));
 
   rtcp::ExtendedReports* xr = new rtcp::ExtendedReports();
   xr->From(ssrc_);
 
   rtcp::Rrtr rrtr;
   rrtr.WithNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_));
 
   xr->WithRrtr(rrtr);
 
   // TODO(sprang): Merge XR report sending to contain all of RRTR, DLRR, VOIP?
@@ skipping 323 matching lines @@
     // RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(Sender);
     // but we can't because of an incorrect warning (C4822) in MVS 2013.
   } sender(transport_, event_log_);
 
   uint8_t buffer[IP_PACKET_SIZE];
   return packet.BuildExternalBuffer(buffer, IP_PACKET_SIZE, &sender) &&
          !sender.send_failure_;
 }
 
 }  // namespace webrtc