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) {

[åsapersson, 2016/03/09 09:00:13]

should xr_rrtr_status_ be GUARDED_BY(_criticalSectionRTCPReceiver)?

[danilchap, 2016/03/09 09:52:53]

Done. Do not think it should, but it doesn't hurt either. Better be safe.

+  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 269 matching lines @@
     uint32_t remoteSSRC)
     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver) {
   // This will be called once per report block in the RTCP packet.
   // We filter out all report blocks that are not for us.
   // Each packet has max 31 RR blocks.
   //
   // We can calc RTT if we send a send report and get a report block back.
 
   // |rtcpPacket.ReportBlockItem.SSRC| is the SSRC identifier of the source to
   // which the information in this reception report block pertains.
 

[åsapersson, 2016/03/09 09:00:13]

maybe we should move the check earlier and not store the report block
information. could maybe be done in a later CL.

[danilchap, 2016/03/09 09:52:53]

May be, but not in this CL. (I have CL that changes report block handling:
https://codereview.webrtc.org/1540383002/ - probably should incorporate this
change there).

This CL is intended to be merged into M51, so would prefer to have fixes, but
not improvements here.

[åsapersson, 2016/03/09 10:06:46]

Acknowledged.

   // Filter out all report blocks that are not for us.
   if (registered_ssrcs_.find(rtcpPacket.ReportBlockItem.SSRC) ==
       registered_ssrcs_.end()) {
     // This block is not for us ignore it.
     return;
   }
 
   RTCPReportBlockInformation* reportBlock =
       CreateOrGetReportBlockInformation(remoteSSRC,
                                         rtcpPacket.ReportBlockItem.SSRC);
@@ skipping 19 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 accidentely can.

[åsapersson, 2016/03/09 09:00:13]

nit: accidentally

[danilchap, 2016/03/09 09:52:53]

Done.

+  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 explicetely enable rtt calculation using extended reports.

[åsapersson, 2016/03/09 09:00:13]

nit: explicitly

[danilchap, 2016/03/09 09:52:53]

Done.

+  if (!xr_rrtr_status_)

[åsapersson, 2016/03/09 09:00:13]

move check to line 921

[danilchap, 2016/03/09 09:52:53]

Would rather not in this CL:
xr_dlrr_item flag is used in tests only, and the only impact of moving check
before setting the flag is breaking some tests. (Tests explicitly expect this
flag to be set even when rtt can't be calculated)

+    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