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

media/base/video_util_unittest.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 <stdint.h>
 
 #include <memory>
 
 #include "base/macros.h"
 #include "media/base/video_frame.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace {
+
+// Helper function used to verify the data in the coded region after copying the
+// visible region and padding the remaining area.
+bool VerifyPlanCopyWithPadding(const uint8_t* src,
+                               size_t src_stride,
+                               // Size of visible region.
+                               const gfx::Size& src_size,
+                               const uint8_t* dst,
+                               size_t dst_stride,
+                               // Coded size of |dst|.
+                               const gfx::Size& dst_size) {
+  if (!src || !dst)
+    return false;
+
+  const size_t src_width = src_size.width();
+  const size_t src_height = src_size.height();
+  const size_t dst_width = dst_size.width();
+  const size_t dst_height = dst_size.height();
+  if (src_width > dst_width || src_width > src_stride ||
+      src_height > dst_height || src_size.IsEmpty() || dst_size.IsEmpty())
+    return false;
+
+  const uint8_t *src_ptr = src, *dst_ptr = dst;
+  for (size_t i = 0; i < src_height;
+       ++i, src_ptr += src_stride, dst_ptr += dst_stride) {
+    if (memcmp(src_ptr, dst_ptr, src_width))
+      return false;
+    for (size_t j = src_width; j < dst_width; ++j) {
+      if (src_ptr[src_width - 1] != dst_ptr[j])
+        return false;
+    }
+  }
+  if (src_height < dst_height) {
+    src_ptr = dst + (src_height - 1) * dst_stride;
+    if (memcmp(src_ptr, dst_ptr, dst_width))
+      return false;
+  }
+  return true;
+}
+
+bool VerifyCopyWithPadding(const media::VideoFrame& src_frame,
+                           const media::VideoFrame& dst_frame) {
+  if (!src_frame.IsMappable() || !dst_frame.IsMappable() ||
+      src_frame.visible_rect().size() != dst_frame.visible_rect().size())
+    return false;
+
+  if (!VerifyPlanCopyWithPadding(
+          src_frame.visible_data(media::VideoFrame::kYPlane),
+          src_frame.stride(media::VideoFrame::kYPlane),
+          src_frame.visible_rect().size(),
+          dst_frame.data(media::VideoFrame::kYPlane),
+          dst_frame.stride(media::VideoFrame::kYPlane), dst_frame.coded_size()))
+    return false;
+  if (!VerifyPlanCopyWithPadding(
+          src_frame.visible_data(media::VideoFrame::kUPlane),
+          src_frame.stride(media::VideoFrame::kUPlane),
+          media::VideoFrame::PlaneSize(media::PIXEL_FORMAT_I420,
+                                       media::VideoFrame::kUPlane,
+                                       src_frame.visible_rect().size()),
+          dst_frame.data(media::VideoFrame::kUPlane),
+          dst_frame.stride(media::VideoFrame::kUPlane),
+          media::VideoFrame::PlaneSize(media::PIXEL_FORMAT_I420,
+                                       media::VideoFrame::kUPlane,
+                                       dst_frame.coded_size())))
+    return false;
+  if (!VerifyPlanCopyWithPadding(
+          src_frame.visible_data(media::VideoFrame::kVPlane),
+          src_frame.stride(media::VideoFrame::kVPlane),
+          media::VideoFrame::PlaneSize(media::PIXEL_FORMAT_I420,
+                                       media::VideoFrame::kVPlane,
+                                       src_frame.visible_rect().size()),
+          dst_frame.data(media::VideoFrame::kVPlane),
+          dst_frame.stride(media::VideoFrame::kVPlane),
+          media::VideoFrame::PlaneSize(media::PIXEL_FORMAT_I420,
+                                       media::VideoFrame::kVPlane,
+                                       dst_frame.coded_size())))
+    return false;
+
+  return true;
+}
+
+}  // namespace
+
 namespace media {
 
 class VideoUtilTest : public testing::Test {
  public:
   VideoUtilTest()
       : height_(0),
         y_stride_(0),
         u_stride_(0),
         v_stride_(0) {
   }
@@ skipping 330 matching lines @@
                   (y / 2) * frame->stride(VideoFrame::kVPlane) + (x / 2)],
                         inside ? 0x03 : 0x80);
             }
           }
         }
       }
     }
   }
 }
 
+TEST_F(VideoUtilTest, I420CopyWithPadding) {
+  gfx::Size visible_size(40, 30);
+  scoped_refptr<VideoFrame> src_frame(VideoFrame::CreateFrame(
+      PIXEL_FORMAT_I420, visible_size, gfx::Rect(visible_size), visible_size,
+      base::TimeDelta()));
+  // Expect to return false when copying to an empty buffer.
+  EXPECT_FALSE(I420CopyWithPadding(*src_frame, nullptr));
+
+  scoped_refptr<VideoFrame> dst_frame(VideoFrame::CreateFrame(
+      PIXEL_FORMAT_I420, visible_size, gfx::Rect(visible_size), visible_size,
+      base::TimeDelta()));
+  EXPECT_TRUE(I420CopyWithPadding(*src_frame, dst_frame.get()));
+  EXPECT_TRUE(VerifyCopyWithPadding(*src_frame, *dst_frame));
+
+  gfx::Size coded_size(60, 40);
+  dst_frame = VideoFrame::CreateFrame(PIXEL_FORMAT_I420, coded_size,
+                                      gfx::Rect(visible_size), coded_size,
+                                      base::TimeDelta());
+  EXPECT_TRUE(I420CopyWithPadding(*src_frame, dst_frame.get()));
+  EXPECT_TRUE(VerifyCopyWithPadding(*src_frame, *dst_frame));
+
+  gfx::Size odd_size(39, 31);
+  src_frame =
+      VideoFrame::CreateFrame(PIXEL_FORMAT_I420, odd_size, gfx::Rect(odd_size),
+                              odd_size, base::TimeDelta());
+  dst_frame = VideoFrame::CreateFrame(PIXEL_FORMAT_I420, coded_size,
+                                      gfx::Rect(odd_size), coded_size,
+                                      base::TimeDelta());
+  EXPECT_TRUE(I420CopyWithPadding(*src_frame, dst_frame.get()));
+  EXPECT_TRUE(VerifyCopyWithPadding(*src_frame, *dst_frame));
+}
+
 }  // namespace media