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 182 matching lines @@
       return 1;
     case PIXEL_FORMAT_MJPEG:
       return 0;
     case PIXEL_FORMAT_UNKNOWN:
       break;
   }
   NOTREACHED();
   return 0;
 }
 
+// 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;
+
+  switch (source_format) {
+    case PIXEL_FORMAT_YV12A:
+      switch (target_format) {
+        case PIXEL_FORMAT_I420:
+          return true;
+        default:
+          return false;
+      }
+    default:
+      return false;
+  }

[mcasas, 2016/02/29 23:48:01]

Hmm actually I'd say either they are the same
format, or are immediately compatible, so the
comparison should be sth reflecting that
either |source_format| or |target_format| is
PIXEL_FORMAT_{YV12,I420,YV12A}, --> OK 

otherwise we might skip previously supported 
cases?

[emircan, 2016/03/01 20:07:55]

l.206 covers the previously supported cases. 

For the new cases, I wanted to only expose PIXEL_FORMAT_YV12A->PIXEL_FORMAT_I420
because only that would be used for now. Additional cases may be added and
tested as use cases come. WDYT?

[mcasas, 2016/03/02 22:01:10]

SG。I'd say just add a comment saying that
nothing prevents trivially adding other 
triplanar-to-triplanar conversions, and change 
this code to

  return source_format == PIXEL_FORMAT_YV12A &&
         target_format == PIXEL_FORMAT_I420;

[emircan, 2016/03/03 22:05:58]

Done.

+}
+
 // 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 formats."

[mcasas, 2016/02/29 23:48:01]

s/formats./format conversion: /

[emircan, 2016/03/01 20:07:55]

Done.

+                << 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()));
   if (frame->metadata()->IsTrue(VideoFrameMetadata::END_OF_STREAM)) {
     wrapping_frame->metadata()->SetBoolean(VideoFrameMetadata::END_OF_STREAM,
-                                          true);
+                                           true);
   }

[mcasas, 2016/02/29 23:48:01]

nit: Maybe we should copy all VideoFrameMetadata::Key ?

I'm ok with crbug.com too.

[emircan, 2016/03/01 20:07:55]

Done.

 
-  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 545 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