Handle Alpha channel in Canvas capture

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 <climits>
 
 #include "base/bind.h"
@@ skipping 65 matching lines @@
       // level, DmaBufs are not mappable from userspace.
       storage_type != VideoFrame::STORAGE_DMABUFS &&
 #endif
       (storage_type == VideoFrame::STORAGE_UNOWNED_MEMORY ||
        storage_type == VideoFrame::STORAGE_OWNED_MEMORY ||
        storage_type == VideoFrame::STORAGE_SHMEM ||
        storage_type == VideoFrame::STORAGE_GPU_MEMORY_BUFFERS ||
        storage_type == VideoFrame::STORAGE_MOJO_SHARED_BUFFER);
 }
 
+// Checks if |source_format| can be wrapped into a |target_format| frame.
+static bool AreValidPixelFormatsForWrap(VideoPixelFormat source_format,
+                                        VideoPixelFormat target_format) {
+  if (source_format == target_format)
+    return true;
+
+  // It is possible to add other planar to planar format conversions here if the
+  // use case is there.
+  return source_format == PIXEL_FORMAT_YV12A &&
+         target_format == PIXEL_FORMAT_I420;
+}
+
 // static
 bool VideoFrame::IsValidConfig(VideoPixelFormat format,
                                StorageType storage_type,
                                const gfx::Size& coded_size,
                                const gfx::Rect& visible_rect,
                                const gfx::Size& natural_size) {
   // Check maximum limits for all formats.
   int coded_size_area = coded_size.GetCheckedArea().ValueOrDefault(INT_MAX);
   int natural_size_area = natural_size.GetCheckedArea().ValueOrDefault(INT_MAX);
   static_assert(limits::kMaxCanvas < INT_MAX, "");
@@ skipping 275 matching lines @@
   scoped_refptr<VideoFrame> frame(new VideoFrame(
       format, storage, coded_size, visible_rect, natural_size, timestamp));
 
   frame->cv_pixel_buffer_.reset(cv_pixel_buffer, base::scoped_policy::RETAIN);
   return frame;
 }
 #endif
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::WrapVideoFrame(
-      const scoped_refptr<VideoFrame>& frame,
-      const gfx::Rect& visible_rect,
-      const gfx::Size& natural_size) {
+    const scoped_refptr<VideoFrame>& frame,
+    VideoPixelFormat format,
+    const gfx::Rect& visible_rect,
+    const gfx::Size& natural_size) {
   // Frames with textures need mailbox info propagated, and there's no support
   // for that here yet, see http://crbug/362521.
   CHECK(!frame->HasTextures());
-
   DCHECK(frame->visible_rect().Contains(visible_rect));
 
-  if (!IsValidConfig(frame->format(), frame->storage_type(),
-                     frame->coded_size(), visible_rect, natural_size)) {
+  if (!AreValidPixelFormatsForWrap(frame->format(), format)) {
+    LOG(DFATAL) << __FUNCTION__ << " Invalid format conversion."
+                << VideoPixelFormatToString(frame->format()) << " to "
+                << VideoPixelFormatToString(format);
+    return nullptr;
+  }
+
+  if (!IsValidConfig(format, frame->storage_type(), frame->coded_size(),
+                     visible_rect, natural_size)) {
     LOG(DFATAL) << __FUNCTION__ << " Invalid config."
-                << ConfigToString(frame->format(), frame->storage_type(),
+                << ConfigToString(format, frame->storage_type(),
                                   frame->coded_size(), visible_rect,
                                   natural_size);
     return nullptr;
   }
 
-  scoped_refptr<VideoFrame> wrapping_frame(new VideoFrame(
-      frame->format(), frame->storage_type(), frame->coded_size(), visible_rect,
-      natural_size, frame->timestamp()));
+  scoped_refptr<VideoFrame> wrapping_frame(
+      new VideoFrame(format, frame->storage_type(), frame->coded_size(),
+                     visible_rect, natural_size, frame->timestamp()));
 
   // Copy all metadata to the wrapped frame.
   wrapping_frame->metadata()->MergeMetadataFrom(frame->metadata());
 
-  for (size_t i = 0; i < NumPlanes(frame->format()); ++i) {
+  for (size_t i = 0; i < NumPlanes(format); ++i) {
     wrapping_frame->strides_[i] = frame->stride(i);
     wrapping_frame->data_[i] = frame->data(i);
   }
 
 #if defined(OS_LINUX)
   // If there are any |dmabuf_fds_| plugged in, we should duplicate them.
   if (frame->storage_type() == STORAGE_DMABUFS) {
     std::vector<int> original_fds;
     for (size_t i = 0; i < kMaxPlanes; ++i)
       original_fds.push_back(frame->dmabuf_fd(i));
@@ skipping 679 matching lines @@
   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