Add histogram stats for AV sync stream offset:

webrtc/video/vie_sync_module.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/video/vie_sync_module.h"
 
+#include <algorithm>
+
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
+#include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/video/stream_synchronization.h"
+#include "webrtc/video_frame.h"
 #include "webrtc/voice_engine/include/voe_video_sync.h"
 
 namespace webrtc {
+namespace {
+bool RtpTimestampToNtp(uint32_t timestamp,
+                       const RtcpList& rtcp_list,
+                       int64_t* timestamp_ms) {
+  if (rtcp_list.size() != 2)
+    return false;

[stefan-webrtc, 2016/03/04 14:32:17]

Maybe we should simply move this check into RtpToNtpMs and remove this new
function?

[åsapersson, 2016/03/09 15:44:35]

Done.

+
+  if (!RtpToNtpMs(timestamp, rtcp_list, timestamp_ms))
+    return false;
+
+  return true;
+}
 
 int UpdateMeasurements(StreamSynchronization::Measurements* stream,
                        const RtpRtcp& rtp_rtcp, const RtpReceiver& receiver) {
   if (!receiver.Timestamp(&stream->latest_timestamp))
     return -1;
   if (!receiver.LastReceivedTimeMs(&stream->latest_receive_time_ms))
     return -1;
 
   uint32_t ntp_secs = 0;
   uint32_t ntp_frac = 0;
   uint32_t rtp_timestamp = 0;
   if (0 != rtp_rtcp.RemoteNTP(&ntp_secs,
                               &ntp_frac,
                               NULL,
                               NULL,
                               &rtp_timestamp)) {
     return -1;
   }
 
   bool new_rtcp_sr = false;
   if (!UpdateRtcpList(
       ntp_secs, ntp_frac, rtp_timestamp, &stream->rtcp, &new_rtcp_sr)) {
     return -1;
   }
 
   return 0;
 }
+}  // namespace
 
 ViESyncModule::ViESyncModule(VideoCodingModule* vcm)
     : vcm_(vcm),
+      clock_(Clock::GetRealTimeClock()),
       video_receiver_(NULL),
       video_rtp_rtcp_(NULL),
       voe_channel_id_(-1),
       voe_sync_interface_(NULL),
       last_sync_time_(TickTime::Now()),
-      sync_() {
-}
+      sync_() {}
 
 ViESyncModule::~ViESyncModule() {
 }
 
 void ViESyncModule::ConfigureSync(int voe_channel_id,
                                   VoEVideoSync* voe_sync_interface,
                                   RtpRtcp* video_rtcp_module,
                                   RtpReceiver* video_receiver) {
   if (voe_channel_id != -1)
     RTC_DCHECK(voe_sync_interface);
@@ skipping 59 matching lines @@
     return;
   }
 
   int relative_delay_ms;
   // Calculate how much later or earlier the audio stream is compared to video.
   if (!sync_->ComputeRelativeDelay(audio_measurement_, video_measurement_,
                                    &relative_delay_ms)) {
     return;
   }
 
   TRACE_COUNTER1("webrtc", "SyncCurrentVideoDelay", current_video_delay_ms);

[pbos-webrtc, 2016/03/04 14:34:27]

Can we store and use something based on these three or sync_->ComputeDelays
below? The querying looks complex?

[stefan-webrtc, 2016/03/04 14:38:55]

This is only called periodically, once per second. I think it's better to
compute the "true" sync offset for a frame as done below.

[åsapersson, 2016/03/09 15:44:35]

Acknowledged.

   TRACE_COUNTER1("webrtc", "SyncCurrentAudioDelay", current_audio_delay_ms);
   TRACE_COUNTER1("webrtc", "SyncRelativeDelay", relative_delay_ms);
   int target_audio_delay_ms = 0;
   int target_video_delay_ms = current_video_delay_ms;
   // Calculate the necessary extra audio delay and desired total video
   // delay to get the streams in sync.
   if (!sync_->ComputeDelays(relative_delay_ms,
                             current_audio_delay_ms,
                             &target_audio_delay_ms,
                             &target_video_delay_ms)) {
     return;
   }
 
   if (voe_sync_interface_->SetMinimumPlayoutDelay(
       voe_channel_id_, target_audio_delay_ms) == -1) {
     LOG(LS_ERROR) << "Error setting voice delay.";
   }
   vcm_->SetMinimumPlayoutDelay(target_video_delay_ms);
 }
 
+int64_t ViESyncModule::GetStreamSyncOffsetInMs(const VideoFrame& frame) {
+  rtc::CritScope lock(&data_cs_);
+  if (voe_channel_id_ == -1)
+    return -1;
+
+  uint32_t playout_timestamp = 0;
+  if (voe_sync_interface_->GetPlayoutTimestamp(voe_channel_id_,
+                                               playout_timestamp) != 0) {
+    return -1;
+  }
+  int64_t latest_audio_ntp;
+  if (!RtpTimestampToNtp(playout_timestamp, audio_measurement_.rtcp,
+                         &latest_audio_ntp)) {
+    return -1;
+  }
+  int64_t latest_video_ntp;
+  if (!RtpTimestampToNtp(frame.timestamp(), video_measurement_.rtcp,
+                         &latest_video_ntp)) {
+    return -1;
+  }
+  int64_t time_to_render_ms =
+      frame.render_time_ms() - clock_->TimeInMilliseconds();
+  if (time_to_render_ms > 0)
+    latest_video_ntp += time_to_render_ms;
+
+  return std::abs(latest_audio_ntp - latest_video_ntp);
+}
+
 }  // namespace webrtc