Memory copy the VideoFrame to match the requirement for HW encoders.

media/cast/sender/external_video_encoder.cc

Index: media/cast/sender/external_video_encoder.cc
diff --git a/media/cast/sender/external_video_encoder.cc b/media/cast/sender/external_video_encoder.cc
index 3eb7740a3c5ba7621b48054c4c7bd1a171a7ef8e..304c617332b8814f25c8be4cfa736036c2607149 100644
--- a/media/cast/sender/external_video_encoder.cc
+++ b/media/cast/sender/external_video_encoder.cc
@@ -29,6 +29,7 @@
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/sender/vp8_quantizer_parser.h"
 #include "media/filters/h264_parser.h"
+#include "third_party/libyuv/include/libyuv.h"
 
 namespace {
 
@@ -149,8 +150,38 @@ class ExternalVideoEncoder::VEAClientImpl
         video_frame, reference_time, frame_encoded_callback,
         requested_bit_rate_));
 
+    scoped_refptr<media::VideoFrame> frame = video_frame;
+    if (video_frame->coded_size() != frame_coded_size_) {

[miu, 2016/04/26 19:20:17]

For safety, we should probably:

  DCHECK_GE(frame_coded_size_.width, visible_rect.width);
  DCHECK_GE(frame_coded_size_.height, visible_rect.height);

-or-

I'm not sure whether there are transient conditions where the frame_coded_size_
might be wrong, but we should just drop frames and expect frame_coded_size_ to
be set correctly in the near future.

[xjz, 2016/04/27 22:13:54]

Done.

+      frame = VideoFrame::CreateZeroInitializedFrame(
+          video_frame->format(), frame_coded_size_, video_frame->visible_rect(),
+          video_frame->natural_size(), video_frame->timestamp());
+      if (!frame.get()) {
+        VLOG(1) << "Error: ExternalVideoEncoder: CreateFrame failed.";
+        return;
+      }
+
+      // Copy the input frame to match the input requirements for the encoder.
+      if (libyuv::I420Copy(video_frame->data(media::VideoFrame::kYPlane),
+                           video_frame->stride(media::VideoFrame::kYPlane),
+                           video_frame->data(media::VideoFrame::kUPlane),
+                           video_frame->stride(media::VideoFrame::kUPlane),
+                           video_frame->data(media::VideoFrame::kVPlane),
+                           video_frame->stride(media::VideoFrame::kVPlane),
+                           frame->data(media::VideoFrame::kYPlane),
+                           frame->stride(media::VideoFrame::kYPlane),
+                           frame->data(media::VideoFrame::kUPlane),
+                           frame->stride(media::VideoFrame::kUPlane),
+                           frame->data(media::VideoFrame::kVPlane),
+                           frame->stride(media::VideoFrame::kVPlane),
+                           video_frame->visible_rect().width(),
+                           video_frame->visible_rect().height())) {
+        VLOG(1) << "ERROR: ExternalVideoEncoder: Copy failed.";
+        return;
+      }
+    }
+
     // BitstreamBufferReady will be called once the encoder is done.
-    video_encode_accelerator_->Encode(video_frame, key_frame_requested);
+    video_encode_accelerator_->Encode(frame, key_frame_requested);
   }
 
  protected:
@@ -177,8 +208,8 @@ class ExternalVideoEncoder::VEAClientImpl
                                size_t output_buffer_size) final {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
-    // TODO(miu): Investigate why we are ignoring |input_count| (4) and instead
-    // using |kOutputBufferCount| (3) here.
+    frame_coded_size_ = input_coded_size;
+
     for (size_t j = 0; j < kOutputBufferCount; ++j) {
       create_video_encode_memory_cb_.Run(
           output_buffer_size,
@@ -476,6 +507,10 @@ class ExternalVideoEncoder::VEAClientImpl
   // TODO(miu): Remove after discovering cause.  http://crbug.com/519022
   bool has_seen_zero_length_encoded_frame_;
 
+  // The coded size of the video frame required by Encoder. This size is
+  // obtained from VEA through |RequireBitstreamBuffers()|.
+  gfx::Size frame_coded_size_;
+
   DISALLOW_COPY_AND_ASSIGN(VEAClientImpl);
 };