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"
@@ skipping 89 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 238 matching lines @@
   // Compute the time offset_in_ticks based on the incoming_rtp_timestamp_.
   if (time_offset_.InMilliseconds() == 0) {
     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_ = time_incoming_packet_ - rtp_timestamp_in_ticks;
+    ++time_offset_counter_;
   } 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;
+      if (time_offset_counter_  < 10 && time_offset < time_offset_)
+        time_offset_ = time_offset;
+      ++time_offset_counter_;

[hguihot1, 2014/03/03 23:20:59]

The previous filter was basically doing:

time_offset_ = ((7 * time_offset_) + time_offset) / 8;

Could the issue have been that when you only have for example 2 samples this was
basically doing:

time_offset_ = ((7 * first_time_offset_sample) + second_time_offset_sample) / 8;

In other words, the first sample was counting for 7/8 of the new average, vs.
only 1/8 for the second sample. In general, first samples were counting for
more.

[mikhal1, 2014/03/03 23:33:23]

That is indeed part of the problem, which can be described as follows:
1. The initial value can be very off if sender starts before receiver.
2. Given the slow adaptation of this filter, conversion from a bad value took a
very long time.
3. In an unstable wi-fi setting, these values may fluctuate significantly. We
are not interested in these fluctuations, but in finding the offset, which will
be best estimated at the best network setting, i.e. minimum value over time. 
On 2014/03/03 23:20:59, hguihot1 wrote:

[pwestin, 2014/03/03 23:35:47]

Mikhal based on the date we have seen in testing I think we should ignore the
first value

[mikhal1, 2014/03/04 00:02:37]

True, just thought of it as I was responding to hguihot.
On 2014/03/03 23:35:47, pwestin wrote:

     }
   }
   // 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 15 matching lines @@
 }
 
 void VideoReceiver::IncomingParsedRtpPacket(const uint8* payload_data,
                                             size_t payload_size,
                                             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)) {

[pwestin, 2014/03/03 23:35:47]

kMinTimeBetweenOffsetUpdatesMs should be decreased to get a faster convergence 

[mikhal1, 2014/03/04 00:02:37]

Done.

     if (time_incoming_packet_.is_null())
       InitializeTimers();
     incoming_rtp_timestamp_ = rtp_header.webrtc.header.timestamp;
     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(
@@ skipping 92 matching lines @@
 }
 
 void VideoReceiver::SendNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   rtcp_->SendRtcpFromRtpReceiver(NULL, NULL);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media