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

webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.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 18 matching lines @@
 #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/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/tmmbr.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
+#include "webrtc/modules/rtp_rtcp/source/time_util.h"
+#include "webrtc/system_wrappers/include/ntp_time.h"
 
 namespace webrtc {
 
 namespace {  // Anonymous namespace; hide utility functions and classes.
 
 // This test transport verifies that no functions get called.
 class TestTransport : public Transport,
                       public NullRtpData {
  public:
   explicit TestTransport() : rtcp_receiver_(nullptr) {}
@@ skipping 123 matching lines @@
   const uint32_t kSenderSsrc = 0x10203;
   rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
   rtcp::SenderReport sr;
   sr.From(kSenderSsrc);
   rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
   EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
   EXPECT_EQ(kRtcpSr, rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
+TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesRTT) {
+  Random r(0x0123456789abcdef);
+  const uint32_t kSenderSsrc = r.Rand(0x00000001u, 0xfffffffeu);
+  const uint32_t kRemoteSsrc = r.Rand(0x00000001u, 0xfffffffeu);
+  const int64_t kRttMs = r.Rand(1, 18 * 3600 * 1000);
+  const uint32_t kDelayNtp = r.Rand<uint32_t>();
+  const uint32_t kDelayMs = CompactNtpIntervalToMs(kDelayNtp);
+
+  rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
+  std::set<uint32_t> ssrcs;
+  ssrcs.insert(kRemoteSsrc);
+  rtcp_receiver_->SetSsrcs(kRemoteSsrc, ssrcs);
+
+  int64_t rtt_ms = 0;
+  EXPECT_EQ(
+      -1, rtcp_receiver_->RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
+
+  uint32_t sent_ntp = CompactNtp(NtpTime(system_clock_));
+  system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
+
+  rtcp::SenderReport sr;
+  sr.From(kSenderSsrc);
+  rtcp::ReportBlock block;
+  block.To(kRemoteSsrc);
+  block.WithLastSr(sent_ntp);
+  block.WithDelayLastSr(kDelayNtp);
+  sr.WithReportBlock(block);
+
+  rtc::scoped_ptr<rtcp::RawPacket> packet = sr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+
+  EXPECT_EQ(
+      0, rtcp_receiver_->RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr));
+  EXPECT_NEAR(kRttMs, rtt_ms, 1);

[stefan-webrtc, 2016/02/03 10:03:11]

What's the reason we can't get an exact rtt here?

[danilchap, 2016/02/03 13:27:11]

Rounding.
if rtt would be stored and returned in 1/2^16 seconds, the result would be
exact.

[stefan-webrtc, 2016/02/22 16:14:35]

Acknowledged.

+}
+
 TEST_F(RtcpReceiverTest, InjectRrPacket) {
   const uint32_t kSenderSsrc = 0x10203;
   rtcp::ReceiverReport rr;
   rr.From(kSenderSsrc);
   rtc::scoped_ptr<rtcp::RawPacket> packet(rr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
   EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
   EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags);
   ASSERT_EQ(0u, rtcp_packet_info_.report_blocks.size());
 }
@@ skipping 463 matching lines @@
   EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item);
 }
 
 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::Dlrr dlrr;
-  dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890);
+  dlrr.WithDlrrItem(kSourceSsrc, 0, 0x67890);

[stefan-webrtc, 2016/02/03 10:03:11]

Could you explain these changes to me?

[danilchap, 2016/02/03 13:27:11]

changed field is sent time.
Before this cl it wasn't possible to estimate RTT because rtcp_sender associated
with rtcp_receiver should have send Rrtr Report at that send time.
This CL removes this complicated setup.
sent time 0 indicate there is no sent time and RTT shouldn't be estimated.

This test is not about RTT.
Though it is better to update the comment since RTT calculation is not checked.

   rtcp::ExtendedReports xr;
   xr.From(0x2345);
   xr.WithDlrr(dlrr);
   rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
   // The parser should note the DLRR report block item, but not flag the packet
   // since the RTT is not estimated.
   EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item);
 }
 
 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::Dlrr dlrr;
