Add Cast PLI support on sender side.

media/cast/sender/frame_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/frame_sender.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 #include <vector>
@@ skipping 41 matching lines @@
       animated_playout_delay_(animated_playout_delay == base::TimeDelta()
                                   ? max_playout_delay
                                   : animated_playout_delay),
       send_target_playout_delay_(false),
       max_frame_rate_(max_frame_rate),
       num_aggressive_rtcp_reports_sent_(0),
       last_sent_frame_id_(0),
       latest_acked_frame_id_(0),
       duplicate_ack_counter_(0),
       congestion_control_(congestion_control),
+      picture_lost_at_receiver_(false),
       rtp_timebase_(rtp_timebase),
       is_audio_(is_audio),
       weak_factory_(this) {
   DCHECK(transport_sender_);
   DCHECK_GT(rtp_timebase_, 0);
   DCHECK(congestion_control_);
   // We assume animated content to begin with since that is the common use
   // case today.
   VLOG(1) << SENDER_SSRC << "min latency "
           << min_playout_delay_.InMilliseconds() << "max latency "
@@ skipping 140 matching lines @@
 
 void FrameSender::SendEncodedFrame(
     int requested_bitrate_before_encode,
     scoped_ptr<SenderEncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   VLOG(2) << SENDER_SSRC << "About to send another frame: last_sent="
           << last_sent_frame_id_ << ", latest_acked=" << latest_acked_frame_id_;
 
   const uint32_t frame_id = encoded_frame->frame_id;
+  const bool is_first_frame_to_be_sent = last_send_time_.is_null();
 
-  const bool is_first_frame_to_be_sent = last_send_time_.is_null();
+  if (picture_lost_at_receiver_ &&
+      (encoded_frame->dependency == EncodedFrame::KEY)) {
+    picture_lost_at_receiver_ = false;
+    DCHECK(frame_id > latest_acked_frame_id_);
+    // Cancel sending remaining frames.
+    std::vector<uint32_t> cancel_sending_frames;
+    for (uint32_t id = latest_acked_frame_id_ + 1; id < frame_id; ++id) {
+      cancel_sending_frames.push_back(id);
+    }
+    transport_sender_->CancelSendingFrames(ssrc_, cancel_sending_frames);
+  }
+
   last_send_time_ = cast_environment_->Clock()->NowTicks();
   last_sent_frame_id_ = frame_id;
   // If this is the first frame about to be sent, fake the value of
   // |latest_acked_frame_id_| to indicate the receiver starts out all caught up.
   // Also, schedule the periodic frame re-send checks.
   if (is_first_frame_to_be_sent) {
     latest_acked_frame_id_ = frame_id - 1;
     ScheduleNextResendCheck();
   }
 
@@ skipping 140 matching lines @@
       TRACE_EVENT_ASYNC_END1("cast.stream",
           is_audio_ ? "Audio Transport" : "Video Transport",
           cast_feedback.ack_frame_id,
           "RTT_usecs", current_round_trip_time_.InMicroseconds());
     }
     transport_sender_->CancelSendingFrames(ssrc_, cancel_sending_frames);
     latest_acked_frame_id_ = cast_feedback.ack_frame_id;
   }
 }
 
+void FrameSender::OnReceivedPli() {
+  picture_lost_at_receiver_ = true;
+}
+
 bool FrameSender::ShouldDropNextFrame(base::TimeDelta frame_duration) const {
   // Check that accepting the next frame won't cause more frames to become
   // in-flight than the system's design limit.
   const int count_frames_in_flight =
       GetUnacknowledgedFrameCount() + GetNumberOfFramesInEncoder();
   if (count_frames_in_flight >= kMaxUnackedFrames) {
     VLOG(1) << SENDER_SSRC << "Dropping: Too many frames would be in-flight.";
     return true;
   }
 
@@ skipping 27 matching lines @@
     VLOG(1) << SENDER_SSRC << "Dropping: In-flight duration would be too high.";
     return true;
   }
 
   // Next frame is accepted.
   return false;
 }
 
 }  // namespace cast
 }  // namespace media