cast: Support for low-latency interactive mode

media/cast/sender/video_sender.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/sender/video_sender.h"
 
 #include <algorithm>
 #include <cmath>
 #include <cstring>
 
@@ skipping 77 matching lines @@
     const PlayoutDelayChangeCB& playout_delay_change_cb)
     : FrameSender(
           cast_environment,
           false,
           transport_sender,
           kVideoFrequency,
           video_config.ssrc,
           video_config.max_frame_rate,
           video_config.min_playout_delay,
           video_config.max_playout_delay,
+          video_config.animated_playout_delay,
           video_config.use_external_encoder
               ? NewFixedCongestionControl(
                     (video_config.min_bitrate + video_config.max_bitrate) / 2)
               : NewAdaptiveCongestionControl(cast_environment->Clock(),
                                              video_config.max_bitrate,
                                              video_config.min_bitrate,
                                              video_config.max_frame_rate)),
       frames_in_encoder_(0),
       last_bitrate_(0),
       playout_delay_change_cb_(playout_delay_change_cb),
+      interactive_mode_(false),
       last_reported_deadline_utilization_(-1.0),
       last_reported_lossy_utilization_(-1.0),
       weak_factory_(this) {
   video_encoder_ = VideoEncoder::Create(
       cast_environment_,
       video_config,
       status_change_cb,
       create_vea_cb,
       create_video_encode_mem_cb);
   if (!video_encoder_) {
@@ skipping 36 matching lines @@
   LogVideoCaptureTimestamps(cast_environment_.get(), *video_frame,
                             rtp_timestamp);
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT2(
       "cast_perf_test", "InsertRawVideoFrame",
       TRACE_EVENT_SCOPE_THREAD,
       "timestamp", reference_time.ToInternalValue(),
       "rtp_timestamp", rtp_timestamp);
 
+  bool interactive_mode;
+  if (video_frame->metadata()->GetBoolean(VideoFrameMetadata::INTERACTIVE_MODE,
+                                          &interactive_mode)) {
+    if (interactive_mode && !interactive_mode_) {
+      VLOG(1) << "Interactive mode playout time " << min_playout_delay_;
+      playout_delay_change_cb_.Run(min_playout_delay_);
+    }
+    interactive_mode_ = interactive_mode;
+  }
+
   // Drop the frame if either its RTP or reference timestamp is not an increase
   // over the last frame's.  This protects: 1) the duration calculations that
   // assume timestamps are monotonically non-decreasing, and 2) assumptions made
   // deeper in the implementation where each frame's RTP timestamp needs to be
   // unique.
   if (!last_enqueued_frame_reference_time_.is_null() &&
       (!IsNewerRtpTimestamp(rtp_timestamp,
                             last_enqueued_frame_rtp_timestamp_) ||
        reference_time <= last_enqueued_frame_reference_time_)) {
     VLOG(1) << "Dropping video frame: RTP or reference time did not increase.";
@@ skipping 11 matching lines @@
   // OnEncodedVideoFrame().
   const base::TimeDelta duration_added_by_next_frame = frames_in_encoder_ > 0 ?
       reference_time - last_enqueued_frame_reference_time_ :
       base::TimeDelta::FromSecondsD(1.0 / max_frame_rate_);
 
   if (ShouldDropNextFrame(duration_added_by_next_frame)) {
     base::TimeDelta new_target_delay = std::min(
         current_round_trip_time_ * kRoundTripsNeeded +
         base::TimeDelta::FromMilliseconds(kConstantTimeMs),
         max_playout_delay_);
-    if (new_target_delay > target_playout_delay_) {
+    // In case of interactive mode, we prefer frame drops over increasing
+    // playout time.
+    if (!interactive_mode_ && new_target_delay > target_playout_delay_) {
+      // In case we detect user is no more in an interactive mode and there is
+      // a need to drop a frame, we ensure the playout delay is at-least the
+      // the starting value for playing animated content.
+      // This is intended to minimize freeze when moving from an interactive
+      // session to watching animating content while being limited by end-to-end
+      // delay.
+      VLOG(1) << "Ensure playout time is at least " << animated_playout_delay_;
+      if (new_target_delay < animated_playout_delay_)
+        new_target_delay = animated_playout_delay_;
       VLOG(1) << "New target delay: " << new_target_delay.InMilliseconds();
       playout_delay_change_cb_.Run(new_target_delay);
     }
 
     // Some encoder implementations have a frame window for analysis. Since we
     // are dropping this frame, unless we instruct the encoder to flush all the
     // frames that have been enqueued for encoding, frames_in_encoder_ and
     // last_enqueued_frame_reference_time_ will never be updated and we will
     // drop every subsequent frame for the rest of the session.
     video_encoder_->EmitFrames();
@@ skipping 150 matching lines @@
         media::VideoFrameMetadata::RESOURCE_UTILIZATION,
         encoded_frame->dependency == EncodedFrame::KEY ?
             std::min(1.0, attenuated_utilization) : attenuated_utilization);
   }
 
   SendEncodedFrame(encoder_bitrate, encoded_frame.Pass());
 }
 
 }  // namespace cast
 }  // namespace media