Handle Alpha channel in Canvas capture

media/base/video_frame.h

 // 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.
 
 #ifndef MEDIA_BASE_VIDEO_FRAME_H_
 #define MEDIA_BASE_VIDEO_FRAME_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 361 matching lines @@
 #endif
 
   void AddSharedMemoryHandle(base::SharedMemoryHandle handle);
 
 #if defined(OS_MACOSX)
   // Returns the backing CVPixelBuffer, if present.
   // TODO(mcasas): Rename to CvPixelBuffer() to comply with Style Guide.
   CVPixelBufferRef cv_pixel_buffer() const;
 #endif
 
+  // Converts a frame with YV12A format into I420 by dropping alpha channel.

[Pawel Osciak, 2016/02/26 00:32:51]

Personally, I'm wondering if this kind of a method should be in VideoFrame
itself, not somewhere else? VF is quite complicated already...

[emircan, 2016/02/26 01:33:08]

I see your point about VF being too complicated again. However, I am modifying
private class members in this function and it belongs here more than a helper
class. WDYT?

[Pawel Osciak, 2016/02/26 01:51:25]

Honestly, I would really prefer not doing it this way. I understand this will
somewhat work, assuming only for OWNED_MEMORY *and* due to the fact how we
allocate (just one buffer) *and* how AlignedAlloc/Free work.

But this is very scary in case things change. And this is very, very non-obvious
to anyone changing this later on, for example, it's not obvious why this only
works for OWNED_MEMORY and how, if someone decides to extend this later; it's
not obvious that we may only be using one-buffer allocation and malloc/free that
stores size by itself, not using the sizes in VF, etc.

There is also the code complexity which I believe we should try not to introduce
to VF if we can help it. Could we for example use realloc outside of this class
and re-Wrap() the frame as different format?

+  bool DropYV12AAlphaChannel();
+
   // Adds a callback to be run when the VideoFrame is about to be destroyed.
   // The callback may be run from ANY THREAD, and so it is up to the client to
   // ensure thread safety.  Although read-only access to the members of this
   // VideoFrame is permitted while the callback executes (including
   // VideoFrameMetadata), clients should not assume the data pointers are
   // valid.
   void AddDestructionObserver(const base::Closure& callback);
 
   // Returns a dictionary of optional metadata.  This contains information
   // associated with the frame that downstream clients might use for frame-level
@@ skipping 65 matching lines @@
       VideoPixelFormat format,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
       base::TimeDelta timestamp,
       bool zero_initialize_memory);
 
   void AllocateYUV(bool zero_initialize_memory);
 
   // Frame format.
-  const VideoPixelFormat format_;
+  VideoPixelFormat format_;
 
   // Storage type for the different planes.
   StorageType storage_type_;  // TODO(mcasas): make const
 
   // Width and height of the video frame, in pixels. This must include pixel
   // data for the whole image; i.e. for YUV formats with subsampled chroma
   // planes, in the case that the visible portion of the image does not line up
   // on a sample boundary, |coded_size_| must be rounded up appropriately and
   // the pixel data provided for the odd pixels.
   const gfx::Size coded_size_;
@@ skipping 47 matching lines @@
   gpu::SyncToken release_sync_token_;
 
   VideoFrameMetadata metadata_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoFrame);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_VIDEO_FRAME_H_