rtt calculation handles time go backwards

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.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h"
 
 #include <assert.h>
 #include <string.h>
 
-#include <algorithm>
-
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.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/rtp_rtcp_impl.h"
 #include "webrtc/modules/rtp_rtcp/source/time_util.h"
 #include "webrtc/system_wrappers/include/ntp_time.h"
 
 namespace webrtc {
@@ skipping 31 matching lines @@
       _cbTransportFeedbackObserver(transport_feedback_observer),
       _criticalSectionRTCPReceiver(
           CriticalSectionWrapper::CreateCriticalSection()),
       main_ssrc_(0),
       _remoteSSRC(0),
       _remoteSenderInfo(),
       _lastReceivedSRNTPsecs(0),
       _lastReceivedSRNTPfrac(0),
       _lastReceivedXRNTPsecs(0),
       _lastReceivedXRNTPfrac(0),
+      xr_rrtr_status_(false),
       xr_rr_rtt_ms_(0),
       _receivedInfoMap(),
       _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 105 matching lines @@
   }
   if (minRTT) {
     *minRTT = reportBlock->minRTT;
   }
   if (maxRTT) {
     *maxRTT = reportBlock->maxRTT;
   }
   return 0;
 }
 
+void RTCPReceiver::SetRtcpXrRrtrStatus(bool enable) {
+  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  xr_rrtr_status_ = enable;
+}
+
 bool RTCPReceiver::GetAndResetXrRrRtt(int64_t* rtt_ms) {
   assert(rtt_ms);
   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
   if (xr_rr_rtt_ms_ == 0) {
     return false;
   }
   *rtt_ms = xr_rr_rtt_ms_;
   xr_rr_rtt_ms_ = 0;
   return true;
 }
@@ skipping 309 matching lines @@
   reportBlock->remoteReceiveBlock.extendedHighSeqNum =
       rb.ExtendedHighestSequenceNumber;
   reportBlock->remoteReceiveBlock.jitter = rb.Jitter;
   reportBlock->remoteReceiveBlock.delaySinceLastSR = rb.DelayLastSR;
   reportBlock->remoteReceiveBlock.lastSR = rb.LastSR;
 
   if (rtcpPacket.ReportBlockItem.Jitter > reportBlock->remoteMaxJitter) {
     reportBlock->remoteMaxJitter = rtcpPacket.ReportBlockItem.Jitter;
   }
 
+  int64_t rtt = 0;
   uint32_t send_time = rtcpPacket.ReportBlockItem.LastSR;
-  uint32_t rtt = 0;
-
-  if (send_time > 0) {
+  // RFC3550, section 6.4.1, LSR field discription states:
+  // If no SR has been received yet, the field is set to zero.
+  // Receiver rtp_rtcp module is not expected to calculate rtt using
+  // Sender Reports even if it accidentally can.
+  if (!receiver_only_ && send_time != 0) {
     uint32_t delay = rtcpPacket.ReportBlockItem.DelayLastSR;
     // Local NTP time.
     uint32_t receive_time = CompactNtp(NtpTime(*_clock));
 
     // RTT in 1/(2^16) seconds.
     uint32_t rtt_ntp = receive_time - delay - send_time;
     // Convert to 1/1000 seconds (milliseconds).
-    uint32_t rtt_ms = CompactNtpIntervalToMs(rtt_ntp);
-    rtt = std::max<uint32_t>(rtt_ms, 1);
+    rtt = CompactNtpRttToMs(rtt_ntp);
     if (rtt > reportBlock->maxRTT) {
       // Store max RTT.
       reportBlock->maxRTT = rtt;
     }
     if (reportBlock->minRTT == 0) {
       // First RTT.
       reportBlock->minRTT = rtt;
     } else if (rtt < reportBlock->minRTT) {
       // Store min RTT.
       reportBlock->minRTT = rtt;
@@ skipping 363 matching lines @@
     RTCPPacketInformation& rtcpPacketInformation)
     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver) {
   if (registered_ssrcs_.find(packet.XRDLRRReportBlockItem.SSRC) ==
       registered_ssrcs_.end()) {
     // Not to us.
     return;
   }
 
   rtcpPacketInformation.xr_dlrr_item = true;
 
+  // Caller should explicitly enable rtt calculation using extended reports.
+  if (!xr_rrtr_status_)
+    return;
+
   // The send_time and delay_rr fields are in units of 1/2^16 sec.
   uint32_t send_time = packet.XRDLRRReportBlockItem.LastRR;
-  // RFC3411, section 4.5, LRR field discription states:
+  // RFC3611, section 4.5, LRR field discription states:
   // If no such block has been received, the field is set to zero.
   if (send_time == 0)
     return;
 
   uint32_t delay_rr = packet.XRDLRRReportBlockItem.DelayLastRR;
   uint32_t now = CompactNtp(NtpTime(*_clock));
 
   uint32_t rtt_ntp = now - delay_rr - send_time;
-  uint32_t rtt_ms = CompactNtpIntervalToMs(rtt_ntp);
-  xr_rr_rtt_ms_ = std::max<uint32_t>(rtt_ms, 1);
+  xr_rr_rtt_ms_ = CompactNtpRttToMs(rtt_ntp);
 
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrDlrrReportBlock;
 }
 
 void
 RTCPReceiver::HandleXRVOIPMetric(RTCPUtility::RTCPParserV2& rtcpParser,
                                  RTCPPacketInformation& rtcpPacketInformation)
 {
     const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
 
@@ skipping 503 matching lines @@
         return -1;
       }
       num += receiveInfo->TmmbrSet.lengthOfSet();
       receiveInfoIt++;
     }
   }
   return num;
 }
 
 }  // namespace webrtc