Home | History | Annotate | Download | only in filters 
      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 #include <vector>
     10 
     11 #include "base/bind.h"
     12 #include "base/callback_helpers.h"
     13 #include "base/command_line.h"
     14 #include "base/location.h"
     15 #include "base/logging.h"
     16 #include "base/single_thread_task_runner.h"
     17 #include "base/stl_util.h"
     18 #include "base/strings/string_number_conversions.h"
     19 #include "base/sys_byteorder.h"
     20 #include "media/base/bind_to_current_loop.h"
     21 #include "media/base/decoder_buffer.h"
     22 #include "media/base/demuxer_stream.h"
     23 #include "media/base/limits.h"
     24 #include "media/base/media_switches.h"
     25 #include "media/base/pipeline.h"
     26 #include "media/base/video_decoder_config.h"
     27 #include "media/base/video_frame.h"
     28 #include "media/base/video_util.h"
     29 
     30 // Include libvpx header files.
     31 // VPX_CODEC_DISABLE_COMPAT excludes parts of the libvpx API that provide
     32 // backwards compatibility for legacy applications using the library.
     33 #define VPX_CODEC_DISABLE_COMPAT 1
     34 extern "C" {
     35 #include "third_party/libvpx/source/libvpx/vpx/vpx_decoder.h"
     36 #include "third_party/libvpx/source/libvpx/vpx/vpx_frame_buffer.h"
     37 #include "third_party/libvpx/source/libvpx/vpx/vp8dx.h"
     38 }
     39 
     40 namespace media {
     41 
     42 // Always try to use three threads for video decoding.  There is little reason
     43 // not to since current day CPUs tend to be multi-core and we measured
     44 // performance benefits on older machines such as P4s with hyperthreading.
     45 static const int kDecodeThreads = 2;
     46 static const int kMaxDecodeThreads = 16;
     47 
     48 // Returns the number of threads.
     49 static int GetThreadCount(const VideoDecoderConfig& config) {
     50   // Refer to http://crbug.com/93932 for tsan suppressions on decoding.
     51   int decode_threads = kDecodeThreads;
     52 
     53   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
     54   std::string threads(cmd_line->GetSwitchValueASCII(switches::kVideoThreads));
     55   if (threads.empty() || !base::StringToInt(threads, &decode_threads)) {
     56     if (config.codec() == kCodecVP9) {
     57       // For VP9 decode when using the default thread count, increase the number
     58       // of decode threads to equal the maximum number of tiles possible for
     59       // higher resolution streams.
     60       if (config.coded_size().width() >= 2048)
     61         decode_threads = 8;
     62       else if (config.coded_size().width() >= 1024)
     63         decode_threads = 4;
     64     }
     65 
     66     return decode_threads;
     67   }
     68 
     69   decode_threads = std::max(decode_threads, 0);
     70   decode_threads = std::min(decode_threads, kMaxDecodeThreads);
     71   return decode_threads;
     72 }
     73 
     74 class VpxVideoDecoder::MemoryPool
     75     : public base::RefCountedThreadSafe<VpxVideoDecoder::MemoryPool> {
     76  public:
     77   MemoryPool();
     78 
     79   // Callback that will be called by libvpx when it needs a frame buffer.
     80   // Parameters:
     81   // |user_priv|  Private data passed to libvpx (pointer to memory pool).
     82   // |min_size|   Minimum size needed by libvpx to decompress the next frame.
     83   // |fb|         Pointer to the frame buffer to update.
     84   // Returns 0 on success. Returns < 0 on failure.
     85   static int32 GetVP9FrameBuffer(void* user_priv, size_t min_size,
     86                                  vpx_codec_frame_buffer* fb);
     87 
     88   // Callback that will be called by libvpx when the frame buffer is no longer
     89   // being used by libvpx. Parameters:
     90   // |user_priv|  Private data passed to libvpx (pointer to memory pool).
     91   // |fb|         Pointer to the frame buffer that's being released.
     92   static int32 ReleaseVP9FrameBuffer(void *user_priv,
     93                                      vpx_codec_frame_buffer *fb);
     94 
     95   // Generates a "no_longer_needed" closure that holds a reference
     96   // to this pool.
     97   base::Closure CreateFrameCallback(void* fb_priv_data);
     98 
     99  private:
    100   friend class base::RefCountedThreadSafe<VpxVideoDecoder::MemoryPool>;
    101   ~MemoryPool();
    102 
    103   // Reference counted frame buffers used for VP9 decoding. Reference counting
    104   // is done manually because both chromium and libvpx has to release this
    105   // before a buffer can be re-used.
    106   struct VP9FrameBuffer {
    107     VP9FrameBuffer() : ref_cnt(0) {}
    108     std::vector<uint8> data;
    109     uint32 ref_cnt;
    110   };
    111 
    112   // Gets the next available frame buffer for use by libvpx.
    113   VP9FrameBuffer* GetFreeFrameBuffer(size_t min_size);
    114 
    115   // Method that gets called when a VideoFrame that references this pool gets
    116   // destroyed.
    117   void OnVideoFrameDestroyed(VP9FrameBuffer* frame_buffer);
    118 
    119   // Frame buffers to be used by libvpx for VP9 Decoding.
    120   std::vector<VP9FrameBuffer*> frame_buffers_;
    121 
    122   DISALLOW_COPY_AND_ASSIGN(MemoryPool);
    123 };
    124 
    125 VpxVideoDecoder::MemoryPool::MemoryPool() {}
    126 
    127 VpxVideoDecoder::MemoryPool::~MemoryPool() {
    128   STLDeleteElements(&frame_buffers_);
    129 }
    130 
    131 VpxVideoDecoder::MemoryPool::VP9FrameBuffer*
    132     VpxVideoDecoder::MemoryPool::GetFreeFrameBuffer(size_t min_size) {
    133   // Check if a free frame buffer exists.
    134   size_t i = 0;
    135   for (; i < frame_buffers_.size(); ++i) {
    136     if (frame_buffers_[i]->ref_cnt == 0)
    137       break;
    138   }
    139 
    140   if (i == frame_buffers_.size()) {
    141     // Create a new frame buffer.
    142     frame_buffers_.push_back(new VP9FrameBuffer());
    143   }
    144 
    145   // Resize the frame buffer if necessary.
    146   if (frame_buffers_[i]->data.size() < min_size)
    147     frame_buffers_[i]->data.resize(min_size);
    148   return frame_buffers_[i];
    149 }
    150 
    151 int32 VpxVideoDecoder::MemoryPool::GetVP9FrameBuffer(
    152     void* user_priv, size_t min_size, vpx_codec_frame_buffer* fb) {
    153   DCHECK(user_priv);
    154   DCHECK(fb);
    155 
    156   VpxVideoDecoder::MemoryPool* memory_pool =
    157       static_cast<VpxVideoDecoder::MemoryPool*>(user_priv);
    158 
    159   VP9FrameBuffer* fb_to_use = memory_pool->GetFreeFrameBuffer(min_size);
    160   if (fb_to_use == NULL)
    161     return -1;
    162 
    163   fb->data = &fb_to_use->data[0];
    164   fb->size = fb_to_use->data.size();
    165   ++fb_to_use->ref_cnt;
    166 
    167   // Set the frame buffer's private data to point at the external frame buffer.
    168   fb->priv = static_cast<void*>(fb_to_use);
    169   return 0;
    170 }
    171 
    172 int32 VpxVideoDecoder::MemoryPool::ReleaseVP9FrameBuffer(
    173     void *user_priv, vpx_codec_frame_buffer *fb) {
    174   VP9FrameBuffer* frame_buffer = static_cast<VP9FrameBuffer*>(fb->priv);
    175   --frame_buffer->ref_cnt;
    176   return 0;
    177 }
    178 
    179 base::Closure VpxVideoDecoder::MemoryPool::CreateFrameCallback(
    180     void* fb_priv_data) {
    181   VP9FrameBuffer* frame_buffer = static_cast<VP9FrameBuffer*>(fb_priv_data);
    182   ++frame_buffer->ref_cnt;
    183   return BindToCurrentLoop(
    184              base::Bind(&MemoryPool::OnVideoFrameDestroyed, this,
    185                         frame_buffer));
    186 }
    187 
    188 void VpxVideoDecoder::MemoryPool::OnVideoFrameDestroyed(
    189     VP9FrameBuffer* frame_buffer) {
    190   --frame_buffer->ref_cnt;
    191 }
    192 
    193 VpxVideoDecoder::VpxVideoDecoder(
    194     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
    195     : task_runner_(task_runner),
    196       state_(kUninitialized),
    197       vpx_codec_(NULL),
    198       vpx_codec_alpha_(NULL) {}
    199 
    200 VpxVideoDecoder::~VpxVideoDecoder() {
    201   DCHECK(task_runner_->BelongsToCurrentThread());
    202   CloseDecoder();
    203 }
    204 
    205 std::string VpxVideoDecoder::GetDisplayName() const {
    206   return "VpxVideoDecoder";
    207 }
    208 
    209 void VpxVideoDecoder::Initialize(const VideoDecoderConfig& config,
    210                                  bool low_delay,
    211                                  const PipelineStatusCB& status_cb,
    212                                  const OutputCB& output_cb) {
    213   DCHECK(task_runner_->BelongsToCurrentThread());
    214   DCHECK(config.IsValidConfig());
    215   DCHECK(!config.is_encrypted());
    216   DCHECK(decode_cb_.is_null());
    217 
    218   if (!ConfigureDecoder(config)) {
    219     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
    220     return;
    221   }
    222 
    223   // Success!
    224   config_ = config;
    225   state_ = kNormal;
    226   output_cb_ = BindToCurrentLoop(output_cb);
    227   status_cb.Run(PIPELINE_OK);
    228 }
    229 
    230 static vpx_codec_ctx* InitializeVpxContext(vpx_codec_ctx* context,
    231                                            const VideoDecoderConfig& config) {
    232   context = new vpx_codec_ctx();
    233   vpx_codec_dec_cfg_t vpx_config = {0};
    234   vpx_config.w = config.coded_size().width();
    235   vpx_config.h = config.coded_size().height();
    236   vpx_config.threads = GetThreadCount(config);
    237 
    238   vpx_codec_err_t status = vpx_codec_dec_init(context,
    239                                               config.codec() == kCodecVP9 ?
    240                                                   vpx_codec_vp9_dx() :
    241                                                   vpx_codec_vp8_dx(),
    242                                               &vpx_config,
    243                                               0);
    244   if (status != VPX_CODEC_OK) {
    245     LOG(ERROR) << "vpx_codec_dec_init failed, status=" << status;
    246     delete context;
    247     return NULL;
    248   }
    249   return context;
    250 }
    251 
    252 bool VpxVideoDecoder::ConfigureDecoder(const VideoDecoderConfig& config) {
    253   if (config.codec() != kCodecVP8 && config.codec() != kCodecVP9)
    254     return false;
    255 
    256   // In VP8 videos, only those with alpha are handled by VpxVideoDecoder. All
    257   // other VP8 videos go to FFmpegVideoDecoder.
    258   if (config.codec() == kCodecVP8 && config.format() != VideoFrame::YV12A)
    259     return false;
    260 
    261   CloseDecoder();
    262 
    263   vpx_codec_ = InitializeVpxContext(vpx_codec_, config);
    264   if (!vpx_codec_)
    265     return false;
    266 
    267   // We use our own buffers for VP9 so that there is no need to copy data after
    268   // decoding.
    269   if (config.codec() == kCodecVP9) {
    270     memory_pool_ = new MemoryPool();
    271     if (vpx_codec_set_frame_buffer_functions(vpx_codec_,
    272                                              &MemoryPool::GetVP9FrameBuffer,
    273                                              &MemoryPool::ReleaseVP9FrameBuffer,
    274                                              memory_pool_.get())) {
    275       LOG(ERROR) << "Failed to configure external buffers.";
    276       return false;
    277     }
    278   }
    279 
    280   if (config.format() == VideoFrame::YV12A) {
    281     vpx_codec_alpha_ = InitializeVpxContext(vpx_codec_alpha_, config);
    282     if (!vpx_codec_alpha_)
    283       return false;
    284   }
    285 
    286   return true;
    287 }
    288 
    289 void VpxVideoDecoder::CloseDecoder() {
    290   if (vpx_codec_) {
    291     vpx_codec_destroy(vpx_codec_);
    292     delete vpx_codec_;
    293     vpx_codec_ = NULL;
    294     memory_pool_ = NULL;
    295   }
    296   if (vpx_codec_alpha_) {
    297     vpx_codec_destroy(vpx_codec_alpha_);
    298     delete vpx_codec_alpha_;
    299     vpx_codec_alpha_ = NULL;
    300   }
    301 }
    302 
    303 void VpxVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
    304                              const DecodeCB& decode_cb) {
    305   DCHECK(task_runner_->BelongsToCurrentThread());
    306   DCHECK(!decode_cb.is_null());
    307   CHECK_NE(state_, kUninitialized);
    308   CHECK(decode_cb_.is_null()) << "Overlapping decodes are not supported.";
    309 
    310   decode_cb_ = BindToCurrentLoop(decode_cb);
    311 
    312   if (state_ == kError) {
    313     base::ResetAndReturn(&decode_cb_).Run(kDecodeError);
    314     return;
    315   }
    316 
    317   // Return empty frames if decoding has finished.
    318   if (state_ == kDecodeFinished) {
    319     base::ResetAndReturn(&decode_cb_).Run(kOk);
    320     return;
    321   }
    322 
    323   DecodeBuffer(buffer);
    324 }
    325 
    326 void VpxVideoDecoder::Reset(const base::Closure& closure) {
    327   DCHECK(task_runner_->BelongsToCurrentThread());
    328   DCHECK(decode_cb_.is_null());
    329 
    330   state_ = kNormal;
    331   task_runner_->PostTask(FROM_HERE, closure);
    332 }
    333 
    334 void VpxVideoDecoder::DecodeBuffer(const scoped_refptr<DecoderBuffer>& buffer) {
    335   DCHECK(task_runner_->BelongsToCurrentThread());
    336   DCHECK_NE(state_, kUninitialized);
    337   DCHECK_NE(state_, kDecodeFinished);
    338   DCHECK_NE(state_, kError);
    339   DCHECK(!decode_cb_.is_null());
    340   DCHECK(buffer.get());
    341 
    342   // Transition to kDecodeFinished on the first end of stream buffer.
    343   if (state_ == kNormal && buffer->end_of_stream()) {
    344     state_ = kDecodeFinished;
    345     base::ResetAndReturn(&decode_cb_).Run(kOk);
    346     return;
    347   }
    348 
    349   scoped_refptr<VideoFrame> video_frame;
    350   if (!VpxDecode(buffer, &video_frame)) {
    351     state_ = kError;
    352     base::ResetAndReturn(&decode_cb_).Run(kDecodeError);
    353     return;
    354   }
    355 
    356   base::ResetAndReturn(&decode_cb_).Run(kOk);
    357 
    358   if (video_frame.get())
    359     output_cb_.Run(video_frame);
    360 }
    361 
    362 bool VpxVideoDecoder::VpxDecode(const scoped_refptr<DecoderBuffer>& buffer,
    363                                 scoped_refptr<VideoFrame>* video_frame) {
    364   DCHECK(video_frame);
    365   DCHECK(!buffer->end_of_stream());
    366 
    367   // Pass |buffer| to libvpx.
    368   int64 timestamp = buffer->timestamp().InMicroseconds();
    369   void* user_priv = reinterpret_cast<void*>(&timestamp);
    370   vpx_codec_err_t status = vpx_codec_decode(vpx_codec_,
    371                                             buffer->data(),
    372                                             buffer->data_size(),
    373                                             user_priv,
    374                                             0);
    375   if (status != VPX_CODEC_OK) {
    376     LOG(ERROR) << "vpx_codec_decode() failed, status=" << status;
    377     return false;
    378   }
    379 
    380   // Gets pointer to decoded data.
    381   vpx_codec_iter_t iter = NULL;
    382   const vpx_image_t* vpx_image = vpx_codec_get_frame(vpx_codec_, &iter);
    383   if (!vpx_image) {
    384     *video_frame = NULL;
    385     return true;
    386   }
    387 
    388   if (vpx_image->user_priv != reinterpret_cast<void*>(&timestamp)) {
    389     LOG(ERROR) << "Invalid output timestamp.";
    390     return false;
    391   }
    392 
    393   const vpx_image_t* vpx_image_alpha = NULL;
    394   if (vpx_codec_alpha_ && buffer->side_data_size() >= 8) {
    395     // Pass alpha data to libvpx.
    396     int64 timestamp_alpha = buffer->timestamp().InMicroseconds();
    397     void* user_priv_alpha = reinterpret_cast<void*>(&timestamp_alpha);
    398 
    399     // First 8 bytes of side data is side_data_id in big endian.
    400     const uint64 side_data_id = base::NetToHost64(
    401         *(reinterpret_cast<const uint64*>(buffer->side_data())));
    402     if (side_data_id == 1) {
    403       status = vpx_codec_decode(vpx_codec_alpha_,
    404                                 buffer->side_data() + 8,
    405                                 buffer->side_data_size() - 8,
    406                                 user_priv_alpha,
    407                                 0);
    408 
    409       if (status != VPX_CODEC_OK) {
    410         LOG(ERROR) << "vpx_codec_decode() failed on alpha, status=" << status;
    411         return false;
    412       }
    413 
    414       // Gets pointer to decoded data.
    415       vpx_codec_iter_t iter_alpha = NULL;
    416       vpx_image_alpha = vpx_codec_get_frame(vpx_codec_alpha_, &iter_alpha);
    417       if (!vpx_image_alpha) {
    418         *video_frame = NULL;
    419         return true;
    420       }
    421 
    422       if (vpx_image_alpha->user_priv !=
    423           reinterpret_cast<void*>(&timestamp_alpha)) {
    424         LOG(ERROR) << "Invalid output timestamp on alpha.";
    425         return false;
    426       }
    427     }
    428   }
    429 
    430   CopyVpxImageTo(vpx_image, vpx_image_alpha, video_frame);
    431   (*video_frame)->set_timestamp(base::TimeDelta::FromMicroseconds(timestamp));
    432   return true;
    433 }
    434 
    435 void VpxVideoDecoder::CopyVpxImageTo(const vpx_image* vpx_image,
    436                                      const struct vpx_image* vpx_image_alpha,
    437                                      scoped_refptr<VideoFrame>* video_frame) {
    438   CHECK(vpx_image);
    439   CHECK(vpx_image->fmt == VPX_IMG_FMT_I420 ||
    440         vpx_image->fmt == VPX_IMG_FMT_YV12 ||
    441         vpx_image->fmt == VPX_IMG_FMT_I444);
    442 
    443   VideoFrame::Format codec_format = VideoFrame::YV12;
    444   int uv_rows = (vpx_image->d_h + 1) / 2;
    445 
    446   if (vpx_image->fmt == VPX_IMG_FMT_I444) {
    447     CHECK(!vpx_codec_alpha_);
    448     codec_format = VideoFrame::YV24;
    449     uv_rows = vpx_image->d_h;
    450   } else if (vpx_codec_alpha_) {
    451     codec_format = VideoFrame::YV12A;
    452   }
    453 
    454   gfx::Size size(vpx_image->d_w, vpx_image->d_h);
    455 
    456   if (!vpx_codec_alpha_ && memory_pool_.get()) {
    457     *video_frame = VideoFrame::WrapExternalYuvData(
    458         codec_format,
    459         size, gfx::Rect(size), config_.natural_size(),
    460         vpx_image->stride[VPX_PLANE_Y],
    461         vpx_image->stride[VPX_PLANE_U],
    462         vpx_image->stride[VPX_PLANE_V],
    463         vpx_image->planes[VPX_PLANE_Y],
    464         vpx_image->planes[VPX_PLANE_U],
    465         vpx_image->planes[VPX_PLANE_V],
    466         kNoTimestamp(),
    467         memory_pool_->CreateFrameCallback(vpx_image->fb_priv));
    468     return;
    469   }
    470 
    471   *video_frame = frame_pool_.CreateFrame(
    472       codec_format,
    473       size,
    474       gfx::Rect(size),
    475       config_.natural_size(),
    476       kNoTimestamp());
    477 
    478   CopyYPlane(vpx_image->planes[VPX_PLANE_Y],
    479              vpx_image->stride[VPX_PLANE_Y],
    480              vpx_image->d_h,
    481              video_frame->get());
    482   CopyUPlane(vpx_image->planes[VPX_PLANE_U],
    483              vpx_image->stride[VPX_PLANE_U],
    484              uv_rows,
    485              video_frame->get());
    486   CopyVPlane(vpx_image->planes[VPX_PLANE_V],
    487              vpx_image->stride[VPX_PLANE_V],
    488              uv_rows,
    489              video_frame->get());
    490   if (!vpx_codec_alpha_)
    491     return;
    492   if (!vpx_image_alpha) {
    493     MakeOpaqueAPlane(
    494         vpx_image->stride[VPX_PLANE_Y], vpx_image->d_h, video_frame->get());
    495     return;
    496   }
    497   CopyAPlane(vpx_image_alpha->planes[VPX_PLANE_Y],
    498              vpx_image->stride[VPX_PLANE_Y],
    499              vpx_image->d_h,
    500              video_frame->get());
    501 }
    502 
    503 }  // namespace media
    504