media/vpx: Add support for VP9 alpha channel

media/filters/vpx_video_decoder.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/filters/vpx_video_decoder.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 362 matching lines @@
   state_ = kNormal;
   // PostTask() to avoid calling |closure| inmediately.
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, closure);
 }
 
 bool VpxVideoDecoder::ConfigureDecoder(const VideoDecoderConfig& config) {
   if (config.codec() != kCodecVP8 && config.codec() != kCodecVP9)
     return false;
 
   // These are the combinations of codec-pixel format supported in principle.
-  // Note that VP9 does not support Alpha in the current implementation.
   DCHECK(
       (config.codec() == kCodecVP8 && config.format() == PIXEL_FORMAT_YV12) ||
       (config.codec() == kCodecVP8 && config.format() == PIXEL_FORMAT_YV12A) ||
       (config.codec() == kCodecVP9 && config.format() == PIXEL_FORMAT_YV12) ||
+      (config.codec() == kCodecVP9 && config.format() == PIXEL_FORMAT_YV12A) ||
       (config.codec() == kCodecVP9 && config.format() == PIXEL_FORMAT_YV24));
 
 #if !defined(DISABLE_FFMPEG_VIDEO_DECODERS)
   // When FFmpegVideoDecoder is available it handles VP8 that doesn't have
   // alpha, and VpxVideoDecoder will handle VP8 with alpha.
   if (config.codec() == kCodecVP8 && config.format() != PIXEL_FORMAT_YV12A)
     return false;
 #endif
 
   CloseDecoder();
 
   vpx_codec_ = InitializeVpxContext(vpx_codec_, config);
   if (!vpx_codec_)
     return false;
 
-  // Configure VP9 to decode on our buffers to skip a data copy on decoding.
-  if (config.codec() == kCodecVP9) {
-    DCHECK_NE(PIXEL_FORMAT_YV12A, config.format());
+  // Configure non-YV12A VP9 to decode on our buffers to skip a data copy on

[DaleCurtis, 2016/01/05 21:22:21]

I guess we can't copy into one of the buffers since each buffer may be reused
for a future frame?

[vignesh, 2016/01/06 00:07:49]

The thing is that the Y, U and V planes come from one instance of the decoder
and the Alpha plane comes from another instance of the decoder. It seems a lot
simpler to just do a copy of all the 4 planes.

[DaleCurtis, 2016/01/06 00:18:02]

Hmm, could you over allocate the first buffer and copy in the A plane? If the
non-alpha decoder isn't using that plane, seems we could avoid a copy of the
main plane (most expensive) and keep only the copy of the A plane.

[vignesh, 2016/01/08 17:53:40]

Good point, i will try it out and update the CL.

[vignesh, 2016/01/08 19:21:33]

ok, i looked into this and i'm a little confused. can you please explain a
little more about what you mean by "over allocate the first buffer" ?

as it is, we are using VideoFrame::WrapExternalYuvData for the Y,U and V planes.
Which means VideoFrame doesn't own any of those buffers. And to copy the Alpha
planes, we would need VideoFrame's own buffer. So it ends up being confusing.

[DaleCurtis, 2016/01/08 19:29:03]

Yes, you'd need to add a WrapExternalYUVA method and then change the memory pool
to allocate the space for the extra plane.  You would then copy the A plane into
the buffer owned by the memory pool -- which since the first decoder is only YUV
it would never know about.

+  // decoding. We do not use our buffers for YV12A VP9 since it involves two
+  // different instances of the decoder.
+  if (config.codec() == kCodecVP9 && config.format() != PIXEL_FORMAT_YV12A) {
     DCHECK(vpx_codec_get_caps(vpx_codec_->iface) &
            VPX_CODEC_CAP_EXTERNAL_FRAME_BUFFER);
 
     memory_pool_ = new MemoryPool();
     if (vpx_codec_set_frame_buffer_functions(vpx_codec_,
                                              &MemoryPool::GetVP9FrameBuffer,
                                              &MemoryPool::ReleaseVP9FrameBuffer,
                                              memory_pool_.get())) {
       DLOG(ERROR) << "Failed to configure external buffers. "
                   << vpx_codec_error(vpx_codec_);
@@ skipping 158 matching lines @@
 
   // The mixed |w|/|d_h| in |coded_size| is intentional. Setting the correct
   // coded width is necessary to allow coalesced memory access, which may avoid
   // frame copies. Setting the correct coded height however does not have any
   // benefit, and only risk copying too much data.
   const gfx::Size coded_size(vpx_image->w, vpx_image->d_h);
   const gfx::Size visible_size(vpx_image->d_w, vpx_image->d_h);
 
   if (memory_pool_.get()) {
     DCHECK_EQ(kCodecVP9, config_.codec());
-    DCHECK(!vpx_codec_alpha_) << "Uh-oh, VP9 and Alpha shouldn't coexist.";
+    DCHECK(!vpx_codec_alpha_);
     *video_frame = VideoFrame::WrapExternalYuvData(
         codec_format,
         coded_size, gfx::Rect(visible_size), config_.natural_size(),
         vpx_image->stride[VPX_PLANE_Y],
         vpx_image->stride[VPX_PLANE_U],
         vpx_image->stride[VPX_PLANE_V],
         vpx_image->planes[VPX_PLANE_Y],
         vpx_image->planes[VPX_PLANE_U],
         vpx_image->planes[VPX_PLANE_V],
         kNoTimestamp());
@@ skipping 25 matching lines @@
       (*video_frame)->visible_data(VideoFrame::kUPlane),
       (*video_frame)->stride(VideoFrame::kUPlane),
       (*video_frame)->visible_data(VideoFrame::kVPlane),
       (*video_frame)->stride(VideoFrame::kVPlane), coded_size.width(),
       coded_size.height());
 
   return true;
 }
 
 }  // namespace media