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 sends key frame
+// request to the encoder on receiving Pli messages. This is used to prevent
+// sending multiple requests while the sender is waiting for an encoded key
+// frame or receiving multiple Pli messages in a short period.
+const int kMinKeyFrameRequestOnPliIntervalMs = 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 a Pli message was received, and it has been passed
+  // long enough from the last time sending key frame request on receiving a Pli
+  // message.
+  if (picture_lost_at_receiver_) {
+    const int64_t min_attemp_interval_ms =
+        std::max<int64_t>(kMinKeyFrameRequestOnPliIntervalMs,

[dcheng, 2016/03/01 23:44:13]

Just make the constant a int64_t: then I think you won't need to explicitly
specify a template param.

[xjz, 2016/03/02 04:24:17]

Done.

+                          6 * target_playout_delay_.InMilliseconds());
+    if (last_time_attempted_to_resolve_pli_.is_null() ||
+        ((reference_time - last_time_attempted_to_resolve_pli_)
+             .InMilliseconds() > min_attemp_interval_ms)) {
+      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