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

webrtc/system_wrappers/source/rtp_to_ntp.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 78 matching lines @@
   return true;
 }
 
 // Converts |rtp_timestamp| to the NTP time base using the NTP and RTP timestamp
 // pairs in |rtcp|. The converted timestamp is returned in
 // |rtp_timestamp_in_ms|. This function compensates for wrap arounds in RTP
 // timestamps and returns false if it can't do the conversion due to reordering.
 bool RtpToNtpMs(int64_t rtp_timestamp,
                 const RtcpList& rtcp,
                 int64_t* rtp_timestamp_in_ms) {
+  double frequency_khz;
+  return RtpToNtpMsAndReturnFreq(rtp_timestamp, rtcp, rtp_timestamp_in_ms,
+                                 &frequency_khz);
+}
+
+bool RtpToNtpMsAndReturnFreq(int64_t rtp_timestamp,

[stefan-webrtc, 2016/10/05 14:35:46]

Instead of introducing this slightly odd function, could we instead split it up
in two?

bool GetRtpToNtpParameters(const RtcpList& rtcp, double*
estimated_frequency_khz, double* estimated_offset)

and 

bool RtpToNtpMs(int64_t rtp_timestamp, double rtp_frequency, double offset,
int64_t* rtp_timestamp_in_ms)

[åsapersson, 2016/10/09 14:22:15]

The old timestamp in the RctpList is used in RtpToNtpMs to check for wrap
around. I updated the cl so the parameters are calculated when the rtcp list is
updated, ptal. 

+                             const RtcpList& rtcp,
+                             int64_t* rtp_timestamp_in_ms,
+                             double* estimated_frequency_khz) {
   if (rtcp.size() != 2)
     return false;
 
   int64_t rtcp_ntp_ms_new = Clock::NtpToMs(rtcp.front().ntp_secs,
                                            rtcp.front().ntp_frac);
   int64_t rtcp_ntp_ms_old = Clock::NtpToMs(rtcp.back().ntp_secs,
                                            rtcp.back().ntp_frac);
   int64_t rtcp_timestamp_new = rtcp.front().rtp_timestamp;
   int64_t rtcp_timestamp_old = rtcp.back().rtp_timestamp;
   if (!CompensateForWrapAround(rtcp_timestamp_new,
@@ skipping 17 matching lines @@
   if (!CompensateForWrapAround(rtp_timestamp, rtcp_timestamp_old,
                                &rtp_timestamp_unwrapped)) {
     return false;
   }
   double rtp_timestamp_ntp_ms = (static_cast<double>(rtp_timestamp_unwrapped) -
       offset) / freq_khz + 0.5f;
   if (rtp_timestamp_ntp_ms < 0) {
     return false;
   }
   *rtp_timestamp_in_ms = rtp_timestamp_ntp_ms;
+  *estimated_frequency_khz = freq_khz;
   return true;
 }
 
 int CheckForWrapArounds(uint32_t new_timestamp, uint32_t old_timestamp) {
   if (new_timestamp < old_timestamp) {
     // This difference should be less than -2^31 if we have had a wrap around
     // (e.g. |new_timestamp| = 1, |rtcp_rtp_timestamp| = 2^32 - 1). Since it is
     // cast to a int32_t, it should be positive.
     if (static_cast<int32_t>(new_timestamp - old_timestamp) > 0) {
       // Forward wrap around.
       return 1;
     }
   } else if (static_cast<int32_t>(old_timestamp - new_timestamp) > 0) {
     // This difference should be less than -2^31 if we have had a backward wrap
     // around. Since it is cast to a int32_t, it should be positive.
     return -1;
   }
   return 0;
 }
 
 }  // namespace webrtc