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

media/base/video_util.cc

 // Copyright (c) 2012 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/base/video_util.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/numerics/safe_math.h"
 #include "media/base/video_frame.h"
 #include "media/base/yuv_convert.h"
+#include "third_party/libyuv/include/libyuv.h"
 
 namespace media {
 
 namespace {
 
 // Empty method used for keeping a reference to the original media::VideoFrame.
 void ReleaseOriginalFrame(const scoped_refptr<media::VideoFrame>& frame) {}
 
 }  // namespace
 
@@ skipping 308 matching lines @@
       media::VideoFrame::WrapVideoFrame(frame, PIXEL_FORMAT_I420,
                                         frame->visible_rect(),
                                         frame->natural_size());
   if (!wrapped_frame)
     return nullptr;
   wrapped_frame->AddDestructionObserver(
       base::Bind(&ReleaseOriginalFrame, frame));
   return wrapped_frame;
 }
 
+// Helper to pad the input |frame| with the repeated last column / row.
+void Padding(uint8_t* frame,

[miu, 2016/04/30 00:41:13]

Please put this function in an anonymous namespace.

[miu, 2016/04/30 00:41:14]

naming nit: ApplyPaddingOutsideVisibleRegion() or something a bit more
descriptive?

[xjz, 2016/05/03 01:17:58]

Done. Renamed as FillRegionOutsideVisibleRect().

[xjz, 2016/05/03 01:17:58]

Done.

+             const gfx::Size& frame_size,
+             const gfx::Size& visible_size) {
+  if (!frame)

[miu, 2016/04/30 00:41:13]

This should go at the top of I420CopyWithPadding() (and return false from
there).

[xjz, 2016/05/03 01:17:58]

Done.

+    return;
+  uint8_t* dst = frame;
+  const int stride = frame_size.width();
+  if (visible_size.width() < stride) {

[miu, 2016/04/30 00:41:13]

To avoid the possibility of copying from an empty visible region, consider
adding:

  if (... && !visible_size.IsEmpty()) {

[xjz, 2016/05/03 01:17:58]

Done. Add early return when the visible region is empty.

+    const int width = visible_size.width();
+    const int pad_length = stride - visible_size.width();
+    for (int i = 0; i < visible_size.height(); ++i, dst += stride)
+      std::memset(dst + width, dst[width - 1], pad_length);
+  }
+
+  if (visible_size.height() < frame_size.height()) {

[miu, 2016/04/30 00:41:13]

Here too:

  if (... && !visible_size.IsEmpty()) {

[xjz, 2016/05/03 01:17:58]

Add early return when the visible region is empty.

+    uint8_t* src = dst - stride;
+    for (int i = visible_size.height(); i < frame_size.height();
+         ++i, dst += stride)
+      std::memcpy(dst, src, frame_size.width());
+  }
+}
+
+bool I420CopyWithPadding(const scoped_refptr<VideoFrame> src_frame,
+                         scoped_refptr<VideoFrame> dst_frame) {
+  DCHECK_GE(dst_frame->coded_size().width(), src_frame->visible_rect().width());
+  DCHECK_GE(dst_frame->coded_size().height(),

[miu, 2016/04/30 00:41:14]

Looks like this code assumes dst_frame->visible_rect().origin() is [0,0]. This
is reasonable, but you may want to add a DCHECK for that.

[xjz, 2016/05/03 01:17:58]

Done. 

+            src_frame->visible_rect().height());
+
+  if (libyuv::I420Copy(src_frame->data(media::VideoFrame::kYPlane),

[miu, 2016/04/30 00:41:13]

Please replace all data() calls with visible_data() calls for the I420Copy()
args, since it's the visible region we intend to copy here.

[xjz, 2016/05/03 01:17:58]

Done. Though I think in our application src_frame->visible_rect().origion()
should also be [0, 0].

+                       src_frame->stride(media::VideoFrame::kYPlane),
+                       src_frame->data(media::VideoFrame::kUPlane),
+                       src_frame->stride(media::VideoFrame::kUPlane),
+                       src_frame->data(media::VideoFrame::kVPlane),
+                       src_frame->stride(media::VideoFrame::kVPlane),
+                       dst_frame->data(media::VideoFrame::kYPlane),
+                       dst_frame->stride(media::VideoFrame::kYPlane),
+                       dst_frame->data(media::VideoFrame::kUPlane),
+                       dst_frame->stride(media::VideoFrame::kUPlane),
+                       dst_frame->data(media::VideoFrame::kVPlane),
+                       dst_frame->stride(media::VideoFrame::kVPlane),
+                       src_frame->visible_rect().width(),
+                       src_frame->visible_rect().height()))
+    return false;
+
+  // Padding with the repeated last column / row.
+  Padding(dst_frame->data(media::VideoFrame::kYPlane), dst_frame->coded_size(),
+          src_frame->visible_rect().size());
+  const gfx::Size uv_visible_size(src_frame->visible_rect().width() / 2,

[miu, 2016/04/30 00:41:14]

Is this correct for odd widths/heights? The logic in media::VideoFrame rounds
up. Either way, I'd suggest you call the media::VideoFrame::PlaneSize() static
function to calculate this.

[xjz, 2016/05/03 01:17:58]

Done.

+                                  src_frame->visible_rect().height() / 2);
+  const gfx::Size uv_coded_size(dst_frame->coded_size().width() / 2,
+                                dst_frame->coded_size().height() / 2);
+  Padding(dst_frame->data(media::VideoFrame::kUPlane), uv_coded_size,
+          uv_visible_size);
+  Padding(dst_frame->data(media::VideoFrame::kVPlane), uv_coded_size,
+          uv_visible_size);
+
+  return true;
+}
+
 }  // namespace media