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/gpu_video_decoder.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "base/bind.h"
     10 #include "base/callback_helpers.h"
     11 #include "base/command_line.h"
     12 #include "base/cpu.h"
     13 #include "base/message_loop/message_loop.h"
     14 #include "base/metrics/histogram.h"
     15 #include "base/stl_util.h"
     16 #include "base/synchronization/waitable_event.h"
     17 #include "base/task_runner_util.h"
     18 #include "gpu/command_buffer/common/mailbox_holder.h"
     19 #include "media/base/bind_to_current_loop.h"
     20 #include "media/base/decoder_buffer.h"
     21 #include "media/base/media_switches.h"
     22 #include "media/base/pipeline.h"
     23 #include "media/base/pipeline_status.h"
     24 #include "media/base/video_decoder_config.h"
     25 #include "media/filters/gpu_video_accelerator_factories.h"
     26 #include "third_party/skia/include/core/SkBitmap.h"
     27 
     28 namespace media {
     29 
     30 // Maximum number of concurrent VDA::Decode() operations GVD will maintain.
     31 // Higher values allow better pipelining in the GPU, but also require more
     32 // resources.
     33 enum { kMaxInFlightDecodes = 4 };
     34 
     35 // Size of shared-memory segments we allocate.  Since we reuse them we let them
     36 // be on the beefy side.
     37 static const size_t kSharedMemorySegmentBytes = 100 << 10;
     38 
     39 GpuVideoDecoder::SHMBuffer::SHMBuffer(base::SharedMemory* m, size_t s)
     40     : shm(m), size(s) {
     41 }
     42 
     43 GpuVideoDecoder::SHMBuffer::~SHMBuffer() {}
     44 
     45 GpuVideoDecoder::PendingDecoderBuffer::PendingDecoderBuffer(
     46     SHMBuffer* s,
     47     const scoped_refptr<DecoderBuffer>& b,
     48     const DecodeCB& done_cb)
     49     : shm_buffer(s), buffer(b), done_cb(done_cb) {
     50 }
     51 
     52 GpuVideoDecoder::PendingDecoderBuffer::~PendingDecoderBuffer() {}
     53 
     54 GpuVideoDecoder::BufferData::BufferData(
     55     int32 bbid, base::TimeDelta ts, const gfx::Rect& vr, const gfx::Size& ns)
     56     : bitstream_buffer_id(bbid), timestamp(ts), visible_rect(vr),
     57       natural_size(ns) {
     58 }
     59 
     60 GpuVideoDecoder::BufferData::~BufferData() {}
     61 
     62 GpuVideoDecoder::GpuVideoDecoder(
     63     const scoped_refptr<GpuVideoAcceleratorFactories>& factories)
     64     : needs_bitstream_conversion_(false),
     65       factories_(factories),
     66       state_(kNormal),
     67       decoder_texture_target_(0),
     68       next_picture_buffer_id_(0),
     69       next_bitstream_buffer_id_(0),
     70       available_pictures_(0),
     71       weak_factory_(this) {
     72   DCHECK(factories_.get());
     73 }
     74 
     75 void GpuVideoDecoder::Reset(const base::Closure& closure)  {
     76   DVLOG(3) << "Reset()";
     77   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
     78 
     79   if (state_ == kDrainingDecoder) {
     80     base::MessageLoop::current()->PostTask(
     81         FROM_HERE,
     82         base::Bind(
     83             &GpuVideoDecoder::Reset, weak_factory_.GetWeakPtr(), closure));
     84     return;
     85   }
     86 
     87   if (!vda_) {
     88     base::MessageLoop::current()->PostTask(FROM_HERE, closure);
     89     return;
     90   }
     91 
     92   DCHECK(pending_reset_cb_.is_null());
     93   pending_reset_cb_ = BindToCurrentLoop(closure);
     94 
     95   vda_->Reset();
     96 }
     97 
     98 static bool IsCodedSizeSupported(const gfx::Size& coded_size) {
     99 #if defined(OS_WIN)
    100   // Windows Media Foundation H.264 decoding does not support decoding videos
    101   // with any dimension smaller than 48 pixels:
    102   // http://msdn.microsoft.com/en-us/library/windows/desktop/dd797815
    103   if (coded_size.width() < 48 || coded_size.height() < 48)
    104     return false;
    105 #endif
    106 
    107   // Only non-Windows, Ivy Bridge+ platforms can support more than 1920x1080.
    108   // We test against 1088 to account for 16x16 macroblocks.
    109   if (coded_size.width() <= 1920 && coded_size.height() <= 1088)
    110     return true;
    111 
    112   // NOTE: additional autodetection logic may require updating input buffer size
    113   // selection in platform-specific implementations, such as
    114   // V4L2VideoDecodeAccelerator.
    115   base::CPU cpu;
    116   bool hw_large_video_support =
    117       CommandLine::ForCurrentProcess()->HasSwitch(
    118           switches::kIgnoreResolutionLimitsForAcceleratedVideoDecode) ||
    119       ((cpu.vendor_name() == "GenuineIntel") && cpu.model() >= 55);
    120   bool os_large_video_support = true;
    121 #if defined(OS_WIN)
    122   os_large_video_support = false;
    123 #endif
    124   return os_large_video_support && hw_large_video_support;
    125 }
    126 
    127 // Report |status| to UMA and run |cb| with it.  This is super-specific to the
    128 // UMA stat reported because the UMA_HISTOGRAM_ENUMERATION API requires a
    129 // callsite to always be called with the same stat name (can't parameterize it).
    130 static void ReportGpuVideoDecoderInitializeStatusToUMAAndRunCB(
    131     const PipelineStatusCB& cb,
    132     PipelineStatus status) {
    133   UMA_HISTOGRAM_ENUMERATION(
    134       "Media.GpuVideoDecoderInitializeStatus", status, PIPELINE_STATUS_MAX + 1);
    135   cb.Run(status);
    136 }
    137 
    138 std::string GpuVideoDecoder::GetDisplayName() const {
    139   return "GpuVideoDecoder";
    140 }
    141 
    142 void GpuVideoDecoder::Initialize(const VideoDecoderConfig& config,
    143                                  bool /* low_delay */,
    144                                  const PipelineStatusCB& orig_status_cb,
    145                                  const OutputCB& output_cb) {
    146   DVLOG(3) << "Initialize()";
    147   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    148   DCHECK(config.IsValidConfig());
    149   DCHECK(!config.is_encrypted());
    150 
    151   PipelineStatusCB status_cb =
    152       base::Bind(&ReportGpuVideoDecoderInitializeStatusToUMAAndRunCB,
    153                  BindToCurrentLoop(orig_status_cb));
    154 
    155   bool previously_initialized = config_.IsValidConfig();
    156   DVLOG(1) << "(Re)initializing GVD with config: "
    157            << config.AsHumanReadableString();
    158 
    159   // TODO(posciak): destroy and create a new VDA on codec/profile change
    160   // (http://crbug.com/260224).
    161   if (previously_initialized && (config_.profile() != config.profile())) {
    162     DVLOG(1) << "Codec or profile changed, cannot reinitialize.";
    163     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
    164     return;
    165   }
    166 
    167   if (!IsCodedSizeSupported(config.coded_size())) {
    168     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
    169     return;
    170   }
    171 
    172   config_ = config;
    173   needs_bitstream_conversion_ = (config.codec() == kCodecH264);
    174   output_cb_ = BindToCurrentLoop(output_cb);
    175 
    176   if (previously_initialized) {
    177     // Reinitialization with a different config (but same codec and profile).
    178     // VDA should handle it by detecting this in-stream by itself,
    179     // no need to notify it.
    180     status_cb.Run(PIPELINE_OK);
    181     return;
    182   }
    183 
    184   vda_ = factories_->CreateVideoDecodeAccelerator().Pass();
    185   if (!vda_ || !vda_->Initialize(config.profile(), this)) {
    186     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
    187     return;
    188   }
    189 
    190   DVLOG(3) << "GpuVideoDecoder::Initialize() succeeded.";
    191   status_cb.Run(PIPELINE_OK);
    192 }
    193 
    194 void GpuVideoDecoder::DestroyPictureBuffers(PictureBufferMap* buffers) {
    195   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    196   for (PictureBufferMap::iterator it = buffers->begin(); it != buffers->end();
    197        ++it) {
    198     factories_->DeleteTexture(it->second.texture_id());
    199   }
    200 
    201   buffers->clear();
    202 }
    203 
    204 void GpuVideoDecoder::DestroyVDA() {
    205   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    206 
    207   vda_.reset();
    208 
    209   // Not destroying PictureBuffers in |picture_buffers_at_display_| yet, since
    210   // their textures may still be in use by the user of this GpuVideoDecoder.
    211   for (PictureBufferTextureMap::iterator it =
    212            picture_buffers_at_display_.begin();
    213        it != picture_buffers_at_display_.end();
    214        ++it) {
    215     assigned_picture_buffers_.erase(it->first);
    216   }
    217   DestroyPictureBuffers(&assigned_picture_buffers_);
    218 }
    219 
    220 void GpuVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
    221                              const DecodeCB& decode_cb) {
    222   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    223   DCHECK(pending_reset_cb_.is_null());
    224 
    225   DecodeCB bound_decode_cb = BindToCurrentLoop(decode_cb);
    226 
    227   if (state_ == kError || !vda_) {
    228     bound_decode_cb.Run(kDecodeError);
    229     return;
    230   }
    231 
    232   switch (state_) {
    233     case kDecoderDrained:
    234       state_ = kNormal;
    235       // Fall-through.
    236     case kNormal:
    237       break;
    238     case kDrainingDecoder:
    239     case kError:
    240       NOTREACHED();
    241       return;
    242   }
    243 
    244   DCHECK_EQ(state_, kNormal);
    245 
    246   if (buffer->end_of_stream()) {
    247     state_ = kDrainingDecoder;
    248     eos_decode_cb_ = bound_decode_cb;
    249     vda_->Flush();
    250     return;
    251   }
    252 
    253   size_t size = buffer->data_size();
    254   SHMBuffer* shm_buffer = GetSHM(size);
    255   if (!shm_buffer) {
    256     bound_decode_cb.Run(kDecodeError);
    257     return;
    258   }
    259 
    260   memcpy(shm_buffer->shm->memory(), buffer->data(), size);
    261   BitstreamBuffer bitstream_buffer(
    262       next_bitstream_buffer_id_, shm_buffer->shm->handle(), size);
    263   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
    264   next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x3FFFFFFF;
    265   DCHECK(!ContainsKey(bitstream_buffers_in_decoder_, bitstream_buffer.id()));
    266   bitstream_buffers_in_decoder_.insert(
    267       std::make_pair(bitstream_buffer.id(),
    268                      PendingDecoderBuffer(shm_buffer, buffer, decode_cb)));
    269   DCHECK_LE(static_cast<int>(bitstream_buffers_in_decoder_.size()),
    270             kMaxInFlightDecodes);
    271   RecordBufferData(bitstream_buffer, *buffer.get());
    272 
    273   vda_->Decode(bitstream_buffer);
    274 }
    275 
    276 void GpuVideoDecoder::RecordBufferData(const BitstreamBuffer& bitstream_buffer,
    277                                        const DecoderBuffer& buffer) {
    278   input_buffer_data_.push_front(BufferData(bitstream_buffer.id(),
    279                                            buffer.timestamp(),
    280                                            config_.visible_rect(),
    281                                            config_.natural_size()));
    282   // Why this value?  Because why not.  avformat.h:MAX_REORDER_DELAY is 16, but
    283   // that's too small for some pathological B-frame test videos.  The cost of
    284   // using too-high a value is low (192 bits per extra slot).
    285   static const size_t kMaxInputBufferDataSize = 128;
    286   // Pop from the back of the list, because that's the oldest and least likely
    287   // to be useful in the future data.
    288   if (input_buffer_data_.size() > kMaxInputBufferDataSize)
    289     input_buffer_data_.pop_back();
    290 }
    291 
    292 void GpuVideoDecoder::GetBufferData(int32 id, base::TimeDelta* timestamp,
    293                                     gfx::Rect* visible_rect,
    294                                     gfx::Size* natural_size) {
    295   for (std::list<BufferData>::const_iterator it =
    296            input_buffer_data_.begin(); it != input_buffer_data_.end();
    297        ++it) {
    298     if (it->bitstream_buffer_id != id)
    299       continue;
    300     *timestamp = it->timestamp;
    301     *visible_rect = it->visible_rect;
    302     *natural_size = it->natural_size;
    303     return;
    304   }
    305   NOTREACHED() << "Missing bitstreambuffer id: " << id;
    306 }
    307 
    308 bool GpuVideoDecoder::NeedsBitstreamConversion() const {
    309   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    310   return needs_bitstream_conversion_;
    311 }
    312 
    313 bool GpuVideoDecoder::CanReadWithoutStalling() const {
    314   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    315   return
    316       next_picture_buffer_id_ == 0 ||  // Decode() will ProvidePictureBuffers().
    317       available_pictures_ > 0;
    318 }
    319 
    320 int GpuVideoDecoder::GetMaxDecodeRequests() const {
    321   return kMaxInFlightDecodes;
    322 }
    323 
    324 void GpuVideoDecoder::ProvidePictureBuffers(uint32 count,
    325                                             const gfx::Size& size,
    326                                             uint32 texture_target) {
    327   DVLOG(3) << "ProvidePictureBuffers(" << count << ", "
    328            << size.width() << "x" << size.height() << ")";
    329   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    330 
    331   std::vector<uint32> texture_ids;
    332   std::vector<gpu::Mailbox> texture_mailboxes;
    333   decoder_texture_target_ = texture_target;
    334   if (!factories_->CreateTextures(count,
    335                                   size,
    336                                   &texture_ids,
    337                                   &texture_mailboxes,
    338                                   decoder_texture_target_)) {
    339     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
    340     return;
    341   }
    342   DCHECK_EQ(count, texture_ids.size());
    343   DCHECK_EQ(count, texture_mailboxes.size());
    344 
    345   if (!vda_)
    346     return;
    347 
    348   std::vector<PictureBuffer> picture_buffers;
    349   for (size_t i = 0; i < texture_ids.size(); ++i) {
    350     picture_buffers.push_back(PictureBuffer(
    351         next_picture_buffer_id_++, size, texture_ids[i], texture_mailboxes[i]));
    352     bool inserted = assigned_picture_buffers_.insert(std::make_pair(
    353         picture_buffers.back().id(), picture_buffers.back())).second;
    354     DCHECK(inserted);
    355   }
    356 
    357   available_pictures_ += count;
    358 
    359   vda_->AssignPictureBuffers(picture_buffers);
    360 }
    361 
    362 void GpuVideoDecoder::DismissPictureBuffer(int32 id) {
    363   DVLOG(3) << "DismissPictureBuffer(" << id << ")";
    364   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    365 
    366   PictureBufferMap::iterator it = assigned_picture_buffers_.find(id);
    367   if (it == assigned_picture_buffers_.end()) {
    368     NOTREACHED() << "Missing picture buffer: " << id;
    369     return;
    370   }
    371 
    372   PictureBuffer buffer_to_dismiss = it->second;
    373   assigned_picture_buffers_.erase(it);
    374 
    375   if (!picture_buffers_at_display_.count(id)) {
    376     // We can delete the texture immediately as it's not being displayed.
    377     factories_->DeleteTexture(buffer_to_dismiss.texture_id());
    378     CHECK_GT(available_pictures_, 0);
    379     --available_pictures_;
    380   }
    381   // Not destroying a texture in display in |picture_buffers_at_display_|.
    382   // Postpone deletion until after it's returned to us.
    383 }
    384 
    385 static void ReadPixelsSyncInner(
    386     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories,
    387     uint32 texture_id,
    388     const gfx::Rect& visible_rect,
    389     const SkBitmap& pixels,
    390     base::WaitableEvent* event) {
    391   factories->ReadPixels(texture_id, visible_rect, pixels);
    392   event->Signal();
    393 }
    394 
    395 static void ReadPixelsSync(
    396     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories,
    397     uint32 texture_id,
    398     const gfx::Rect& visible_rect,
    399     const SkBitmap& pixels) {
    400   base::WaitableEvent event(true, false);
    401   if (!factories->GetTaskRunner()->PostTask(FROM_HERE,
    402                                             base::Bind(&ReadPixelsSyncInner,
    403                                                        factories,
    404                                                        texture_id,
    405                                                        visible_rect,
    406                                                        pixels,
    407                                                        &event)))
    408     return;
    409   event.Wait();
    410 }
    411 
    412 void GpuVideoDecoder::PictureReady(const media::Picture& picture) {
    413   DVLOG(3) << "PictureReady()";
    414   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    415 
    416   PictureBufferMap::iterator it =
    417       assigned_picture_buffers_.find(picture.picture_buffer_id());
    418   if (it == assigned_picture_buffers_.end()) {
    419     NOTREACHED() << "Missing picture buffer: " << picture.picture_buffer_id();
    420     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
    421     return;
    422   }
    423   const PictureBuffer& pb = it->second;
    424 
    425   // Validate picture rectangle from GPU. This is for sanity/security check
    426   // even the rectangle is not used in this class.
    427   if (picture.visible_rect().IsEmpty() ||
    428       !gfx::Rect(pb.size()).Contains(picture.visible_rect())) {
    429     NOTREACHED() << "Invalid picture size from VDA: "
    430                  << picture.visible_rect().ToString() << " should fit in "
    431                  << pb.size().ToString();
    432     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
    433     return;
    434   }
    435 
    436   // Update frame's timestamp.
    437   base::TimeDelta timestamp;
    438   // Some of the VDAs don't support and thus don't provide us with visible
    439   // size in picture.size, passing coded size instead, so always drop it and
    440   // use config information instead.
    441   gfx::Rect visible_rect;
    442   gfx::Size natural_size;
    443   GetBufferData(picture.bitstream_buffer_id(), &timestamp, &visible_rect,
    444                 &natural_size);
    445   DCHECK(decoder_texture_target_);
    446 
    447   scoped_refptr<VideoFrame> frame(VideoFrame::WrapNativeTexture(
    448       make_scoped_ptr(new gpu::MailboxHolder(
    449           pb.texture_mailbox(), decoder_texture_target_, 0 /* sync_point */)),
    450       BindToCurrentLoop(base::Bind(&GpuVideoDecoder::ReleaseMailbox,
    451                                    weak_factory_.GetWeakPtr(),
    452                                    factories_,
    453                                    picture.picture_buffer_id(),
    454                                    pb.texture_id())),
    455       pb.size(),
    456       visible_rect,
    457       natural_size,
    458       timestamp,
    459       base::Bind(&ReadPixelsSync, factories_, pb.texture_id(), visible_rect)));
    460   CHECK_GT(available_pictures_, 0);
    461   --available_pictures_;
    462   bool inserted =
    463       picture_buffers_at_display_.insert(std::make_pair(
    464                                              picture.picture_buffer_id(),
    465                                              pb.texture_id())).second;
    466   DCHECK(inserted);
    467 
    468   DeliverFrame(frame);
    469 }
    470 
    471 void GpuVideoDecoder::DeliverFrame(
    472     const scoped_refptr<VideoFrame>& frame) {
    473   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    474 
    475   // During a pending vda->Reset(), we don't accumulate frames.  Drop it on the
    476   // floor and return.
    477   if (!pending_reset_cb_.is_null())
    478     return;
    479 
    480   output_cb_.Run(frame);
    481 }
    482 
    483 // static
    484 void GpuVideoDecoder::ReleaseMailbox(
    485     base::WeakPtr<GpuVideoDecoder> decoder,
    486     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories,
    487     int64 picture_buffer_id,
    488     uint32 texture_id,
    489     uint32 release_sync_point) {
    490   DCHECK(factories->GetTaskRunner()->BelongsToCurrentThread());
    491   factories->WaitSyncPoint(release_sync_point);
    492 
    493   if (decoder) {
    494     decoder->ReusePictureBuffer(picture_buffer_id);
    495     return;
    496   }
    497   // It's the last chance to delete the texture after display,
    498   // because GpuVideoDecoder was destructed.
    499   factories->DeleteTexture(texture_id);
    500 }
    501 
    502 void GpuVideoDecoder::ReusePictureBuffer(int64 picture_buffer_id) {
    503   DVLOG(3) << "ReusePictureBuffer(" << picture_buffer_id << ")";
    504   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    505 
    506   DCHECK(!picture_buffers_at_display_.empty());
    507   PictureBufferTextureMap::iterator display_iterator =
    508       picture_buffers_at_display_.find(picture_buffer_id);
    509   uint32 texture_id = display_iterator->second;
    510   DCHECK(display_iterator != picture_buffers_at_display_.end());
    511   picture_buffers_at_display_.erase(display_iterator);
    512 
    513   if (!assigned_picture_buffers_.count(picture_buffer_id)) {
    514     // This picture was dismissed while in display, so we postponed deletion.
    515     factories_->DeleteTexture(texture_id);
    516     return;
    517   }
    518 
    519   ++available_pictures_;
    520 
    521   // DestroyVDA() might already have been called.
    522   if (vda_)
    523     vda_->ReusePictureBuffer(picture_buffer_id);
    524 }
    525 
    526 GpuVideoDecoder::SHMBuffer* GpuVideoDecoder::GetSHM(size_t min_size) {
    527   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    528   if (available_shm_segments_.empty() ||
    529       available_shm_segments_.back()->size < min_size) {
    530     size_t size_to_allocate = std::max(min_size, kSharedMemorySegmentBytes);
    531     base::SharedMemory* shm = factories_->CreateSharedMemory(size_to_allocate);
    532     // CreateSharedMemory() can return NULL during Shutdown.
    533     if (!shm)
    534       return NULL;
    535     return new SHMBuffer(shm, size_to_allocate);
    536   }
    537   SHMBuffer* ret = available_shm_segments_.back();
    538   available_shm_segments_.pop_back();
    539   return ret;
    540 }
    541 
    542 void GpuVideoDecoder::PutSHM(SHMBuffer* shm_buffer) {
    543   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    544   available_shm_segments_.push_back(shm_buffer);
    545 }
    546 
    547 void GpuVideoDecoder::NotifyEndOfBitstreamBuffer(int32 id) {
    548   DVLOG(3) << "NotifyEndOfBitstreamBuffer(" << id << ")";
    549   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    550 
    551   std::map<int32, PendingDecoderBuffer>::iterator it =
    552       bitstream_buffers_in_decoder_.find(id);
    553   if (it == bitstream_buffers_in_decoder_.end()) {
    554     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
    555     NOTREACHED() << "Missing bitstream buffer: " << id;
    556     return;
    557   }
    558 
    559   PutSHM(it->second.shm_buffer);
    560   it->second.done_cb.Run(state_ == kError ? kDecodeError : kOk);
    561   bitstream_buffers_in_decoder_.erase(it);
    562 }
    563 
    564 GpuVideoDecoder::~GpuVideoDecoder() {
    565   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    566   if (vda_)
    567     DestroyVDA();
    568   DCHECK(bitstream_buffers_in_decoder_.empty());
    569   DCHECK(assigned_picture_buffers_.empty());
    570 
    571   if (!pending_reset_cb_.is_null())
    572     base::ResetAndReturn(&pending_reset_cb_).Run();
    573 
    574   for (size_t i = 0; i < available_shm_segments_.size(); ++i) {
    575     available_shm_segments_[i]->shm->Close();
    576     delete available_shm_segments_[i];
    577   }
    578   available_shm_segments_.clear();
    579 
    580   for (std::map<int32, PendingDecoderBuffer>::iterator it =
    581            bitstream_buffers_in_decoder_.begin();
    582        it != bitstream_buffers_in_decoder_.end(); ++it) {
    583     it->second.shm_buffer->shm->Close();
    584   }
    585   bitstream_buffers_in_decoder_.clear();
    586 }
    587 
    588 void GpuVideoDecoder::NotifyFlushDone() {
    589   DVLOG(3) << "NotifyFlushDone()";
    590   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    591   DCHECK_EQ(state_, kDrainingDecoder);
    592   state_ = kDecoderDrained;
    593   base::ResetAndReturn(&eos_decode_cb_).Run(kOk);
    594 }
    595 
    596 void GpuVideoDecoder::NotifyResetDone() {
    597   DVLOG(3) << "NotifyResetDone()";
    598   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    599   DCHECK(bitstream_buffers_in_decoder_.empty());
    600 
    601   // This needs to happen after the Reset() on vda_ is done to ensure pictures
    602   // delivered during the reset can find their time data.
    603   input_buffer_data_.clear();
    604 
    605   if (!pending_reset_cb_.is_null())
    606     base::ResetAndReturn(&pending_reset_cb_).Run();
    607 }
    608 
    609 void GpuVideoDecoder::NotifyError(media::VideoDecodeAccelerator::Error error) {
    610   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
    611   if (!vda_)
    612     return;
    613 
    614   state_ = kError;
    615 
    616   DLOG(ERROR) << "VDA Error: " << error;
    617   DestroyVDA();
    618 }
    619 
    620 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
    621     const {
    622   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
    623 }
    624 
    625 }  // namespace media
    626