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