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) {
+  return CreateFrame(format, coded_size, visible_rect, natural_size, timestamp,
+                     false);
+}
+
+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,
+                                                  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();
+  frame->AllocateYUV(zero_initialize_memory);
   return frame;
 }
 
 // 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,
@@ skipping 654 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() {
+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