Use NtpTime in RtcpReceiver instead of pair of uints

webrtc/modules/rtp_rtcp/source/rtcp_receiver.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 21 matching lines @@
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
-#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/time_util.h"
 #include "webrtc/modules/rtp_rtcp/source/tmmbr_help.h"
 #include "webrtc/system_wrappers/include/ntp_time.h"
 
 namespace webrtc {
 namespace {
 
 using rtcp::CommonHeader;
 using rtcp::ReportBlock;
 
@@ skipping 54 matching lines @@
     ModuleRtpRtcp* owner)
     : _clock(clock),
       receiver_only_(receiver_only),
       _rtpRtcp(*owner),
       _cbRtcpBandwidthObserver(rtcp_bandwidth_observer),
       _cbRtcpIntraFrameObserver(rtcp_intra_frame_observer),
       _cbTransportFeedbackObserver(transport_feedback_observer),
       main_ssrc_(0),
       _remoteSSRC(0),
       _remoteSenderInfo(),
-      _lastReceivedSRNTPsecs(0),
-      _lastReceivedSRNTPfrac(0),
-      _lastReceivedXRNTPsecs(0),
-      _lastReceivedXRNTPfrac(0),
       xr_rrtr_status_(false),
       xr_rr_rtt_ms_(0),
       _lastReceivedRrMs(0),
       _lastIncreasedSequenceNumberMs(0),
       stats_callback_(NULL),
       packet_type_counter_observer_(packet_type_counter_observer),
       num_skipped_packets_(0),
       last_skipped_packets_warning_(clock->TimeInMilliseconds()) {
   memset(&_remoteSenderInfo, 0, sizeof(_remoteSenderInfo));
 }
@@ skipping 20 matching lines @@
     if (kv.second.last_time_received_ms > last_received_rr)
       last_received_rr = kv.second.last_time_received_ms;
   return last_received_rr;
 }
 
 void RTCPReceiver::SetRemoteSSRC(uint32_t ssrc) {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   // new SSRC reset old reports
   memset(&_remoteSenderInfo, 0, sizeof(_remoteSenderInfo));
-  _lastReceivedSRNTPsecs = 0;
-  _lastReceivedSRNTPfrac = 0;
+  last_received_sr_ntp_.Reset();
 
   _remoteSSRC = ssrc;
 }
 
 uint32_t RTCPReceiver::RemoteSSRC() const {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   return _remoteSSRC;
 }
 
 void RTCPReceiver::SetSsrcs(uint32_t main_ssrc,
@@ skipping 56 matching lines @@
   assert(rtt_ms);
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   if (xr_rr_rtt_ms_ == 0) {
     return false;
   }
   *rtt_ms = xr_rr_rtt_ms_;
   xr_rr_rtt_ms_ = 0;
   return true;
 }
 
