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"
@@ skipping 41 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),
       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 20 matching lines @@
 }
 
 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)
-    return false;
+  format_ = config.format();

[scherkus (not reviewing), 2013/02/22 23:18:01]

it looks like the only reason for storing format_ is to check against YV12A in
other functions

in the interest of avoiding redundant member variables, could we check for
whether vpx_codec_alpha_ is non-null instead of having format_?

[vignesh, 2013/02/25 21:51:42]

Done.

+  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
+  bool can_handle = false;
+  if (cmd_line->HasSwitch(switches::kEnableVp9Playback) &&
+      config.codec() == kCodecVP9) {
+      can_handle = true;

[scherkus (not reviewing), 2013/02/22 23:18:01]

de-indent by 2

[vignesh, 2013/02/25 21:51:42]

Done.

+  }
+  if (cmd_line->HasSwitch(switches::kEnableVp8AlphaPlayback) &&
+      config.codec() == kCodecVP8 && format_ == VideoFrame::YV12A) {
+    can_handle = true;
+  }
+  if (!can_handle)
+      return false;

[scherkus (not reviewing), 2013/02/22 23:18:01]

de-indent by 2

[vignesh, 2013/02/25 21:51:42]

Done.

 
   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_err_t status = vpx_codec_dec_init(vpx_codec_,
-                                              vpx_codec_vp9_dx(),
+                                              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 vpx_codec_;
     vpx_codec_ = NULL;
     return false;
   }
 
+  if(format_ == VideoFrame::YV12A) {

[scherkus (not reviewing), 2013/02/22 23:18:01]

add space between if and (

[vignesh, 2013/02/25 21:51:42]

Done.

+    vpx_codec_alpha_ = new vpx_codec_ctx();
+    vpx_codec_dec_cfg_t vpx_config_alpha = {0};
+
+    vpx_config_alpha.w = config.coded_size().width();
+    vpx_config_alpha.h = config.coded_size().height();
+    vpx_config_alpha.threads = GetThreadCount();
+
+    status = vpx_codec_dec_init(vpx_codec_alpha_,
+                                vpx_codec_vp8_dx(),
+                                &vpx_config_alpha,
+                                0);
+    if (status != VPX_CODEC_OK) {
+      LOG(ERROR) << "vpx_codec_dec_init failed, status=" << status;
+      delete vpx_codec_alpha_;
+      vpx_codec_alpha_ = NULL;
+      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(format_ == VideoFrame::YV12A) {

[scherkus (not reviewing), 2013/02/22 23:18:01]

add space between if and (

[vignesh, 2013/02/25 21:51:42]

Done.

+

[scherkus (not reviewing), 2013/02/22 23:18:01]

nit: remove extra blank line

[vignesh, 2013/02/25 21:51:42]

Done.

+    // Pass alpha data to libvpx.
+    int64 timestamp_alpha = buffer->GetTimestamp().InMicroseconds();
+    void* user_priv_alpha = reinterpret_cast<void*>(&timestamp_alpha);
+    const uint8* side_data_id_buf = buffer->GetSideData();
+    uint64_t side_data_id = side_data_id_buf[0];
+    for (size_t i = 1; i < 8; ++i) {

[scherkus (not reviewing), 2013/02/22 23:18:01]

what's all this stuff doing?

[vignesh, 2013/02/25 21:51:42]

first 8 bytes of side_data is side_data_id in big endian format. this code
merely reads it. have added a comment.

+      side_data_id <<= 8;
+      side_data_id |= side_data_id_buf[i];
+    }
+    if (side_data_id == 1) {
+      status = vpx_codec_decode(vpx_codec_alpha_,
+                                buffer->GetSideData() + 8,

[scherkus (not reviewing), 2013/02/22 23:18:01]

what's the magic +8 for?

[vignesh, 2013/02/25 21:51:42]

first 8 bytes of side_data is side_data_id and the rest of it is actual data.
hence the +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,
+    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(format_,
                                          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(format_ == VideoFrame::YV12A) {

[scherkus (not reviewing), 2013/02/22 23:18:01]

add space between if and (

[vignesh, 2013/02/25 21:51:42]

Done.

+    if(vpx_image_alpha) {

[scherkus (not reviewing), 2013/02/22 23:18:01]

are we guaranteed to always produce an alpha image when decoding VP8A content?

i.e., do we need the opaque-setting code below?

[vignesh, 2013/02/25 21:51:42]

yes. because there could be video files with no alpha on few frames and with
alpha on few others. so in general, if we detect presence of alpha and if there
is no alpha associated with a single frame, we set it to be opaque.

+      CopyAPlane(vpx_image_alpha->planes[VPX_PLANE_Y],
+                 vpx_image->stride[VPX_PLANE_Y],
+                 vpx_image->d_h,
+                 *video_frame);
+    } else {
+      /* there is no alpha. set it to opaque */

[scherkus (not reviewing), 2013/02/22 23:18:01]

use // for comments

[vignesh, 2013/02/25 21:51:42]

Done.

+      uint64_t alpha_plane_size = vpx_image->stride[VPX_PLANE_Y] *
+                                  vpx_image->d_h;
+      unsigned char* alpha_plane = static_cast<unsigned char*>(
+                                         malloc(alpha_plane_size));

[scherkus (not reviewing), 2013/02/22 23:18:01]

this seems a bit silly: we're allocating a frame, clearing it to opaque, then
copying that data

perhaps we should add a Clear[YUVA]Plane() function?

[vignesh, 2013/02/25 21:51:42]

Adding a ClearAPlane function. Although, the notion of clearing A plane could be
confusing as it sets all the values to 255 and not 0 (255 = opaque). So perhaps
ClearAPlane isn't such a good name. Thoughts?

+      memset(alpha_plane, 255, alpha_plane_size);
+      CopyAPlane(alpha_plane,
+                 vpx_image->stride[VPX_PLANE_Y],
+                 vpx_image->d_h,
+                 *video_frame);
+      free(alpha_plane);
+    }
+  }
 }
 
 }  // namespace media