Allow multiple concurrent Decode() requests in VideoDecoder interface.

media/filters/gpu_video_decoder.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/filters/gpu_video_decoder.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 62 matching lines @@
 
 void GpuVideoDecoder::Reset(const base::Closure& closure)  {
   DVLOG(3) << "Reset()";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   if (state_ == kDrainingDecoder) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(
             &GpuVideoDecoder::Reset, weak_factory_.GetWeakPtr(), closure));
-    // NOTE: if we're deferring Reset() until a Flush() completes, return
-    // queued pictures to the VDA so they can be used to finish that Flush().
-    if (pending_decode_cb_.is_null())
-      ready_video_frames_.clear();
     return;
   }
 
-  // Throw away any already-decoded, not-yet-delivered frames.
-  ready_video_frames_.clear();
-
   if (!vda_) {
     base::MessageLoop::current()->PostTask(FROM_HERE, closure);
     return;
   }
 
-  if (!pending_decode_cb_.is_null())
-    EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEOSFrame());
+  while (!pending_decode_callbacks_.empty()) {
+    DeliverFrame(VideoFrame::CreateEOSFrame());
+  }
 
   DCHECK(pending_reset_cb_.is_null());
   pending_reset_cb_ = BindToCurrentLoop(closure);
 
   vda_->Reset();
 }
 
 void GpuVideoDecoder::Stop() {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   if (vda_)
     DestroyVDA();
-  if (!pending_decode_cb_.is_null())
-    EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEOSFrame());
+  while (!pending_decode_callbacks_.empty()) {
+    DeliverFrame(VideoFrame::CreateEOSFrame());
+  }
   if (!pending_reset_cb_.is_null())
     base::ResetAndReturn(&pending_reset_cb_).Run();
 }
 
 static bool IsCodedSizeSupported(const gfx::Size& coded_size) {
   // Only non-Windows, Ivy Bridge+ platforms can support more than 1920x1080.
   // We test against 1088 to account for 16x16 macroblocks.
   if (coded_size.width() <= 1920 && coded_size.height() <= 1088)
     return true;
 
@@ skipping 92 matching lines @@
        ++it) {
     assigned_picture_buffers_.erase(it->first);
   }
   DestroyPictureBuffers(&assigned_picture_buffers_);
 }
 
 void GpuVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
                              const DecodeCB& decode_cb) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DCHECK(pending_reset_cb_.is_null());
-  DCHECK(pending_decode_cb_.is_null());
-
-  pending_decode_cb_ = BindToCurrentLoop(decode_cb);
 
   if (state_ == kError || !vda_) {
-    base::ResetAndReturn(&pending_decode_cb_).Run(kDecodeError, NULL);
+    decode_cb.Run(kDecodeError, NULL);
     return;
   }
 
   switch (state_) {
     case kDecoderDrained:
-      if (!ready_video_frames_.empty()) {
-        EnqueueFrameAndTriggerFrameDelivery(NULL);
-        return;
-      }
       state_ = kNormal;
       // Fall-through.
     case kNormal:
       break;
     case kDrainingDecoder:
       DCHECK(buffer->end_of_stream());
       // Do nothing.  Will be satisfied either by a PictureReady or
       // NotifyFlushDone below.
       return;
     case kError:
       NOTREACHED();
       return;
   }
 
   if (buffer->end_of_stream()) {
     if (state_ == kNormal) {
       state_ = kDrainingDecoder;
+      pending_decode_callbacks_.push_back(BindToCurrentLoop(decode_cb));
+      DCHECK_LE(static_cast<int>(pending_decode_callbacks_.size()),
+                kMaxInFlightDecodes);
       vda_->Flush();
-      // If we have ready frames, go ahead and process them to ensure that the
-      // Flush operation does not block in the VDA due to lack of picture
-      // buffers.
-      if (!ready_video_frames_.empty())
-        EnqueueFrameAndTriggerFrameDelivery(NULL);
     }
     return;
   }
 
   size_t size = buffer->data_size();
   SHMBuffer* shm_buffer = GetSHM(size);
   if (!shm_buffer) {
-    base::ResetAndReturn(&pending_decode_cb_).Run(kDecodeError, NULL);
+    decode_cb.Run(kDecodeError, NULL);
     return;
   }
 
