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 between two key frame requests. Too many Key
+// frames will reduce the dependency among frames, but reduce the picture
+// quality as well.
+const base::TimeDelta kMinKeyFrameRequestDuration =

[miu, 2016/02/26 23:36:07]

Static initializer foo: In Chromium code, we can only use POD types for
constants.  So, this needs to become (with naming change, based on later
comments):

  const int kMinPliResolveIntervalMs = 500;

[xjz, 2016/02/27 05:53:32]

Done.

+    base::TimeDelta::FromMilliseconds(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));
 
   if (!video_encoder_) {
     NOTREACHED();
     return;
   }
 
+  // Request a key frame when receive the PLI and it has been passed more than
+  // |kMinKeyFrameRequestDuration| frome encoding last key frame.
+  if (picture_lost_at_receiver_) {

[miu, 2016/02/26 23:36:07]

The client may call InsertRawVideoFrame() several times before
|last_encoded_key_frame_| is updated in OnEncodedVideoFrame().  That means we
would be making several redundant requests for key frames in the meantime.

Instead, what if the |last_encoded_key_frame_| timestamp became a
|last_attempt_to_resolve_picture_loss_| timestamp?  Then, the logic here would
look like:

  if (picture_lost_at_receiver_) {
    if (last_attempt_to_resolve_picture_loss_.is_null() ||
        ((reference_time -
last_attempt_to_resolve_picture_loss_).InMilliseconds() >
kMinPliResolveIntervalMs)) {
      video_encoder_->GenerateKeyFrame();
      last_attempt_to_resolve_picture_loss_ = reference_time;
    }
    // Note: |picture_lost_at_receiver_| is cleared in FrameSender
when...blahblahblah...
  }

Also, let's move all this down to line 210.  That ensures the reference_time is
valid (monotonically increasing), which is important for this logic to work
correctly.

[xjz, 2016/02/27 05:53:32]

Done.

+    base::TimeDelta duration;
+    if (last_encoded_key_frame_ != base::TimeTicks())
+      duration = reference_time - last_encoded_key_frame_;
+    if (duration > kMinKeyFrameRequestDuration)
+      video_encoder_->GenerateKeyFrame();
+  }
+
   const RtpTimeTicks rtp_timestamp =
       RtpTimeTicks::FromTimeDelta(video_frame->timestamp(), kVideoFrequency);
   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(),
@@ skipping 132 matching lines @@
 
 void VideoSender::OnEncodedVideoFrame(
     const scoped_refptr<media::VideoFrame>& video_frame,
     int encoder_bitrate,
     scoped_ptr<SenderEncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   frames_in_encoder_--;
   DCHECK_GE(frames_in_encoder_, 0);
 
+  if (encoded_frame->dependency == EncodedFrame::KEY)
+    last_encoded_key_frame_ = encoded_frame->reference_time;
+
   duration_in_encoder_ =
       last_enqueued_frame_reference_time_ - encoded_frame->reference_time;
 
   last_reported_deadline_utilization_ = encoded_frame->deadline_utilization;
   last_reported_lossy_utilization_ = encoded_frame->lossy_utilization;
 
   TRACE_EVENT_ASYNC_END2("cast.stream", "Video Encode", video_frame.get(),
       "deadline_utilization", last_reported_deadline_utilization_,
       "lossy_utilization", last_reported_lossy_utilization_);
 
@@ skipping 12 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