media/filters/vpx_video_decoder.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/filters/vpx_video_decoder.h"
   6
   7 #include <algorithm>
   8 #include <string>
   9
  10 #include "base/bind.h"
  11 #include "base/callback_helpers.h"
  12 #include "base/command_line.h"
  13 #include "base/location.h"
  14 #include "base/logging.h"
  15 #include "base/message_loop/message_loop_proxy.h"
  16 #include "base/strings/string_number_conversions.h"
  17 #include "base/sys_byteorder.h"
  18 #include "media/base/bind_to_loop.h"
  19 #include "media/base/decoder_buffer.h"
  20 #include "media/base/demuxer_stream.h"
  21 #include "media/base/media_switches.h"
  22 #include "media/base/pipeline.h"
  23 #include "media/base/video_decoder_config.h"
  24 #include "media/base/video_frame.h"
  25 #include "media/base/video_util.h"
  26
  27 // Include libvpx header files.
  28 // VPX_CODEC_DISABLE_COMPAT excludes parts of the libvpx API that provide
  29 // backwards compatibility for legacy applications using the library.
  30 #define VPX_CODEC_DISABLE_COMPAT 1
  31 extern "C" {
  32 #include "third_party/libvpx/source/libvpx/vpx/vpx_decoder.h"
  33 #include "third_party/libvpx/source/libvpx/vpx/vp8dx.h"
  34 }
  35
  36 namespace media {
  37
  38 // Always try to use three threads for video decoding.  There is little reason
  39 // not to since current day CPUs tend to be multi-core and we measured
  40 // performance benefits on older machines such as P4s with hyperthreading.
  41 static const int kDecodeThreads = 2;
  42 static const int kMaxDecodeThreads = 16;
  43
  44 // Returns the number of threads.
  45 static int GetThreadCount() {
  46   // TODO(scherkus): De-duplicate this function and the one used by
  47   // FFmpegVideoDecoder.
  48
  49   // Refer to http://crbug.com/93932 for tsan suppressions on decoding.
  50   int decode_threads = kDecodeThreads;
  51
  52   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
  53   std::string threads(cmd_line->GetSwitchValueASCII(switches::kVideoThreads));
  54   if (threads.empty() || !base::StringToInt(threads, &decode_threads))
  55     return decode_threads;
  56
  57   decode_threads = std::max(decode_threads, 0);
  58   decode_threads = std::min(decode_threads, kMaxDecodeThreads);
  59   return decode_threads;
  60 }
  61
  62 VpxVideoDecoder::VpxVideoDecoder(
  63     const scoped_refptr<base::MessageLoopProxy>& message_loop)
  64     : message_loop_(message_loop),
  65       weak_factory_(this),
  66       state_(kUninitialized),
  67       vpx_codec_(NULL),
  68       vpx_codec_alpha_(NULL) {
  69 }
  70
  71 VpxVideoDecoder::~VpxVideoDecoder() {
  72   DCHECK_EQ(kUninitialized, state_);
  73   CloseDecoder();
  74 }
  75
  76 void VpxVideoDecoder::Initialize(const VideoDecoderConfig& config,
  77                                  const PipelineStatusCB& status_cb) {
  78   DCHECK(message_loop_->BelongsToCurrentThread());
  79   DCHECK(config.IsValidConfig());
  80   DCHECK(!config.is_encrypted());
  81   DCHECK(decode_cb_.is_null());
  82   DCHECK(reset_cb_.is_null());
  83
  84   weak_this_ = weak_factory_.GetWeakPtr();
  85
  86   if (!ConfigureDecoder(config)) {
  87     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
  88     return;
  89   }
  90
  91   // Success!
  92   config_ = config;
  93   state_ = kNormal;
  94   status_cb.Run(PIPELINE_OK);
  95 }
  96
  97 static vpx_codec_ctx* InitializeVpxContext(vpx_codec_ctx* context,
  98                                            const VideoDecoderConfig& config) {
  99   context = new vpx_codec_ctx();
 100   vpx_codec_dec_cfg_t vpx_config = {0};
 101   vpx_config.w = config.coded_size().width();
 102   vpx_config.h = config.coded_size().height();
 103   vpx_config.threads = GetThreadCount();
 104
 105   vpx_codec_err_t status = vpx_codec_dec_init(context,
 106                                               config.codec() == kCodecVP9 ?
 107                                                   vpx_codec_vp9_dx() :
 108                                                   vpx_codec_vp8_dx(),
 109                                               &vpx_config,
 110                                               0);
 111   if (status != VPX_CODEC_OK) {
 112     LOG(ERROR) << "vpx_codec_dec_init failed, status=" << status;
 113     delete context;
 114     return NULL;
 115   }
 116   return context;
 117 }
 118
 119 bool VpxVideoDecoder::ConfigureDecoder(const VideoDecoderConfig& config) {
 120   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 121   bool can_handle = false;
 122   if (config.codec() == kCodecVP9)
 123     can_handle = true;
 124   if (!cmd_line->HasSwitch(switches::kDisableVp8AlphaPlayback) &&
 125       config.codec() == kCodecVP8 && config.format() == VideoFrame::YV12A) {
 126     can_handle = true;
 127   }
 128   if (!can_handle)
 129     return false;
 130
 131   CloseDecoder();
 132
 133   vpx_codec_ = InitializeVpxContext(vpx_codec_, config);
 134   if (!vpx_codec_)
 135     return false;
 136
 137   if (config.format() == VideoFrame::YV12A) {
 138     vpx_codec_alpha_ = InitializeVpxContext(vpx_codec_alpha_, config);
 139     if (!vpx_codec_alpha_)
 140       return false;
 141   }
 142
 143   return true;
 144 }
 145
 146 void VpxVideoDecoder::CloseDecoder() {
 147   if (vpx_codec_) {
 148     vpx_codec_destroy(vpx_codec_);
 149     delete vpx_codec_;
 150     vpx_codec_ = NULL;
 151   }
 152   if (vpx_codec_alpha_) {
 153     vpx_codec_destroy(vpx_codec_alpha_);
 154     delete vpx_codec_alpha_;
 155     vpx_codec_alpha_ = NULL;
 156   }
 157 }
 158
 159 void VpxVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
 160                              const DecodeCB& decode_cb) {
 161   DCHECK(message_loop_->BelongsToCurrentThread());
 162   DCHECK(!decode_cb.is_null());
 163   CHECK_NE(state_, kUninitialized);
 164   CHECK(decode_cb_.is_null()) << "Overlapping decodes are not supported.";
 165
 166   decode_cb_ = BindToCurrentLoop(decode_cb);
 167
 168   if (state_ == kError) {
 169     base::ResetAndReturn(&decode_cb_).Run(kDecodeError, NULL);
 170     return;
 171   }
 172
 173   // Return empty frames if decoding has finished.
 174   if (state_ == kDecodeFinished) {
 175     base::ResetAndReturn(&decode_cb_).Run(kOk, VideoFrame::CreateEmptyFrame());
 176     return;
 177   }
 178
 179   DecodeBuffer(buffer);
 180 }
 181
 182 void VpxVideoDecoder::Reset(const base::Closure& closure) {
 183   DCHECK(message_loop_->BelongsToCurrentThread());
 184   DCHECK(reset_cb_.is_null());
 185   reset_cb_ = BindToCurrentLoop(closure);
 186
 187   // Defer the reset if a decode is pending.
 188   if (!decode_cb_.is_null())
 189     return;
 190
 191   DoReset();
 192 }
 193
 194 void VpxVideoDecoder::Stop(const base::Closure& closure) {
 195   DCHECK(message_loop_->BelongsToCurrentThread());
 196   base::ScopedClosureRunner runner(BindToCurrentLoop(closure));
 197
 198   if (state_ == kUninitialized)
 199     return;
 200
 201   if (!decode_cb_.is_null()) {
 202     base::ResetAndReturn(&decode_cb_).Run(kOk, NULL);
 203     // Reset is pending only when decode is pending.
 204     if (!reset_cb_.is_null())
 205       base::ResetAndReturn(&reset_cb_).Run();
 206   }
 207
 208   state_ = kUninitialized;
 209 }
 210
 211 bool VpxVideoDecoder::HasAlpha() const {
 212   return vpx_codec_alpha_ != NULL;
 213 }
 214
 215 void VpxVideoDecoder::DecodeBuffer(const scoped_refptr<DecoderBuffer>& buffer) {
 216   DCHECK(message_loop_->BelongsToCurrentThread());
 217   DCHECK_NE(state_, kUninitialized);
 218   DCHECK_NE(state_, kDecodeFinished);
 219   DCHECK_NE(state_, kError);
 220   DCHECK(reset_cb_.is_null());
 221   DCHECK(!decode_cb_.is_null());
 222   DCHECK(buffer);
 223
 224   // Transition to kDecodeFinished on the first end of stream buffer.
 225   if (state_ == kNormal && buffer->end_of_stream()) {
 226     state_ = kDecodeFinished;
 227     base::ResetAndReturn(&decode_cb_).Run(kOk, VideoFrame::CreateEmptyFrame());
 228     return;
 229   }
 230
 231   scoped_refptr<VideoFrame> video_frame;
 232   if (!VpxDecode(buffer, &video_frame)) {
 233     state_ = kError;
 234     base::ResetAndReturn(&decode_cb_).Run(kDecodeError, NULL);
 235     return;
 236   }
 237
 238   // If we didn't get a frame we need more data.
 239   if (!video_frame.get()) {
 240     base::ResetAndReturn(&decode_cb_).Run(kNotEnoughData, NULL);
 241     return;
 242   }
 243
 244   base::ResetAndReturn(&decode_cb_).Run(kOk, video_frame);
 245 }
 246
 247 bool VpxVideoDecoder::VpxDecode(const scoped_refptr<DecoderBuffer>& buffer,
 248                                 scoped_refptr<VideoFrame>* video_frame) {
 249   DCHECK(video_frame);
 250   DCHECK(!buffer->end_of_stream());
 251
 252   // Pass |buffer| to libvpx.
 253   int64 timestamp = buffer->timestamp().InMicroseconds();
 254   void* user_priv = reinterpret_cast<void*>(&timestamp);
 255   vpx_codec_err_t status = vpx_codec_decode(vpx_codec_,
 256                                             buffer->data(),
 257                                             buffer->data_size(),
 258                                             user_priv,
 259                                             0);
 260   if (status != VPX_CODEC_OK) {
 261     LOG(ERROR) << "vpx_codec_decode() failed, status=" << status;
 262     return false;
 263   }
 264
 265   // Gets pointer to decoded data.
 266   vpx_codec_iter_t iter = NULL;
 267   const vpx_image_t* vpx_image = vpx_codec_get_frame(vpx_codec_, &iter);
 268   if (!vpx_image) {
 269     *video_frame = NULL;
 270     return true;
 271   }
 272
 273   if (vpx_image->user_priv != reinterpret_cast<void*>(&timestamp)) {
 274     LOG(ERROR) << "Invalid output timestamp.";
 275     return false;
 276   }
 277
 278   const vpx_image_t* vpx_image_alpha = NULL;
 279   if (vpx_codec_alpha_ && buffer->side_data_size() >= 8) {
 280     // Pass alpha data to libvpx.
 281     int64 timestamp_alpha = buffer->timestamp().InMicroseconds();
 282     void* user_priv_alpha = reinterpret_cast<void*>(&timestamp_alpha);
 283
 284     // First 8 bytes of side data is side_data_id in big endian.
 285     const uint64 side_data_id = base::NetToHost64(
 286         *(reinterpret_cast<const uint64*>(buffer->side_data())));
 287     if (side_data_id == 1) {
 288       status = vpx_codec_decode(vpx_codec_alpha_,
 289                                 buffer->side_data() + 8,
 290                                 buffer->side_data_size() - 8,
 291                                 user_priv_alpha,
 292                                 0);
 293
 294       if (status != VPX_CODEC_OK) {
 295         LOG(ERROR) << "vpx_codec_decode() failed on alpha, status=" << status;
 296         return false;
 297       }
 298
 299       // Gets pointer to decoded data.
 300       vpx_codec_iter_t iter_alpha = NULL;
 301       vpx_image_alpha = vpx_codec_get_frame(vpx_codec_alpha_, &iter_alpha);
 302       if (!vpx_image_alpha) {
 303         *video_frame = NULL;
 304         return true;
 305       }
 306
 307       if (vpx_image_alpha->user_priv !=
 308           reinterpret_cast<void*>(&timestamp_alpha)) {
 309         LOG(ERROR) << "Invalid output timestamp on alpha.";
 310         return false;
 311       }
 312     }
 313   }
 314
 315   CopyVpxImageTo(vpx_image, vpx_image_alpha, video_frame);
 316   (*video_frame)->SetTimestamp(base::TimeDelta::FromMicroseconds(timestamp));
 317   return true;
 318 }
 319
 320 void VpxVideoDecoder::DoReset() {
 321   DCHECK(decode_cb_.is_null());
 322
 323   state_ = kNormal;
 324   reset_cb_.Run();
 325   reset_cb_.Reset();
 326 }
 327
 328 void VpxVideoDecoder::CopyVpxImageTo(const vpx_image* vpx_image,
 329                                      const struct vpx_image* vpx_image_alpha,
 330                                      scoped_refptr<VideoFrame>* video_frame) {
 331   CHECK(vpx_image);
 332   CHECK_EQ(vpx_image->d_w % 2, 0U);
 333   CHECK_EQ(vpx_image->d_h % 2, 0U);
 334   CHECK(vpx_image->fmt == VPX_IMG_FMT_I420 ||
 335         vpx_image->fmt == VPX_IMG_FMT_YV12);
 336
 337   gfx::Size size(vpx_image->d_w, vpx_image->d_h);
 338
 339   *video_frame = VideoFrame::CreateFrame(
 340       vpx_codec_alpha_ ? VideoFrame::YV12A : VideoFrame::YV12,
 341       size,
 342       gfx::Rect(size),
 343       config_.natural_size(),
 344       kNoTimestamp());
 345
 346   CopyYPlane(vpx_image->planes[VPX_PLANE_Y],
 347              vpx_image->stride[VPX_PLANE_Y],
 348              vpx_image->d_h,
 349              video_frame->get());
 350   CopyUPlane(vpx_image->planes[VPX_PLANE_U],
 351              vpx_image->stride[VPX_PLANE_U],
 352              vpx_image->d_h / 2,
 353              video_frame->get());
 354   CopyVPlane(vpx_image->planes[VPX_PLANE_V],
 355              vpx_image->stride[VPX_PLANE_V],
 356              vpx_image->d_h / 2,
 357              video_frame->get());
 358   if (!vpx_codec_alpha_)
 359     return;
 360   if (!vpx_image_alpha) {
 361     MakeOpaqueAPlane(
 362         vpx_image->stride[VPX_PLANE_Y], vpx_image->d_h, video_frame->get());
 363     return;
 364   }
 365   CopyAPlane(vpx_image_alpha->planes[VPX_PLANE_Y],
 366              vpx_image->stride[VPX_PLANE_Y],
 367              vpx_image->d_h,
 368              video_frame->get());
 369 }
 370
 371 }  // namespace media