-  dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890);
-  dlrr.WithDlrrItem(kSourceSsrc + 2, 0x12345, 0x67890);
-  dlrr.WithDlrrItem(kSourceSsrc,     0x12345, 0x67890);
+  dlrr.WithDlrrItem(kSourceSsrc + 1, 0, 0x67890);
+  dlrr.WithDlrrItem(kSourceSsrc + 2, 0, 0x67890);
+  dlrr.WithDlrrItem(kSourceSsrc, 0, 0x67890);
   rtcp::ExtendedReports xr;
   xr.From(0x2345);
   xr.WithDlrr(dlrr);
   rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
   // The parser should note the DLRR report block item, but not flag the packet
   // since the RTT is not estimated.
   EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item);
 }
 
 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   rtcp::Rrtr rrtr;
   rtcp::Dlrr dlrr;
-  dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890);
+  dlrr.WithDlrrItem(kSourceSsrc, 0, 0x67890);

[danilchap, 2016/02/03 13:27:11]

This test does check rtt wasn't estimated. So need to be updated it to prevent
rtt calculation.

   rtcp::VoipMetric metric;
   metric.To(kSourceSsrc);
   rtcp::ExtendedReports xr;
   xr.From(0x2345);
   xr.WithRrtr(rrtr);
   xr.WithDlrr(dlrr);
   xr.WithVoipMetric(metric);
   rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
   EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime +
@@ skipping 33 matching lines @@
                                       kRtcpXrVoipMetric),
             rtcp_packet_info_.rtcpPacketTypeFlags);
   EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item);
 }
 
 TEST_F(RtcpReceiverTest, TestXrRrRttInitiallyFalse) {
   int64_t rtt_ms;
   EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms));
 }
 
+TEST_F(RtcpReceiverTest, RttCalculatedAfterXrDlrr) {
+  Random rand(0x0123456789abcdef);
+  const uint32_t kSourceSsrc = rand.Rand(0x00000001u, 0xfffffffeu);
+  const uint32_t kRttMs = rand.Rand(1, 18 * 3600 * 1000);
+  const uint32_t kDelayNtp = rand.Rand<uint32_t>();
+  const uint32_t kDelayMs = CompactNtpIntervalToMs(kDelayNtp);
+  std::set<uint32_t> ssrcs;
+  ssrcs.insert(kSourceSsrc);
+  rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
+  NtpTime now(system_clock_);
+  uint32_t sent_ntp = CompactNtp(now);
+  system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
+
+  rtcp::Dlrr dlrr;
+  dlrr.WithDlrrItem(kSourceSsrc, sent_ntp, kDelayNtp);
+  rtcp::ExtendedReports xr;
+  xr.From(0x2345);
+  xr.WithDlrr(dlrr);
+  rtc::scoped_ptr<rtcp::RawPacket> packet = xr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
+
+  int64_t rtt_ms = 0;
+  EXPECT_TRUE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms));
+  EXPECT_NEAR(kRttMs, rtt_ms, 1);
+}

[stefan-webrtc, 2016/02/03 10:03:11]

Maybe we can reuse a few lines from the other test you added? See that as
optional if it turns out to be non trivial.

[danilchap, 2016/02/03 13:27:11]

Do not want to think about test improvements in this CL.
There is another CL where I refactor this tests in more radical way
(https://codereview.webrtc.org/1527003002/)

+
 TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) {
   RtcpReceiveTimeInfo info;
   EXPECT_FALSE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info));
 }
 
 TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) {
   const uint32_t kSenderSsrc = 0x123456;
   const NtpTime kNtp(0x10203, 0x40506);
-  const uint32_t kNtpMid =
-      RTCPUtility::MidNtp(kNtp.seconds(), kNtp.fractions());
+  const uint32_t kNtpMid = CompactNtp(kNtp);
 
   rtcp::Rrtr rrtr;
   rrtr.WithNtp(kNtp);
   rtcp::ExtendedReports xr;
   xr.From(kSenderSsrc);
   xr.WithRrtr(rrtr);
   rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
   EXPECT_EQ(kRtcpXrReceiverReferenceTime,
       rtcp_packet_info_.rtcpPacketTypeFlags);
@@ skipping 320 matching lines @@
 
   // Transport feedback should be ignored, but next packet should work.
   EXPECT_EQ(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpTransportFeedback);
   EXPECT_NE(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpRemb);
   EXPECT_EQ(kBitrateBps, rtcp_packet_info_.receiverEstimatedMaxBitrate);
 }
 
 }  // Anonymous namespace
 
 }  // namespace webrtc