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

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 {
 using RTCPHelp::RTCPPacketInformation;
 using RTCPHelp::RTCPReceiveInformation;
 using RTCPHelp::RTCPReportBlockInformation;
 using RTCPUtility::kBtVoipMetric;
 using RTCPUtility::RTCPCnameInformation;
 using RTCPUtility::RTCPPacketReportBlockItem;
 using RTCPUtility::RTCPPacketTypes;
 
@@ skipping 446 matching lines @@
   // |rtcpPacket.ReportBlockItem.SSRC| is the SSRC identifier of the source to
   // which the information in this reception report block pertains.
 
   // 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;
   }
 
-  // To avoid problem with acquiring _criticalSectionRTCPSender while holding
-  // _criticalSectionRTCPReceiver.
-  _criticalSectionRTCPReceiver->Leave();
-  int64_t sendTimeMS =
-      _rtpRtcp.SendTimeOfSendReport(rtcpPacket.ReportBlockItem.LastSR);
-  _criticalSectionRTCPReceiver->Enter();
-
   RTCPReportBlockInformation* reportBlock =
       CreateOrGetReportBlockInformation(remoteSSRC,
                                         rtcpPacket.ReportBlockItem.SSRC);
   if (reportBlock == NULL) {
     LOG(LS_WARNING) << "Failed to CreateReportBlockInformation("
                     << remoteSSRC << ")";
     return;
   }
 
   _lastReceivedRrMs = _clock->TimeInMilliseconds();
@@ skipping 12 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;
   }
 
-  uint32_t delaySinceLastSendReport =
-      rtcpPacket.ReportBlockItem.DelayLastSR;
+  uint32_t send_time = rtcpPacket.ReportBlockItem.LastSR;
+  uint32_t rtt = 0;
 
-  // local NTP time when we received this
-  uint32_t lastReceivedRRNTPsecs = 0;
-  uint32_t lastReceivedRRNTPfrac = 0;
+  if (send_time > 0) {
+    uint32_t delay = rtcpPacket.ReportBlockItem.DelayLastSR;
+    // Local NTP time.
+    uint32_t receive_time = CompactNtp(NtpTime(*_clock));
 
-  _clock->CurrentNtp(lastReceivedRRNTPsecs, lastReceivedRRNTPfrac);
-
-  // time when we received this in MS
-  int64_t receiveTimeMS = Clock::NtpToMs(lastReceivedRRNTPsecs,
-                                         lastReceivedRRNTPfrac);
-
-  // Estimate RTT
-  uint32_t d = (delaySinceLastSendReport & 0x0000ffff) * 1000;
-  d /= 65536;
-  d += ((delaySinceLastSendReport & 0xffff0000) >> 16) * 1000;
-
-  int64_t RTT = 0;
-
-  if (sendTimeMS > 0) {
-    RTT = receiveTimeMS - d - sendTimeMS;
-    if (RTT <= 0) {
-      RTT = 1;
-    }
-    if (RTT > reportBlock->maxRTT) {
-      // store max RTT
-      reportBlock->maxRTT = RTT;
+    // 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);
+    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;
+      // First RTT.
+      reportBlock->minRTT = rtt;
+    } else if (rtt < reportBlock->minRTT) {
+      // Store min RTT.
+      reportBlock->minRTT = rtt;
     }
-    // store last RTT
-    reportBlock->RTT = RTT;
+    // Store last RTT.
+    reportBlock->RTT = rtt;
 
     // store average RTT
     if (reportBlock->numAverageCalcs != 0) {
       float ac = static_cast<float>(reportBlock->numAverageCalcs);
       float newAverage =
-          ((ac / (ac + 1)) * reportBlock->avgRTT) + ((1 / (ac + 1)) * RTT);
+          ((ac / (ac + 1)) * reportBlock->avgRTT) + ((1 / (ac + 1)) * rtt);
       reportBlock->avgRTT = static_cast<int64_t>(newAverage + 0.5f);
     } else {
-      // first RTT
-      reportBlock->avgRTT = RTT;
+      // First RTT.
+      reportBlock->avgRTT = rtt;
     }
     reportBlock->numAverageCalcs++;
   }
 
   TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR_RTT", rb.SSRC,
-                    RTT);
+                    rtt);
 
   rtcpPacketInformation.AddReportInfo(*reportBlock);
 }
 
 RTCPReportBlockInformation* RTCPReceiver::CreateOrGetReportBlockInformation(
     uint32_t remote_ssrc,
     uint32_t source_ssrc) {
   RTCPReportBlockInformation* info =
       GetReportBlockInformation(remote_ssrc, source_ssrc);
   if (info == NULL) {
@@ skipping 334 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;
 
-  // To avoid problem with acquiring _criticalSectionRTCPSender while holding
-  // _criticalSectionRTCPReceiver.
-  _criticalSectionRTCPReceiver->Leave();
+  // 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:
+  // If no such block has been received, the field is set to zero.
+  if (send_time == 0)
+    return;
 
-  int64_t send_time_ms;
-  bool found = _rtpRtcp.SendTimeOfXrRrReport(
-      packet.XRDLRRReportBlockItem.LastRR, &send_time_ms);
+  uint32_t delay_rr = packet.XRDLRRReportBlockItem.DelayLastRR;
+  uint32_t now = CompactNtp(NtpTime(*_clock));
 
-  _criticalSectionRTCPReceiver->Enter();
-
-  if (!found) {
-    return;
-  }
-
-  // The DelayLastRR field is in units of 1/65536 sec.
-  uint32_t delay_rr_ms =
-      (((packet.XRDLRRReportBlockItem.DelayLastRR & 0x0000ffff) * 1000) >> 16) +
-      (((packet.XRDLRRReportBlockItem.DelayLastRR & 0xffff0000) >> 16) * 1000);
-
-  int64_t rtt = _clock->CurrentNtpInMilliseconds() - delay_rr_ms - send_time_ms;
-
-  xr_rr_rtt_ms_ = std::max<int64_t>(rtt, 1);
+  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);
 
   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