media: Add support for playback of VP8 Alpha video streams

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 "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
+#include "base/sys_byteorder.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_switches.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 
 // Include libvpx header files.
@@ skipping 29 matching lines @@
   decode_threads = std::max(decode_threads, 0);
   decode_threads = std::min(decode_threads, kMaxDecodeThreads);
   return decode_threads;
 }
 
 VpxVideoDecoder::VpxVideoDecoder(
     const scoped_refptr<base::MessageLoopProxy>& message_loop)
     : message_loop_(message_loop),
       weak_factory_(this),
       state_(kUninitialized),
-      vpx_codec_(NULL) {
+      vpx_codec_(NULL),
+      vpx_codec_alpha_(NULL) {
 }
 
 VpxVideoDecoder::~VpxVideoDecoder() {
   DCHECK_EQ(kUninitialized, state_);
   CloseDecoder();
 }
 
 void VpxVideoDecoder::Initialize(
     const scoped_refptr<DemuxerStream>& stream,
     const PipelineStatusCB& status_cb,
@@ skipping 13 matching lines @@
   if (!ConfigureDecoder()) {
     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   // Success!
   state_ = kNormal;
   status_cb.Run(PIPELINE_OK);
 }
 
+static vpx_codec_ctx* InitializeVpxContext(vpx_codec_ctx* context,
+                                           const VideoDecoderConfig& config) {
+  context = new vpx_codec_ctx();
+  vpx_codec_dec_cfg_t vpx_config = {0};
+  vpx_config.w = config.coded_size().width();
+  vpx_config.h = config.coded_size().height();
+  vpx_config.threads = GetThreadCount();
+
+  vpx_codec_err_t status = vpx_codec_dec_init(context,
+                                              config.codec() == kCodecVP9 ?
+                                                  vpx_codec_vp9_dx() :
+                                                  vpx_codec_vp8_dx(),
+                                              &vpx_config,
+                                              0);
+  if (status != VPX_CODEC_OK) {
+    LOG(ERROR) << "vpx_codec_dec_init failed, status=" << status;
+    delete context;
+    return NULL;
+  }
+  return context;
+}
+
 bool VpxVideoDecoder::ConfigureDecoder() {
   const VideoDecoderConfig& config = demuxer_stream_->video_decoder_config();
   if (!config.IsValidConfig()) {
     DLOG(ERROR) << "Invalid video stream config: "
                 << config.AsHumanReadableString();
     return false;
   }
 
-  if (config.codec() != kCodecVP9)
+  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
+  bool can_handle = false;
+  if (cmd_line->HasSwitch(switches::kEnableVp9Playback) &&
+      config.codec() == kCodecVP9) {
+    can_handle = true;
+  }
+  if (cmd_line->HasSwitch(switches::kEnableVp8AlphaPlayback) &&
+      config.codec() == kCodecVP8 && config.format() == VideoFrame::YV12A) {
+    can_handle = true;
+  }
+  if (!can_handle)
     return false;
 
   CloseDecoder();
 
-  vpx_codec_ = new vpx_codec_ctx();
-  vpx_codec_dec_cfg_t vpx_config = {0};
-  vpx_config.w = config.coded_size().width();
-  vpx_config.h = config.coded_size().height();
-  vpx_config.threads = GetThreadCount();
+  vpx_codec_ = InitializeVpxContext(vpx_codec_, config);
+  if (!vpx_codec_)
+    return false;
 
-  vpx_codec_err_t status = vpx_codec_dec_init(vpx_codec_,
-                                              vpx_codec_vp9_dx(),
-                                              &vpx_config,
-                                              0);
-  if (status != VPX_CODEC_OK) {
-    LOG(ERROR) << "vpx_codec_dec_init failed, status=" << status;
-    delete vpx_codec_;
-    vpx_codec_ = NULL;
-    return false;
+  if (config.format() == VideoFrame::YV12A) {
+    vpx_codec_alpha_ = InitializeVpxContext(vpx_codec_alpha_, config);
+    if (!vpx_codec_alpha_)
+      return false;
   }
 
   return true;
 }
 
 void VpxVideoDecoder::CloseDecoder() {
   if (vpx_codec_) {
     vpx_codec_destroy(vpx_codec_);
     delete vpx_codec_;
     vpx_codec_ = NULL;
   }
+  if (vpx_codec_alpha_) {
+    vpx_codec_destroy(vpx_codec_alpha_);
+    delete vpx_codec_alpha_;
+    vpx_codec_alpha_ = NULL;
+  }
 }
 
 void VpxVideoDecoder::Read(const ReadCB& read_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!read_cb.is_null());
   CHECK_NE(state_, kUninitialized);
   CHECK(read_cb_.is_null()) << "Overlapping decodes are not supported.";
   read_cb_ = BindToCurrentLoop(read_cb);
 
   // Return empty frames if decoding has finished.
@@ skipping 95 matching lines @@
   }
 
   scoped_refptr<VideoFrame> video_frame;
   if (!Decode(buffer, &video_frame)) {
     state_ = kDecodeFinished;
     base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
     return;
   }
 
   // Any successful decode counts!
-  if (buffer->GetDataSize()) {
+  if (buffer->GetDataSize() && buffer->GetSideDataSize()) {
     PipelineStatistics statistics;
     statistics.video_bytes_decoded = buffer->GetDataSize();
     statistics_cb_.Run(statistics);
   }
 
   // If we didn't get a frame we need more data.
   if (!video_frame) {
     ReadFromDemuxerStream();
     return;
   }
@@ skipping 26 matching lines @@
   if (!vpx_image) {
     *video_frame = NULL;
     return true;
   }
 
   if (vpx_image->user_priv != reinterpret_cast<void*>(&timestamp)) {
     LOG(ERROR) << "Invalid output timestamp.";
     return false;
   }
 
-  CopyVpxImageTo(vpx_image, video_frame);
+  const vpx_image_t* vpx_image_alpha = NULL;
+  if (vpx_codec_alpha_ && buffer->GetSideDataSize() >= 8) {
+    // Pass alpha data to libvpx.
+    int64 timestamp_alpha = buffer->GetTimestamp().InMicroseconds();
+    void* user_priv_alpha = reinterpret_cast<void*>(&timestamp_alpha);
+
+    // First 8 bytes of side data is side_data_id in big endian.
+    const uint64 side_data_id = base::NetToHost64(
+        *(reinterpret_cast<const uint64*>(buffer->GetSideData())));
+    if (side_data_id == 1) {
+      status = vpx_codec_decode(vpx_codec_alpha_,
+                                buffer->GetSideData() + 8,
+                                buffer->GetSideDataSize() - 8,
+                                user_priv_alpha,
+                                0);
+
+      if (status != VPX_CODEC_OK) {
+        LOG(ERROR) << "vpx_codec_decode() failed on alpha, status=" << status;
+        return false;
+      }
+
+      // Gets pointer to decoded data.
+      vpx_codec_iter_t iter_alpha = NULL;
+      vpx_image_alpha = vpx_codec_get_frame(vpx_codec_alpha_, &iter_alpha);
+      if (!vpx_image_alpha) {
+        *video_frame = NULL;
+        return true;
+      }
+
+      if (vpx_image_alpha->user_priv !=
+          reinterpret_cast<void*>(&timestamp_alpha)) {
+        LOG(ERROR) << "Invalid output timestamp on alpha.";
+        return false;
+      }
+    }
+  }
+
+  CopyVpxImageTo(vpx_image, vpx_image_alpha, video_frame);
   (*video_frame)->SetTimestamp(base::TimeDelta::FromMicroseconds(timestamp));
   return true;
 }
 
 void VpxVideoDecoder::DoReset() {
   DCHECK(read_cb_.is_null());
 
   state_ = kNormal;
   reset_cb_.Run();
   reset_cb_.Reset();
 }
 
 void VpxVideoDecoder::CopyVpxImageTo(
     const vpx_image* vpx_image,
+    const struct vpx_image* vpx_image_alpha,
     scoped_refptr<VideoFrame>* video_frame) {
   CHECK(vpx_image);
   CHECK_EQ(vpx_image->d_w % 2, 0U);
   CHECK_EQ(vpx_image->d_h % 2, 0U);
   CHECK(vpx_image->fmt == VPX_IMG_FMT_I420 ||
         vpx_image->fmt == VPX_IMG_FMT_YV12);
 
   gfx::Size size(vpx_image->d_w, vpx_image->d_h);
   gfx::Size natural_size =
       demuxer_stream_->video_decoder_config().natural_size();
 
-  *video_frame = VideoFrame::CreateFrame(VideoFrame::YV12,
+  *video_frame = VideoFrame::CreateFrame(vpx_codec_alpha_ ?
+                                             VideoFrame::YV12A :
+                                             VideoFrame::YV12,
                                          size,
                                          gfx::Rect(size),
                                          natural_size,
                                          kNoTimestamp());
+
   CopyYPlane(vpx_image->planes[VPX_PLANE_Y],
              vpx_image->stride[VPX_PLANE_Y],
              vpx_image->d_h,
              *video_frame);
   CopyUPlane(vpx_image->planes[VPX_PLANE_U],
              vpx_image->stride[VPX_PLANE_U],
              vpx_image->d_h / 2,
              *video_frame);
   CopyVPlane(vpx_image->planes[VPX_PLANE_V],
              vpx_image->stride[VPX_PLANE_V],
              vpx_image->d_h / 2,
              *video_frame);
+  if (!vpx_codec_alpha_)
+    return;
+  if (!vpx_image_alpha) {
+    MakeOpaqueAPlane(vpx_image->stride[VPX_PLANE_Y], vpx_image->d_h,
+                     *video_frame);
+    return;
+  }
+  CopyAPlane(vpx_image_alpha->planes[VPX_PLANE_Y],
+             vpx_image->stride[VPX_PLANE_Y],
+             vpx_image->d_h,
+             *video_frame);
 }
 
 }  // namespace media