Add Cast PLI support on sender side.

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 <stdint.h>
 #include <algorithm>
 #include <cmath>
 #include <cstring>
@@ skipping 23 matching lines @@
 // network quality (e.g., additional time that accounts for encode and decode
 // time).
 const int kConstantTimeMs = 75;
 
 // The target maximum utilization of the encoder and network resources.  This is
 // used to attenuate the actual measured utilization values in order to provide
 // "breathing room" (i.e., to ensure there will be sufficient CPU and bandwidth
 // available to handle the occasional more-complex frames).
 const int kTargetUtilizationPercentage = 75;
 
+// This is the minimum duration in milliseconds that the sender will respond to

[miu, 2016/02/29 23:00:45]

Hmm...This comment and var name still aren't quite right.  This is really the
"attempt interval."  The sender will respond immediately (without waiting) to
PLI's.  This variable just controls how often, after each attempt, the sender
will wait before trying to force another key frame while the PLI condition is
still present.

[xjz, 2016/03/01 01:14:27]

Renamed to |kMinKeyFrameRequestOnPliIntervalMs|.

+// multiple Pli messages.
+const int kMinPliResponseIntervalMs = 500;
+
 // Extract capture begin/end timestamps from |video_frame|'s metadata and log
 // it.
 void LogVideoCaptureTimestamps(CastEnvironment* cast_environment,
                                const media::VideoFrame& video_frame,
                                RtpTimeTicks rtp_timestamp) {
   scoped_ptr<FrameEvent> capture_begin_event(new FrameEvent());
   capture_begin_event->type = FRAME_CAPTURE_BEGIN;
   capture_begin_event->media_type = VIDEO_EVENT;
   capture_begin_event->rtp_timestamp = rtp_timestamp;
 
@@ skipping 73 matching lines @@
   }
 
   media::cast::CastTransportRtpConfig transport_config;
   transport_config.ssrc = video_config.ssrc;
   transport_config.feedback_ssrc = video_config.receiver_ssrc;
   transport_config.rtp_payload_type = video_config.rtp_payload_type;
   transport_config.aes_key = video_config.aes_key;
   transport_config.aes_iv_mask = video_config.aes_iv_mask;
 
   transport_sender->InitializeVideo(
-      transport_config,
-      base::Bind(&VideoSender::OnReceivedCastFeedback,
+      transport_config, base::Bind(&VideoSender::OnReceivedCastFeedback,
+                                   weak_factory_.GetWeakPtr()),
+      base::Bind(&VideoSender::OnMeasuredRoundTripTime,
                  weak_factory_.GetWeakPtr()),
-      base::Bind(&VideoSender::OnMeasuredRoundTripTime,
-                 weak_factory_.GetWeakPtr()));
+      base::Bind(&VideoSender::OnReceivedPli, weak_factory_.GetWeakPtr()));
 }
 
 VideoSender::~VideoSender() {
 }
 
 void VideoSender::InsertRawVideoFrame(
     const scoped_refptr<media::VideoFrame>& video_frame,
     const base::TimeTicks& reference_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
@@ skipping 33 matching lines @@
       (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.";
     TRACE_EVENT_INSTANT2("cast.stream", "Video Frame Drop",
                          TRACE_EVENT_SCOPE_THREAD,
                          "rtp_timestamp", rtp_timestamp.lower_32_bits(),
                          "reason", "time did not increase");
     return;
   }
 
+  // Request a key frame when received a Pli message, and it has been passed
+  // more than |kMinPliResponseIntervalMs| milliseconds from the last key frame
+  // request sent to encoder.
+  if (picture_lost_at_receiver_) {
+    if (last_time_attempted_to_resolve_pli_.is_null() ||
+        ((reference_time - last_time_attempted_to_resolve_pli_)
+             .InMilliseconds() > kMinPliResponseIntervalMs)) {

[miu, 2016/02/29 23:00:45]

BTW--Thinking about this a bit more: Is 500 ms enough time?  What if, for
example, the target playout delay is set to 1000 ms?  Perhaps, instead of this
constant, we should make the interval between attempts some multiple of the
target playout delay.  OTOH:

  const int64_t min_attempt_interval_ms =
      std::max<int64_t>(500,
                        6 * target_playout_delay_.InMilliseconds());

Feel free to argue this point!  :)  I'm not exactly sure what the right answer
is here.  PLI will occur when there is lots of network congestion (packets are
being dropped).  So, I'm thinking we want to make sure sending large KFs too
frequently isn't going to make the problem even worse.

[xjz, 2016/03/01 01:14:27]

I agree. Frequent key frames also reduce the video quality. Took the suggestion.

+      video_encoder_->GenerateKeyFrame();
+      last_time_attempted_to_resolve_pli_ = reference_time;
+    }
+  }
+
   // Two video frames are needed to compute the exact media duration added by
   // the next frame.  If there are no frames in the encoder, compute a guess
   // based on the configured |max_frame_rate_|.  Any error introduced by this
   // guess will be eliminated when |duration_in_encoder_| is updated in
   // 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)) {
@@ skipping 126 matching lines @@
         media::VideoFrameMetadata::RESOURCE_UTILIZATION,
         encoded_frame->dependency == EncodedFrame::KEY ?
             std::min(1.0, attenuated_utilization) : attenuated_utilization);
   }
 
   SendEncodedFrame(encoder_bitrate, std::move(encoded_frame));
 }
 
 }  // namespace cast
 }  // namespace media