Implement adaptive target delay extension

media/cast/receiver/frame_receiver.cc

 // Copyright 2014 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/receiver/frame_receiver.h"
 
 #include <algorithm>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
@@ skipping 184 matching lines @@
     bool is_consecutively_next_frame = false;
     bool have_multiple_complete_frames = false;
     if (!framer_.GetEncodedFrame(encoded_frame.get(),
                                  &is_consecutively_next_frame,
                                  &have_multiple_complete_frames)) {
       VLOG(1) << "Wait for more packets to produce a completed frame.";
       return;  // ProcessParsedPacket() will invoke this method in the future.
     }
 
     const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
-    const base::TimeTicks playout_time =
-        GetPlayoutTime(encoded_frame->rtp_timestamp);
+    const base::TimeTicks playout_time = GetPlayoutTime(*encoded_frame);
 
     // If we have multiple decodable frames, and the current frame is
     // too old, then skip it and decode the next frame instead.
     if (have_multiple_complete_frames && now > playout_time) {
       framer_.ReleaseFrame(encoded_frame->frame_id);
       continue;
     }
 
     // If |framer_| has a frame ready that is out of sequence, examine the
     // playout time to determine whether it's acceptable to continue, thereby
@@ skipping 27 matching lines @@
         // Decryption failed.  Give up on this frame.
         framer_.ReleaseFrame(encoded_frame->frame_id);
         continue;
       }
       encoded_frame->data.swap(decrypted_data);
     }
 
     // At this point, we have a decrypted EncodedFrame ready to be emitted.
     encoded_frame->reference_time = playout_time;
     framer_.ReleaseFrame(encoded_frame->frame_id);
+    if (encoded_frame->new_playout_delay_ms) {
+      target_playout_delay_ = base::TimeDelta::FromMilliseconds(
+          encoded_frame->new_playout_delay_ms);
+    }
     cast_environment_->PostTask(CastEnvironment::MAIN,
                                 FROM_HERE,
                                 base::Bind(frame_request_queue_.front(),
                                            base::Passed(&encoded_frame)));
     frame_request_queue_.pop_front();
   }
 }
 
 void FrameReceiver::EmitAvailableEncodedFramesAfterWaiting() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(is_waiting_for_consecutive_frame_);
   is_waiting_for_consecutive_frame_ = false;
   EmitAvailableEncodedFrames();
 }
 
-base::TimeTicks FrameReceiver::GetPlayoutTime(uint32 rtp_timestamp) const {
+base::TimeTicks FrameReceiver::GetPlayoutTime(const EncodedFrame& frame) const {
+  base::TimeDelta target_playout_delay = target_playout_delay_;
+  if (frame.new_playout_delay_ms) {
+    target_playout_delay = base::TimeDelta::FromMilliseconds(
+        frame.new_playout_delay_ms);
+  }
   return lip_sync_reference_time_ +
       lip_sync_drift_.Current() +
       RtpDeltaToTimeDelta(
-          static_cast<int32>(rtp_timestamp - lip_sync_rtp_timestamp_),
+          static_cast<int32>(frame.rtp_timestamp - lip_sync_rtp_timestamp_),
           rtp_timebase_) +
-      target_playout_delay_;
+      target_playout_delay;
 }
 
 void FrameReceiver::ScheduleNextCastMessage() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   base::TimeTicks send_time;
   framer_.TimeToSendNextCastMessage(&send_time);
   base::TimeDelta time_to_send =
       send_time - cast_environment_->Clock()->NowTicks();
   time_to_send = std::max(
       time_to_send, base::TimeDelta::FromMilliseconds(kMinSchedulingDelayMs));
@@ skipping 26 matching lines @@
 }
 
 void FrameReceiver::SendNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   rtcp_.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media