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