+  pending_decode_callbacks_.push_back(BindToCurrentLoop(decode_cb));
+  DCHECK_LE(static_cast<int>(pending_decode_callbacks_.size()),
+            kMaxInFlightDecodes);
+
   memcpy(shm_buffer->shm->memory(), buffer->data(), size);
   BitstreamBuffer bitstream_buffer(
       next_bitstream_buffer_id_, shm_buffer->shm->handle(), size);
   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
   next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x3FFFFFFF;
   bool inserted = bitstream_buffers_in_decoder_.insert(std::make_pair(
       bitstream_buffer.id(), BufferPair(shm_buffer, buffer))).second;
   DCHECK(inserted);
   RecordBufferData(bitstream_buffer, *buffer.get());
 
   vda_->Decode(bitstream_buffer);
-
-  if (!ready_video_frames_.empty()) {
-    EnqueueFrameAndTriggerFrameDelivery(NULL);
-    return;
-  }
-
-  if (CanMoreDecodeWorkBeDone())
-    base::ResetAndReturn(&pending_decode_cb_).Run(kNotEnoughData, NULL);
-}
-
-bool GpuVideoDecoder::CanMoreDecodeWorkBeDone() {
-  return bitstream_buffers_in_decoder_.size() < kMaxInFlightDecodes;
 }
 
 void GpuVideoDecoder::RecordBufferData(const BitstreamBuffer& bitstream_buffer,
                                        const DecoderBuffer& buffer) {
   input_buffer_data_.push_front(BufferData(bitstream_buffer.id(),
                                            buffer.timestamp(),
                                            config_.visible_rect(),
                                            config_.natural_size()));
   // Why this value?  Because why not.  avformat.h:MAX_REORDER_DELAY is 16, but
   // that's too small for some pathological B-frame test videos.  The cost of
@@ skipping 28 matching lines @@
 
 bool GpuVideoDecoder::NeedsBitstreamConversion() const {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   return needs_bitstream_conversion_;
 }
 
 bool GpuVideoDecoder::CanReadWithoutStalling() const {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   return
       next_picture_buffer_id_ == 0 ||  // Decode() will ProvidePictureBuffers().
-      available_pictures_ > 0 || !ready_video_frames_.empty();
+      available_pictures_ > 0;
+}
+
+int GpuVideoDecoder::GetMaxDecodeRequests() const {
+  return kMaxInFlightDecodes;

[xhwang, 2014/04/17 01:06:47]

[not related to this CL]

fischman: Do you know what's the decoding delay of VDAs? Are they guaranteed to
be < kMaxInFlightDecodes? Up until this CL, we always schedule
kMaxInFlightDecodes decodes upon the first DS::Read() call. This seems to work.
But if we have a VDA that has decoding delay > kMaxInFlightDecodes, then we
won't get any decoded frames after kMaxInFlightDecodes decode calls, and DS will
not issue new decode calls, hence a deadlock.

[Sergey Ulanov, 2014/04/23 02:44:21]

per e-mail thread VDA decoder shouldn't have any delay.

 }
 
 void GpuVideoDecoder::NotifyInitializeDone() {
   NOTREACHED() << "GpuVideoDecodeAcceleratorHost::Initialize is synchronous!";
 }
 
 void GpuVideoDecoder::ProvidePictureBuffers(uint32 count,
                                             const gfx::Size& size,
                                             uint32 texture_target) {
   DVLOG(3) << "ProvidePictureBuffers(" << count << ", "
@@ skipping 116 matching lines @@
       timestamp,
       base::Bind(&ReadPixelsSync, factories_, pb.texture_id(), visible_rect)));
   CHECK_GT(available_pictures_, 0);
   --available_pictures_;
   bool inserted =
       picture_buffers_at_display_.insert(std::make_pair(
                                              picture.picture_buffer_id(),
                                              pb.texture_id())).second;
   DCHECK(inserted);
 
-  EnqueueFrameAndTriggerFrameDelivery(frame);
+  DeliverFrame(frame);
 }
 
