Add stats for frequency offset when converting RTP timestamp to NTP time.

webrtc/system_wrappers/source/rtp_to_ntp_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 19 matching lines @@
   EXPECT_EQ(1, CheckForWrapArounds(0x0000FFFF, 0xFFFF0000));
 }
 
 TEST(WrapAroundTests, BackwardWrap) {
   EXPECT_EQ(-1, CheckForWrapArounds(0xFFFFFFFF, 0));
   EXPECT_EQ(-1, CheckForWrapArounds(0xFFFF0000, 0));
   EXPECT_EQ(-1, CheckForWrapArounds(0xFFFFFFFF, 0x0000FFFF));
   EXPECT_EQ(-1, CheckForWrapArounds(0xFFFF0000, 0x0000FFFF));
 }
 
-TEST(WrapAroundTests, OldRtcpWrapped) {
-  RtcpList rtcp;
+TEST(WrapAroundTests, OldRtcpWrapped_OldRtpTimestamp) {
+  RtcpMeasurements rtcp;
+  bool new_sr;
   uint32_t ntp_sec = 0;
-  uint32_t ntp_frac = 0;
+  uint32_t ntp_frac = 1;
   uint32_t timestamp = 0;
-  rtcp.push_front(RtcpMeasurement(ntp_sec, ntp_frac, timestamp));
+  EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
   ntp_frac += kOneMsInNtpFrac;
   timestamp -= kTimestampTicksPerMs;
-  rtcp.push_front(RtcpMeasurement(ntp_sec, ntp_frac, timestamp));
-  ntp_frac += kOneMsInNtpFrac;
-  timestamp -= kTimestampTicksPerMs;
-  int64_t timestamp_in_ms = -1;
-  // This expected to fail since it's highly unlikely that the older RTCP
-  // has a much smaller RTP timestamp than the newer.
-  EXPECT_FALSE(RtpToNtpMs(timestamp, rtcp, &timestamp_in_ms));
+  // Expected to fail since the older RTCP has a smaller RTP timestamp than the
+  // newer (old:0, new:4294967206).
+  EXPECT_FALSE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
 }
 
 TEST(WrapAroundTests, NewRtcpWrapped) {
-  RtcpList rtcp;
+  RtcpMeasurements rtcp;
+  bool new_sr;
   uint32_t ntp_sec = 0;
-  uint32_t ntp_frac = 0;
+  uint32_t ntp_frac = 1;
   uint32_t timestamp = 0xFFFFFFFF;
-  rtcp.push_front(RtcpMeasurement(ntp_sec, ntp_frac, timestamp));
+  EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
   ntp_frac += kOneMsInNtpFrac;
   timestamp += kTimestampTicksPerMs;
-  rtcp.push_front(RtcpMeasurement(ntp_sec, ntp_frac, timestamp));
+  EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
   int64_t timestamp_in_ms = -1;
-  EXPECT_TRUE(RtpToNtpMs(rtcp.back().rtp_timestamp, rtcp, &timestamp_in_ms));
+  EXPECT_TRUE(
+      RtpToNtpMs(rtcp.list.back().rtp_timestamp, rtcp, &timestamp_in_ms));
   // Since this RTP packet has the same timestamp as the RTCP packet constructed
   // at time 0 it should be mapped to 0 as well.
   EXPECT_EQ(0, timestamp_in_ms);
 }
 
 TEST(WrapAroundTests, RtpWrapped) {
-  RtcpList rtcp;
+  RtcpMeasurements rtcp;
+  bool new_sr;
   uint32_t ntp_sec = 0;
-  uint32_t ntp_frac = 0;
+  uint32_t ntp_frac = 1;
   uint32_t timestamp = 0xFFFFFFFF - 2 * kTimestampTicksPerMs;
-  rtcp.push_front(RtcpMeasurement(ntp_sec, ntp_frac, timestamp));
+  EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
   ntp_frac += kOneMsInNtpFrac;
   timestamp += kTimestampTicksPerMs;
-  rtcp.push_front(RtcpMeasurement(ntp_sec, ntp_frac, timestamp));
-  ntp_frac += kOneMsInNtpFrac;
-  timestamp += kTimestampTicksPerMs;
-  int64_t timestamp_in_ms = -1;
-  EXPECT_TRUE(RtpToNtpMs(timestamp, rtcp, &timestamp_in_ms));
+  EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
+
+  int64_t timestamp_ms = -1;
+  EXPECT_TRUE(RtpToNtpMs(rtcp.list.back().rtp_timestamp, rtcp, &timestamp_ms));
   // Since this RTP packet has the same timestamp as the RTCP packet constructed
   // at time 0 it should be mapped to 0 as well.
-  EXPECT_EQ(2, timestamp_in_ms);
+  EXPECT_EQ(0, timestamp_ms);
+  // Two kTimestampTicksPerMs advanced.
+  timestamp += kTimestampTicksPerMs;
+  EXPECT_TRUE(RtpToNtpMs(timestamp, rtcp, &timestamp_ms));
+  EXPECT_EQ(2, timestamp_ms);
+  // Wrapped rtp.
+  timestamp += kTimestampTicksPerMs;
+  EXPECT_TRUE(RtpToNtpMs(timestamp, rtcp, &timestamp_ms));
+  EXPECT_EQ(3, timestamp_ms);
 }
 
 TEST(WrapAroundTests, OldRtp_RtcpsWrapped) {
-  RtcpList rtcp;
+  RtcpMeasurements rtcp;
+  bool new_sr;
   uint32_t ntp_sec = 0;
-  uint32_t ntp_frac = 0;
+  uint32_t ntp_frac = 1;
   uint32_t timestamp = 0;
-  rtcp.push_front(RtcpMeasurement(ntp_sec, ntp_frac, timestamp));
+  EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
   ntp_frac += kOneMsInNtpFrac;
   timestamp += kTimestampTicksPerMs;
-  rtcp.push_front(RtcpMeasurement(ntp_sec, ntp_frac, timestamp));
+  EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
   ntp_frac += kOneMsInNtpFrac;
   timestamp -= 2*kTimestampTicksPerMs;
   int64_t timestamp_in_ms = -1;
   EXPECT_FALSE(RtpToNtpMs(timestamp, rtcp, &timestamp_in_ms));
 }
 
 TEST(WrapAroundTests, OldRtp_NewRtcpWrapped) {
-  RtcpList rtcp;
+  RtcpMeasurements rtcp;
+  bool new_sr;
   uint32_t ntp_sec = 0;
-  uint32_t ntp_frac = 0;
+  uint32_t ntp_frac = 1;
   uint32_t timestamp = 0xFFFFFFFF;
-  rtcp.push_front(RtcpMeasurement(ntp_sec, ntp_frac, timestamp));
+  EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
   ntp_frac += kOneMsInNtpFrac;
   timestamp += kTimestampTicksPerMs;
-  rtcp.push_front(RtcpMeasurement(ntp_sec, ntp_frac, timestamp));
+  EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
   ntp_frac += kOneMsInNtpFrac;
   timestamp -= kTimestampTicksPerMs;
   int64_t timestamp_in_ms = -1;
   EXPECT_TRUE(RtpToNtpMs(timestamp, rtcp, &timestamp_in_ms));
   // Constructed at the same time as the first RTCP and should therefore be
   // mapped to zero.
   EXPECT_EQ(0, timestamp_in_ms);
 }
 
-TEST(WrapAroundTests, OldRtp_OldRtcpWrapped) {
-  RtcpList rtcp;
+TEST(UpdateRtcpListTests, InjectRtcpSr) {
+  const uint32_t kNtpSec = 10;
+  const uint32_t kNtpFrac = 12345;
+  const uint32_t kTs = 0x12345678;
+  bool new_sr;
+  RtcpMeasurements rtcp;
+  EXPECT_TRUE(UpdateRtcpList(kNtpSec, kNtpFrac, kTs, &rtcp, &new_sr));
+  EXPECT_TRUE(new_sr);
+  EXPECT_EQ(1u, rtcp.list.size());
+  EXPECT_EQ(kNtpSec, rtcp.list.front().ntp_secs);
+  EXPECT_EQ(kNtpFrac, rtcp.list.front().ntp_frac);
+  EXPECT_EQ(kTs, rtcp.list.front().rtp_timestamp);
+  // Add second report.
+  EXPECT_TRUE(UpdateRtcpList(kNtpSec, kNtpFrac + kOneMsInNtpFrac, kTs + 1,
+                             &rtcp, &new_sr));
+  EXPECT_EQ(2u, rtcp.list.size());
+  EXPECT_EQ(kTs + 1, rtcp.list.front().rtp_timestamp);
+  EXPECT_EQ(kTs + 0, rtcp.list.back().rtp_timestamp);
+  // List contains last two reports.
+  EXPECT_TRUE(UpdateRtcpList(kNtpSec, kNtpFrac + 2 * kOneMsInNtpFrac, kTs + 2,
+                             &rtcp, &new_sr));
+  EXPECT_EQ(2u, rtcp.list.size());
+  EXPECT_EQ(kTs + 2, rtcp.list.front().rtp_timestamp);
+  EXPECT_EQ(kTs + 1, rtcp.list.back().rtp_timestamp);
+}
+
+TEST(UpdateRtcpListTests, FailsForZeroNtp) {

[stefan-webrtc, 2016/10/18 23:38:27]

Could you comment on why we decide to fail on zero ntp?

[åsapersson, 2016/10/19 14:35:28]

Done. Added comment.

+  RtcpMeasurements rtcp;
   uint32_t ntp_sec = 0;
   uint32_t ntp_frac = 0;
-  uint32_t timestamp = 0;
-  rtcp.push_front(RtcpMeasurement(ntp_sec, ntp_frac, timestamp));
-  ntp_frac += kOneMsInNtpFrac;
-  timestamp -= kTimestampTicksPerMs;
-  rtcp.push_front(RtcpMeasurement(ntp_sec, ntp_frac, timestamp));
-  ntp_frac += kOneMsInNtpFrac;
-  timestamp += 2*kTimestampTicksPerMs;
-  int64_t timestamp_in_ms = -1;
-  EXPECT_FALSE(RtpToNtpMs(timestamp, rtcp, &timestamp_in_ms));
-}
-
-TEST(RtpToNtpTests, FailsForDecreasingRtpTimestamp) {
-  const uint32_t kNtpSec1 = 3683354930;
-  const uint32_t kNtpFrac1 = 699925050;
-  const uint32_t kTimestamp1 = 2192705742;
-  const uint32_t kNtpSec2 = kNtpSec1;
-  const uint32_t kNtpFrac2 = kNtpFrac1 + kOneMsInNtpFrac;
-  const uint32_t kTimestamp2 = kTimestamp1 - kTimestampTicksPerMs;
-  RtcpList rtcp;
-  rtcp.push_front(RtcpMeasurement(kNtpSec1, kNtpFrac1, kTimestamp1));
-  rtcp.push_front(RtcpMeasurement(kNtpSec2, kNtpFrac2, kTimestamp2));
-  int64_t timestamp_in_ms = -1;
-  EXPECT_FALSE(RtpToNtpMs(kTimestamp1, rtcp, &timestamp_in_ms));
-}
-
-TEST(UpdateRtcpListTests, InjectRtcpSrWithEqualNtp) {
-  RtcpList rtcp;
-  uint32_t ntp_sec = 0;
-  uint32_t ntp_frac = 2;
   uint32_t timestamp = 0x12345678;
 
   bool new_sr;
+  EXPECT_FALSE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
+  EXPECT_FALSE(new_sr);
+  EXPECT_EQ(0u, rtcp.list.size());
+}
+
+TEST(UpdateRtcpListTests, FailsForEqualNtp) {
+  RtcpMeasurements rtcp;
+  uint32_t ntp_sec = 0;
+  uint32_t ntp_frac = 699925050;
+  uint32_t timestamp = 0x12345678;
+
+  bool new_sr;
   EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
   EXPECT_TRUE(new_sr);
 
   ++timestamp;
   EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
   EXPECT_FALSE(new_sr);
+  EXPECT_EQ(1u, rtcp.list.size());
 }
 
-TEST(UpdateRtcpListTests, InjectRtcpSrWithEqualTimestamp) {
-  RtcpList rtcp;
+TEST(UpdateRtcpListTests, FailsForOldNtp) {
+  RtcpMeasurements rtcp;
+  uint32_t ntp_sec = 1;
+  uint32_t ntp_frac = 699925050;
+  uint32_t timestamp = 0x12345678;
+
+  bool new_sr;
+  EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
+  EXPECT_TRUE(new_sr);
+
+  ntp_frac -= kOneMsInNtpFrac;
+  timestamp += kTimestampTicksPerMs;
+  EXPECT_FALSE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
+  EXPECT_EQ(1u, rtcp.list.size());
+}
+
+TEST(UpdateRtcpListTests, FailsForEqualTimestamp) {
+  RtcpMeasurements rtcp;
   uint32_t ntp_sec = 0;
   uint32_t ntp_frac = 2;
   uint32_t timestamp = 0x12345678;
 
   bool new_sr;
   EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
   EXPECT_TRUE(new_sr);
 
   ++ntp_frac;
   EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
   EXPECT_FALSE(new_sr);
+  EXPECT_EQ(1u, rtcp.list.size());
 }
 
-TEST(UpdateRtcpListTests, InjectRtcpSrWithZeroNtpFails) {
-  RtcpList rtcp;
+TEST(UpdateRtcpListTests, FailsForOldRtpTimestamp) {
+  RtcpMeasurements rtcp;
   uint32_t ntp_sec = 0;
-  uint32_t ntp_frac = 0;
+  uint32_t ntp_frac = 2;
   uint32_t timestamp = 0x12345678;
 
   bool new_sr;
+  EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
+  EXPECT_TRUE(new_sr);
+
+  ntp_frac += kOneMsInNtpFrac;
+  timestamp -= kTimestampTicksPerMs;
   EXPECT_FALSE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
+  EXPECT_FALSE(new_sr);
+  EXPECT_EQ(1u, rtcp.list.size());
 }
+
+TEST(UpdateRtcpListTests, VerifyParameters) {
+  RtcpMeasurements rtcp;
+  uint32_t ntp_sec = 1;
+  uint32_t ntp_frac = 2;
+  uint32_t timestamp = 0x12345678;
+
+  bool new_sr;
+  EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
+  EXPECT_TRUE(new_sr);
+  EXPECT_FALSE(rtcp.params.calculated);
+
+  ntp_frac += kOneMsInNtpFrac;
+  timestamp += kTimestampTicksPerMs;
+  EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
+  EXPECT_TRUE(rtcp.params.calculated);
+  EXPECT_DOUBLE_EQ(90.0, rtcp.params.frequency_khz);
+  EXPECT_NE(0.0, rtcp.params.offset_ms);
+}
+
+TEST(RtpToNtpTests, FailsForEmptyList) {
+  RtcpMeasurements rtcp;
+  rtcp.params.calculated = true;
+
+  int64_t timestamp_ms = -1;
+  EXPECT_EQ(0u, rtcp.list.size());
+  EXPECT_FALSE(RtpToNtpMs(0, rtcp, &timestamp_ms));
+}
+
+TEST(RtpToNtpTests, FailsForNoParameters) {
+  RtcpMeasurements rtcp;
+  uint32_t ntp_sec = 1;
+  uint32_t ntp_frac = 2;
+  uint32_t timestamp = 0x12345678;
+  bool new_sr;
+  EXPECT_TRUE(UpdateRtcpList(ntp_sec, ntp_frac, timestamp, &rtcp, &new_sr));
+
+  int64_t timestamp_ms = -1;
+  EXPECT_EQ(1u, rtcp.list.size());
+  EXPECT_FALSE(rtcp.params.calculated);
+  EXPECT_FALSE(RtpToNtpMs(timestamp, rtcp, &timestamp_ms));
+}
+
 };  // namespace webrtc