-// TODO(pbos): Make this fail when we haven't received NTP.
 bool RTCPReceiver::NTP(uint32_t* ReceivedNTPsecs,
                        uint32_t* ReceivedNTPfrac,
                        uint32_t* RTCPArrivalTimeSecs,
                        uint32_t* RTCPArrivalTimeFrac,
                        uint32_t* rtcp_timestamp) const {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
-  if (ReceivedNTPsecs) {
-    *ReceivedNTPsecs =
-        _remoteSenderInfo.NTPseconds;  // NTP from incoming SendReport
-  }
-  if (ReceivedNTPfrac) {
+  if (!last_received_sr_ntp_.Valid())
+    return false;
+
+  // NTP from incoming SenderReport.
+  if (ReceivedNTPsecs)
+    *ReceivedNTPsecs = _remoteSenderInfo.NTPseconds;
+  if (ReceivedNTPfrac)
     *ReceivedNTPfrac = _remoteSenderInfo.NTPfraction;
-  }
-  if (RTCPArrivalTimeFrac) {
-    *RTCPArrivalTimeFrac = _lastReceivedSRNTPfrac;  // local NTP time when we
-                                                    // received a RTCP packet
-                                                    // with a send block
-  }
-  if (RTCPArrivalTimeSecs) {
-    *RTCPArrivalTimeSecs = _lastReceivedSRNTPsecs;
-  }
-  if (rtcp_timestamp) {
+
+  // Rtp time from incoming SenderReport.
+  if (rtcp_timestamp)
     *rtcp_timestamp = _remoteSenderInfo.RTPtimeStamp;
-  }
+
+  // Local NTP time when we received a RTCP packet with a send block.
+  if (RTCPArrivalTimeSecs)
+    *RTCPArrivalTimeSecs = last_received_sr_ntp_.seconds();
+  if (RTCPArrivalTimeFrac)
+    *RTCPArrivalTimeFrac = last_received_sr_ntp_.fractions();
+
   return true;
 }
 
 bool RTCPReceiver::LastReceivedXrReferenceTimeInfo(
     rtcp::ReceiveTimeInfo* info) const {
-  assert(info);
+  RTC_DCHECK(info);
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
-  if (_lastReceivedXRNTPsecs == 0 && _lastReceivedXRNTPfrac == 0) {
+  if (!last_received_xr_ntp_.Valid())
     return false;
-  }
 
   info->ssrc = remote_time_info_.ssrc;
   info->last_rr = remote_time_info_.last_rr;
 
   // Get the delay since last received report (RFC 3611).
-  uint32_t receive_time =
-      RTCPUtility::MidNtp(_lastReceivedXRNTPsecs, _lastReceivedXRNTPfrac);
-
-  uint32_t ntp_sec = 0;
-  uint32_t ntp_frac = 0;
-  _clock->CurrentNtp(ntp_sec, ntp_frac);
-  uint32_t now = RTCPUtility::MidNtp(ntp_sec, ntp_frac);
+  uint32_t receive_time = CompactNtp(last_received_xr_ntp_);
+  uint32_t now = CompactNtp(NtpTime(*_clock));
 
   info->delay_since_last_rr = now - receive_time;
   return true;
 }
 
 int32_t RTCPReceiver::SenderInfoReceived(RTCPSenderInfo* senderInfo) const {
   assert(senderInfo);
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
-  if (_lastReceivedSRNTPsecs == 0) {
+  if (!last_received_sr_ntp_.Valid())
     return -1;
-  }
+
   memcpy(senderInfo, &(_remoteSenderInfo), sizeof(RTCPSenderInfo));
   return 0;
 }
 
 // We can get multiple receive reports when we receive the report from a CE.
 int32_t RTCPReceiver::StatisticsReceived(
     std::vector<RTCPReportBlock>* receive_blocks) const {
   RTC_DCHECK(receive_blocks);
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   for (const auto& reports_per_receiver : received_report_blocks_)
@@ skipping 131 matching lines @@
     // Only signal that we have received a SR when we accept one.
     packet_information->packet_type_flags |= kRtcpSr;
 
     // Save the NTP time of this report.
     _remoteSenderInfo.NTPseconds = sender_report.ntp().seconds();
     _remoteSenderInfo.NTPfraction = sender_report.ntp().fractions();
     _remoteSenderInfo.RTPtimeStamp = sender_report.rtp_timestamp();
     _remoteSenderInfo.sendPacketCount = sender_report.sender_packet_count();
     _remoteSenderInfo.sendOctetCount = sender_report.sender_octet_count();
 
-    _clock->CurrentNtp(_lastReceivedSRNTPsecs, _lastReceivedSRNTPfrac);
+    last_received_sr_ntp_.SetCurrent(*_clock);
   } else {
     // We will only store the send report from one source, but
     // we will store all the receive blocks.
     packet_information->packet_type_flags |= kRtcpRr;
   }
 
   for (const rtcp::ReportBlock report_block : sender_report.report_blocks())
     HandleReportBlock(report_block, packet_information, remoteSSRC);
 }
 
@@ skipping 255 matching lines @@
     for (const rtcp::ReceiveTimeInfo& time_info : dlrr.sub_blocks())
       HandleXrDlrrReportBlock(time_info);
   }
 }
 
 void RTCPReceiver::HandleXrReceiveReferenceTime(
     uint32_t sender_ssrc,
     const rtcp::Rrtr& rrtr) {
   remote_time_info_.ssrc = sender_ssrc;
   remote_time_info_.last_rr = CompactNtp(rrtr.ntp());
-  _clock->CurrentNtp(_lastReceivedXRNTPsecs, _lastReceivedXRNTPfrac);
+  last_received_xr_ntp_.SetCurrent(*_clock);
 }
 
 void RTCPReceiver::HandleXrDlrrReportBlock(const rtcp::ReceiveTimeInfo& rti) {
   if (registered_ssrcs_.count(rti.ssrc) == 0)  // Not to us.
     return;
 
   // Caller should explicitly enable rtt calculation using extended reports.
   if (!xr_rrtr_status_)
     return;
 
@@ skipping 339 matching lines @@
       } else {
         candidates.push_back(it->second.tmmbr_item);
         ++it;
       }
     }
   }
   return candidates;
 }
 
 }  // namespace webrtc