-void GpuVideoDecoder::EnqueueFrameAndTriggerFrameDelivery(
+void GpuVideoDecoder::DeliverFrame(
     const scoped_refptr<VideoFrame>& frame) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   // During a pending vda->Reset(), we don't accumulate frames.  Drop it on the
   // floor and return.
   if (!pending_reset_cb_.is_null())
     return;
 
-  if (frame.get())
-    ready_video_frames_.push_back(frame);
-  else
-    DCHECK(!ready_video_frames_.empty());
+  CHECK(!pending_decode_callbacks_.empty());

[xhwang, 2014/04/17 01:06:47]

This is catching a coding error, use DCHECK?

[Sergey Ulanov, 2014/04/23 02:44:21]

Done.

 
-  if (pending_decode_cb_.is_null())
-    return;
+  DecodeCB decode_cb = pending_decode_callbacks_.front();
+  pending_decode_callbacks_.pop_front();
 
-  base::ResetAndReturn(&pending_decode_cb_)
-      .Run(kOk, ready_video_frames_.front());
-  ready_video_frames_.pop_front();
+  decode_cb.Run(kOk, frame);
 }
 
 // static
 void GpuVideoDecoder::ReleaseMailbox(
     base::WeakPtr<GpuVideoDecoder> decoder,
     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories,
     int64 picture_buffer_id,
     uint32 texture_id,
     scoped_ptr<gpu::MailboxHolder> mailbox_holder) {
   DCHECK(factories->GetTaskRunner()->BelongsToCurrentThread());
@@ skipping 60 matching lines @@
   std::map<int32, BufferPair>::iterator it =
       bitstream_buffers_in_decoder_.find(id);
   if (it == bitstream_buffers_in_decoder_.end()) {
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     NOTREACHED() << "Missing bitstream buffer: " << id;
     return;
   }
 
   PutSHM(it->second.shm_buffer);
   bitstream_buffers_in_decoder_.erase(it);
-
-  if (pending_reset_cb_.is_null() && state_ != kDrainingDecoder &&
-      CanMoreDecodeWorkBeDone() && !pending_decode_cb_.is_null()) {
-    base::ResetAndReturn(&pending_decode_cb_).Run(kNotEnoughData, NULL);
-  }

[xhwang, 2014/04/17 01:06:47]

Kudos for removing this logic!

 }
 
 GpuVideoDecoder::~GpuVideoDecoder() {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   // Stop should have been already called.
   DCHECK(!vda_.get() && assigned_picture_buffers_.empty());
-  DCHECK(pending_decode_cb_.is_null());
+  DCHECK(pending_decode_callbacks_.empty());
   for (size_t i = 0; i < available_shm_segments_.size(); ++i) {
     available_shm_segments_[i]->shm->Close();
     delete available_shm_segments_[i];
   }
   available_shm_segments_.clear();
   for (std::map<int32, BufferPair>::iterator it =
            bitstream_buffers_in_decoder_.begin();
        it != bitstream_buffers_in_decoder_.end(); ++it) {
     it->second.shm_buffer->shm->Close();
   }
   bitstream_buffers_in_decoder_.clear();
 }
 
 void GpuVideoDecoder::NotifyFlushDone() {
   DVLOG(3) << "NotifyFlushDone()";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DCHECK_EQ(state_, kDrainingDecoder);
   state_ = kDecoderDrained;
-  EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEOSFrame());
+  DeliverFrame(VideoFrame::CreateEOSFrame());

[xhwang, 2014/04/17 01:06:47]

I suspect that after FlushDone, we'll still have unsatisfied decode_cb's. (See
comments above about decoding delay.)

[Sergey Ulanov, 2014/04/23 02:44:21]

Added DCHECK_EQ(pending_decode_callbacks_.size(), 1U);

 }
 
 void GpuVideoDecoder::NotifyResetDone() {
   DVLOG(3) << "NotifyResetDone()";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
-  DCHECK(ready_video_frames_.empty());
+  DCHECK(pending_decode_callbacks_.empty());
 
   // This needs to happen after the Reset() on vda_ is done to ensure pictures
   // delivered during the reset can find their time data.
   input_buffer_data_.clear();
 
   if (!pending_reset_cb_.is_null())
     base::ResetAndReturn(&pending_reset_cb_).Run();
-
-  if (!pending_decode_cb_.is_null())
-    EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEOSFrame());
 }
 
 void GpuVideoDecoder::NotifyError(media::VideoDecodeAccelerator::Error error) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   if (!vda_)
     return;
 
   DLOG(ERROR) << "VDA Error: " << error;
   DestroyVDA();
 
   state_ = kError;
 
-  if (!pending_decode_cb_.is_null()) {
-    base::ResetAndReturn(&pending_decode_cb_).Run(kDecodeError, NULL);
-    return;
+  while (!pending_decode_callbacks_.empty()) {
+    pending_decode_callbacks_.front().Run(kDecodeError, NULL);
+    pending_decode_callbacks_.pop_front();
   }
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media