Add VideoFrame::CreateZeroInitializedFrame

media/base/video_frame.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_frame.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 177 matching lines @@
   return !coded_size.IsEmpty() && !visible_rect.IsEmpty() &&
          !natural_size.IsEmpty();
 }
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::CreateFrame(VideoPixelFormat format,
                                                   const gfx::Size& coded_size,
                                                   const gfx::Rect& visible_rect,
                                                   const gfx::Size& natural_size,
                                                   base::TimeDelta timestamp) {
-  if (!IsYuvPlanar(format)) {
-    NOTIMPLEMENTED();
-    return nullptr;
-  }
-
-  // Since we're creating a new YUV frame (and allocating memory for it
-  // ourselves), we can pad the requested |coded_size| if necessary if the
-  // request does not line up on sample boundaries. See discussion at
-  // http://crrev.com/1240833003
-  const gfx::Size alignment = CommonAlignment(format);
-  const gfx::Size new_coded_size =
-      gfx::Size(RoundUp(coded_size.width(), alignment.width()),
-                RoundUp(coded_size.height(), alignment.height()));
-  DCHECK((new_coded_size.width() % alignment.width() == 0) &&
-         (new_coded_size.height() % alignment.height() == 0));
-
-  const StorageType storage = STORAGE_OWNED_MEMORY;
-  if (!IsValidConfig(format, storage, new_coded_size, visible_rect,
-                     natural_size)) {
-    DLOG(ERROR) << __FUNCTION__ << " Invalid config."
-                << ConfigToString(format, storage, coded_size, visible_rect,
-                                  natural_size);
-    return nullptr;
-  }
-
-  scoped_refptr<VideoFrame> frame(new VideoFrame(
-      format, storage, new_coded_size, visible_rect, natural_size, timestamp));
-  frame->AllocateYUV();
-  return frame;
+  return CreateFrameInternal(format, coded_size, visible_rect, natural_size,
+                             timestamp, false);
 }
 
 // static
+scoped_refptr<VideoFrame> VideoFrame::CreateZeroInitializedFrame(
+    VideoPixelFormat format,
+    const gfx::Size& coded_size,
+    const gfx::Rect& visible_rect,
+    const gfx::Size& natural_size,
+    base::TimeDelta timestamp) {
+  return CreateFrameInternal(format, coded_size, visible_rect, natural_size,
+                             timestamp, true);
+}
+
+// static
 scoped_refptr<VideoFrame> VideoFrame::WrapNativeTexture(
     VideoPixelFormat format,
     const gpu::MailboxHolder& mailbox_holder,
     const ReleaseMailboxCB& mailbox_holder_release_cb,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     base::TimeDelta timestamp) {
   if (format != PIXEL_FORMAT_ARGB && format != PIXEL_FORMAT_UYVY) {
     DLOG(ERROR) << "Unsupported pixel format supported, got "
@@ skipping 650 matching lines @@
       base::AutoLock locker(release_sync_point_lock_);
       release_sync_point = release_sync_point_;
     }
     base::ResetAndReturn(&mailbox_holders_release_cb_).Run(release_sync_point);
   }
 
   for (auto& callback : done_callbacks_)
     base::ResetAndReturn(&callback).Run();
 }
 
-void VideoFrame::AllocateYUV() {
+// static
+scoped_refptr<VideoFrame> VideoFrame::CreateFrameInternal(
+    VideoPixelFormat format,
+    const gfx::Size& coded_size,
+    const gfx::Rect& visible_rect,
+    const gfx::Size& natural_size,
+    base::TimeDelta timestamp,
+    bool zero_initialize_memory) {
+  if (!IsYuvPlanar(format)) {
+    NOTIMPLEMENTED();
+    return nullptr;
+  }
+
+  // Since we're creating a new YUV frame (and allocating memory for it
+  // ourselves), we can pad the requested |coded_size| if necessary if the
+  // request does not line up on sample boundaries. See discussion at
+  // http://crrev.com/1240833003
+  const gfx::Size alignment = CommonAlignment(format);
+  const gfx::Size new_coded_size =
+      gfx::Size(RoundUp(coded_size.width(), alignment.width()),
+                RoundUp(coded_size.height(), alignment.height()));
+  DCHECK((new_coded_size.width() % alignment.width() == 0) &&
+         (new_coded_size.height() % alignment.height() == 0));
+
+  const StorageType storage = STORAGE_OWNED_MEMORY;
+  if (!IsValidConfig(format, storage, new_coded_size, visible_rect,
+                     natural_size)) {
+    DLOG(ERROR) << __FUNCTION__ << " Invalid config."
+                << ConfigToString(format, storage, coded_size, visible_rect,
+                                  natural_size);
+    return nullptr;
+  }
+
+  scoped_refptr<VideoFrame> frame(new VideoFrame(
+      format, storage, new_coded_size, visible_rect, natural_size, timestamp));
+  frame->AllocateYUV(zero_initialize_memory);
+  return frame;
+}
+
+void VideoFrame::AllocateYUV(bool zero_initialize_memory) {
   DCHECK_EQ(storage_type_, STORAGE_OWNED_MEMORY);
   static_assert(0 == kYPlane, "y plane data must be index 0");
 
   size_t data_size = 0;
   size_t offset[kMaxPlanes];
   for (size_t plane = 0; plane < NumPlanes(format_); ++plane) {
     // The *2 in alignment for height is because some formats (e.g. h264) allow
     // interlaced coding, and then the size needs to be a multiple of two
     // macroblocks (vertically). See
     // libavcodec/utils.c:avcodec_align_dimensions2().
     const size_t height = RoundUp(rows(plane), kFrameSizeAlignment * 2);
     strides_[plane] = RoundUp(row_bytes(plane), kFrameSizeAlignment);
     offset[plane] = data_size;
     data_size += height * strides_[plane];
   }
 
   // The extra line of UV being allocated is because h264 chroma MC
   // overreads by one line in some cases, see libavcodec/utils.c:
   // avcodec_align_dimensions2() and libavcodec/x86/h264_chromamc.asm:
   // put_h264_chroma_mc4_ssse3().
   DCHECK(IsValidPlane(kUPlane, format_));
   data_size += strides_[kUPlane] + kFrameSizePadding;
 
   uint8* data = reinterpret_cast<uint8*>(
       base::AlignedAlloc(data_size, kFrameAddressAlignment));
+  if (zero_initialize_memory)
+    memset(data, 0, data_size);
 
   for (size_t plane = 0; plane < NumPlanes(format_); ++plane)
     data_[plane] = data + offset[plane];
 
   AddDestructionObserver(base::Bind(&base::AlignedFree, data));
 }
 
 }  // namespace media