Cast: Using a min filter to compute time offset

media/cast/video_receiver/video_receiver.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/video_receiver/video_receiver.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/framer/framer.h"
 #include "media/cast/rtcp/receiver_rtcp_event_subscriber.h"
 #include "media/cast/rtcp/rtcp_sender.h"
 #include "media/cast/video_receiver/video_decoder.h"
 
 namespace {
 
 static const int64 kMinSchedulingDelayMs = 1;
-static const int64 kMinTimeBetweenOffsetUpdatesMs = 2000;
-static const int kTimeOffsetFilter = 8;
+static const int64 kMinTimeBetweenOffsetUpdatesMs = 1000;
+static const int kTimeOffsetMaxCounter = 10;
 static const int64_t kMinProcessIntervalMs = 5;
 
 }  // namespace
 
 namespace media {
 namespace cast {
 
 // Local implementation of RtpData (defined in rtp_rtcp_defines.h).
 // Used to pass payload data into the video receiver.
 class LocalRtpVideoData : public RtpData {
@@ skipping 67 matching lines @@
       frame_delay_(base::TimeDelta::FromMilliseconds(
           1000 / video_config.max_frame_rate)),
       incoming_payload_callback_(new LocalRtpVideoData(this)),
       incoming_payload_feedback_(new LocalRtpVideoFeedback(this)),
       rtp_receiver_(cast_environment_->Clock(),
                     NULL,
                     &video_config,
                     incoming_payload_callback_.get()),
       rtp_video_receiver_statistics_(
           new LocalRtpReceiverStatistics(&rtp_receiver_)),
+      time_offset_counter_(0),
       decryptor_(),
       time_incoming_packet_updated_(false),
       incoming_rtp_timestamp_(0),
       weak_factory_(this) {
   int max_unacked_frames =
       video_config.rtp_max_delay_ms * video_config.max_frame_rate / 1000;
   DCHECK(max_unacked_frames) << "Invalid argument";
 
   decryptor_.Initialize(video_config.aes_key, video_config.aes_iv_mask);
   framer_.reset(new Framer(cast_environment->Clock(),
@@ skipping 229 matching lines @@
 }
 
 base::TimeTicks VideoReceiver::GetRenderTime(base::TimeTicks now,
                                              uint32 rtp_timestamp) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   // Senders time in ms when this frame was captured.
   // Note: the senders clock and our local clock might not be synced.
   base::TimeTicks rtp_timestamp_in_ticks;
 
   // Compute the time offset_in_ticks based on the incoming_rtp_timestamp_.
-  if (time_offset_.InMilliseconds() == 0) {
-    if (!rtcp_->RtpTimestampInSenderTime(kVideoFrequency,
+  if (time_offset_counter_ == 0) {
+    // Check for received RTCP to sync the stream play it out asap.
+    if (rtcp_->RtpTimestampInSenderTime(kVideoFrequency,
                                          incoming_rtp_timestamp_,
                                          &rtp_timestamp_in_ticks)) {
-      // We have not received any RTCP to sync the stream play it out as soon as
-      // possible.
-      return now;
+
+       ++time_offset_counter_;
     }
-    time_offset_ = time_incoming_packet_ - rtp_timestamp_in_ticks;
+    return now;
   } else if (time_incoming_packet_updated_) {
     if (rtcp_->RtpTimestampInSenderTime(kVideoFrequency,
                                         incoming_rtp_timestamp_,
                                         &rtp_timestamp_in_ticks)) {
       // Time to update the time_offset.
       base::TimeDelta time_offset =
           time_incoming_packet_ - rtp_timestamp_in_ticks;
-      time_offset_ = ((kTimeOffsetFilter - 1) * time_offset_ + time_offset) /
-                     kTimeOffsetFilter;
+      // Taking the minimum of the first kTimeOffsetMaxCounter values. We are
+      // assuming that we are looking for the minimum offset, which will occur
+      // when network conditions are the best. This should occur at least once
+      // within the first kTimeOffsetMaxCounter samples. Any drift should be
+      // very slow, and negligible for this use case.
+      if (time_offset_counter_ == 1)
+        time_offset_ = time_offset;
+      else if (time_offset_counter_  < kTimeOffsetMaxCounter) {
+        time_offset_ = std::min(time_offset_, time_offset);
+      }
+      ++time_offset_counter_;
     }
   }
   // Reset |time_incoming_packet_updated_| to enable a future measurement.
   time_incoming_packet_updated_ = false;
   // Compute the actual rtp_timestamp_in_ticks based on the current timestamp.
   if (!rtcp_->RtpTimestampInSenderTime(
            kVideoFrequency, rtp_timestamp, &rtp_timestamp_in_ticks)) {
     // This can fail if we have not received any RTCP packets in a long time.
     return now;
   }
@@ skipping 19 matching lines @@
                                             const RtpCastHeader& rtp_header) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   if (time_incoming_packet_.is_null() ||
       now - time_incoming_packet_ >
           base::TimeDelta::FromMilliseconds(kMinTimeBetweenOffsetUpdatesMs)) {
     if (time_incoming_packet_.is_null())
       InitializeTimers();
     incoming_rtp_timestamp_ = rtp_header.webrtc.header.timestamp;
-    time_incoming_packet_ = now;
-    time_incoming_packet_updated_ = true;
+    // The following incoming packet info is used for syncing sender and
+    // receiver clock. Use only the first packet of every frame to obtain a
+    // minimal value.
+    if (rtp_header.packet_id == 0) {
+      time_incoming_packet_ = now;
+      time_incoming_packet_updated_ = true;
+    }
   }
 
   frame_id_to_rtp_timestamp_[rtp_header.frame_id & 0xff] =
       rtp_header.webrtc.header.timestamp;
   cast_environment_->Logging()->InsertPacketEvent(
       now,
       kVideoPacketReceived,
       rtp_header.webrtc.header.timestamp,
       rtp_header.frame_id,
       rtp_header.packet_id,
@@ skipping 87 matching lines @@
 }
 
 void VideoReceiver::SendNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   rtcp_->SendRtcpFromRtpReceiver(NULL, NULL);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media