VTVDA: Fix reorder queue size.

media/gpu/vt_video_decode_accelerator_mac.cc

 // Copyright 2014 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/gpu/vt_video_decode_accelerator_mac.h"
 
 #include <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 #include <stddef.h>
@@ skipping 48 matching lines @@
 
 // Size to use for NALU length headers in AVC format (can be 1, 2, or 4).
 const int kNALUHeaderLength = 4;
 
 // We request 5 picture buffers from the client, each of which has a texture ID
 // that we can bind decoded frames to. We need enough to satisfy preroll, and
 // enough to avoid unnecessary stalling, but no more than that. The resource
 // requirements are low, as we don't need the textures to be backed by storage.
 const int kNumPictureBuffers = limits::kMaxVideoFrames + 1;
 
-// Maximum number of frames to queue for reordering before we stop asking for
-// more. (NotifyEndOfBitstreamBuffer() is called when frames are moved into the
-// reorder queue.)
-const int kMaxReorderQueueSize = 16;
+// Maximum number of frames to queue for reordering. (Also controls the maximum
+// number of in-flight frames, since NotifyEndOfBitstreamBuffer() is called when
+// frames are moved into the reorder queue.)
+//
+// Since the maximum possible |reorder_window| is 16 for H.264, 17 is the
+// minimum safe (static) size of the reorder queue.
+const int kMaxReorderQueueSize = 17;
 
 // Build an |image_config| dictionary for VideoToolbox initialization.
 base::ScopedCFTypeRef<CFMutableDictionaryRef> BuildImageConfig(
     CMVideoDimensions coded_dimensions) {
   base::ScopedCFTypeRef<CFMutableDictionaryRef> image_config;
 
   // Note that 4:2:0 textures cannot be used directly as RGBA in OpenGL, but are
   // lower power than 4:2:2 when composited directly by CoreAnimation.
   int32_t pixel_format = kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange;
 #define CFINT(i) CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &i)
@@ skipping 128 matching lines @@
     DLOG(WARNING) << "Failed to create software VideoToolbox session";
     return false;
   }
 
   return true;
 }
 
 // TODO(sandersd): Share this computation with the VAAPI decoder.
 int32_t ComputeReorderWindow(const H264SPS* sps) {
   // TODO(sandersd): Compute MaxDpbFrames.
-  int32_t max_dpb_frames = kMaxReorderQueueSize;
+  int32_t max_dpb_frames = 16;
 
   // See AVC spec section E.2.1 definition of |max_num_reorder_frames|.
   if (sps->vui_parameters_present_flag && sps->bitstream_restriction_flag) {
     return std::min(sps->max_num_reorder_frames, max_dpb_frames);
   } else if (sps->constraint_set3_flag) {
     if (sps->profile_idc == 44 || sps->profile_idc == 86 ||
         sps->profile_idc == 100 || sps->profile_idc == 110 ||
         sps->profile_idc == 122 || sps->profile_idc == 244) {
       return 0;
     }
@@ skipping 77 matching lines @@
       missing_idr_logged_(false),
       gpu_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       decoder_thread_("VTDecoderThread"),
       weak_this_factory_(this) {
   callback_.decompressionOutputCallback = OutputThunk;
   callback_.decompressionOutputRefCon = this;
   weak_this_ = weak_this_factory_.GetWeakPtr();
 }
 
 VTVideoDecodeAccelerator::~VTVideoDecodeAccelerator() {
+  DVLOG(1) << __func__;
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
 }
 
 bool VTVideoDecodeAccelerator::Initialize(const Config& config,
                                           Client* client) {
+  DVLOG(1) << __func__;
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
 
   if (make_context_current_cb_.is_null() || bind_image_cb_.is_null()) {
     NOTREACHED() << "GL callbacks are required for this VDA";
     return false;
   }
 
   if (config.is_encrypted) {
     NOTREACHED() << "Encrypted streams are not supported for this VDA";
     return false;
@@ skipping 23 matching lines @@
   if (!decoder_thread_.Start())
     return false;
 
   // Count the session as successfully initialized.
   UMA_HISTOGRAM_ENUMERATION("Media.VTVDA.SessionFailureReason",
                             SFT_SUCCESSFULLY_INITIALIZED, SFT_MAX + 1);
   return true;
 }
 
 bool VTVideoDecodeAccelerator::FinishDelayedFrames() {
+  DVLOG(3) << __func__;
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   if (session_) {
     OSStatus status = VTDecompressionSessionWaitForAsynchronousFrames(session_);
     if (status) {
       NOTIFY_STATUS("VTDecompressionSessionWaitForAsynchronousFrames()", status,
                     SFT_PLATFORM_ERROR);
       return false;
     }
   }
   return true;
 }
 
 bool VTVideoDecodeAccelerator::ConfigureDecoder() {
+  DVLOG(2) << __func__;
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK(!last_sps_.empty());
   DCHECK(!last_pps_.empty());
 
   // Build the configuration records.
   std::vector<const uint8_t*> nalu_data_ptrs;
   std::vector<size_t> nalu_data_sizes;
   nalu_data_ptrs.reserve(3);
   nalu_data_sizes.reserve(3);
   nalu_data_ptrs.push_back(&last_sps_.front());
@@ skipping 82 matching lines @@
           cf_using_hardware.InitializeInto()) == 0) {
     using_hardware = CFBooleanGetValue(cf_using_hardware);
   }
   UMA_HISTOGRAM_BOOLEAN("Media.VTVDA.HardwareAccelerated", using_hardware);
 
   return true;
 }
 
 void VTVideoDecodeAccelerator::DecodeTask(const BitstreamBuffer& bitstream,
                                           Frame* frame) {
+  DVLOG(2) << __func__ << "(" << frame->bitstream_id << ")";
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   // Map the bitstream buffer.
   SharedMemoryRegion memory(bitstream, true);
   if (!memory.Map()) {
     DLOG(ERROR) << "Failed to map bitstream buffer";
     NotifyError(PLATFORM_FAILURE, SFT_PLATFORM_ERROR);
     return;
   }
   const uint8_t* buf = static_cast<uint8_t*>(memory.memory());
@@ skipping 309 matching lines @@
   }
 
   Frame* frame = reinterpret_cast<Frame*>(source_frame_refcon);
   frame->image.reset(image_buffer, base::scoped_policy::RETAIN);
   gpu_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VTVideoDecodeAccelerator::DecodeDone, weak_this_, frame));
 }
 
 void VTVideoDecodeAccelerator::DecodeDone(Frame* frame) {
+  DVLOG(3) << __func__ << "(" << frame->bitstream_id << ")";
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
+
   DCHECK_EQ(1u, pending_frames_.count(frame->bitstream_id));
   Task task(TASK_FRAME);
   task.frame = pending_frames_[frame->bitstream_id];
   pending_frames_.erase(frame->bitstream_id);
   task_queue_.push(task);
   ProcessWorkQueues();
 }
 
 void VTVideoDecodeAccelerator::FlushTask(TaskType type) {
+  DVLOG(3) << __func__;
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
+
   FinishDelayedFrames();
 
   // Always queue a task, even if FinishDelayedFrames() fails, so that
   // destruction always completes.
   gpu_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VTVideoDecodeAccelerator::FlushDone, weak_this_, type));
 }
 
 void VTVideoDecodeAccelerator::FlushDone(TaskType type) {
+  DVLOG(3) << __func__;
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   task_queue_.push(Task(type));
   ProcessWorkQueues();
 }
 
 void VTVideoDecodeAccelerator::Decode(const BitstreamBuffer& bitstream) {
+  DVLOG(2) << __func__ << "(" << bitstream.id() << ")";
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
+
   if (bitstream.id() < 0) {
     DLOG(ERROR) << "Invalid bitstream, id: " << bitstream.id();
     if (base::SharedMemory::IsHandleValid(bitstream.handle()))
       base::SharedMemory::CloseHandle(bitstream.handle());
     NotifyError(INVALID_ARGUMENT, SFT_INVALID_STREAM);
     return;
   }
+
   DCHECK_EQ(0u, assigned_bitstream_ids_.count(bitstream.id()));
   assigned_bitstream_ids_.insert(bitstream.id());
+
   Frame* frame = new Frame(bitstream.id());
   pending_frames_[frame->bitstream_id] = make_linked_ptr(frame);
   decoder_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&VTVideoDecodeAccelerator::DecodeTask,
                             base::Unretained(this), bitstream, frame));
 }
 
 void VTVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<PictureBuffer>& pictures) {
+  DVLOG(1) << __func__;
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
 
   for (const PictureBuffer& picture : pictures) {
     DCHECK(!picture_info_map_.count(picture.id()));
     assigned_picture_ids_.insert(picture.id());
     available_picture_ids_.push_back(picture.id());
     DCHECK_LE(1u, picture.internal_texture_ids().size());
     DCHECK_LE(1u, picture.texture_ids().size());
     picture_info_map_.insert(std::make_pair(
         picture.id(),
         base::MakeUnique<PictureInfo>(picture.internal_texture_ids()[0],
                                       picture.texture_ids()[0])));
   }
 
   // Pictures are not marked as uncleared until after this method returns, and
   // they will be broken if they are used before that happens. So, schedule
   // future work after that happens.
   gpu_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VTVideoDecodeAccelerator::ProcessWorkQueues, weak_this_));
 }
 
 void VTVideoDecodeAccelerator::ReusePictureBuffer(int32_t picture_id) {
+  DVLOG(2) << __func__ << "(" << picture_id << ")";
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
 
   auto it = picture_info_map_.find(picture_id);
   if (it != picture_info_map_.end()) {
     PictureInfo* picture_info = it->second.get();
     picture_info->cv_image.reset();
     picture_info->gl_image->Destroy(false);
     picture_info->gl_image = nullptr;
   }
 
   if (assigned_picture_ids_.count(picture_id)) {
     available_picture_ids_.push_back(picture_id);
     ProcessWorkQueues();
   } else {
     client_->DismissPictureBuffer(picture_id);
   }
 }
 
 void VTVideoDecodeAccelerator::ProcessWorkQueues() {
+  DVLOG(3) << __func__;
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   switch (state_) {
     case STATE_DECODING:
       // TODO(sandersd): Batch where possible.
       while (state_ == STATE_DECODING) {
         if (!ProcessReorderQueue() && !ProcessTaskQueue())
           break;
       }
       return;
 
     case STATE_ERROR:
       // Do nothing until Destroy() is called.
       return;
 
     case STATE_DESTROYING:
       // Drop tasks until we are ready to destruct.
       while (!task_queue_.empty()) {
         if (task_queue_.front().type == TASK_DESTROY) {
           delete this;
           return;
         }
         task_queue_.pop();
       }
       return;
   }
 }
 
 bool VTVideoDecodeAccelerator::ProcessTaskQueue() {
+  DVLOG(3) << __func__ << " size=" << task_queue_.size();
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, STATE_DECODING);
 
   if (task_queue_.empty())
     return false;
 
   const Task& task = task_queue_.front();
   switch (task.type) {
     case TASK_FRAME:
       if (reorder_queue_.size() < kMaxReorderQueueSize &&
           (!task.frame->is_idr || reorder_queue_.empty())) {
+        DVLOG(2) << "Decode(" << task.frame->bitstream_id << ") complete";
         assigned_bitstream_ids_.erase(task.frame->bitstream_id);
         client_->NotifyEndOfBitstreamBuffer(task.frame->bitstream_id);
         reorder_queue_.push(task.frame);
         task_queue_.pop();
         return true;
       }
       return false;
 
     case TASK_FLUSH:
       DCHECK_EQ(task.type, pending_flush_tasks_.front());
       if (reorder_queue_.size() == 0) {
+        DVLOG(1) << "Flush complete";
         pending_flush_tasks_.pop();
         client_->NotifyFlushDone();
         task_queue_.pop();
         return true;
       }
       return false;
 
     case TASK_RESET:
       DCHECK_EQ(task.type, pending_flush_tasks_.front());
       if (reorder_queue_.size() == 0) {
+        DVLOG(1) << "Reset complete";
         waiting_for_idr_ = true;
         pending_flush_tasks_.pop();
         client_->NotifyResetDone();
         task_queue_.pop();
         return true;
       }
       return false;
 
     case TASK_DESTROY:
       NOTREACHED() << "Can't destroy while in STATE_DECODING";
@@ skipping 10 matching lines @@
     return false;
 
   // If the next task is a flush (because there is a pending flush or becuase
   // the next frame is an IDR), then we don't need a full reorder buffer to send
   // the next frame.
   bool flushing =
       !task_queue_.empty() && (task_queue_.front().type != TASK_FRAME ||
                                task_queue_.front().frame->is_idr);
 
   size_t reorder_window = std::max(0, reorder_queue_.top()->reorder_window);
+  DVLOG(3) << __func__ << " size=" << reorder_queue_.size()
+           << " window=" << reorder_window << " flushing=" << flushing;
   if (flushing || reorder_queue_.size() > reorder_window) {
     if (ProcessFrame(*reorder_queue_.top())) {
       reorder_queue_.pop();
       return true;
     }
   }
 
   return false;
 }
 
 bool VTVideoDecodeAccelerator::ProcessFrame(const Frame& frame) {
+  DVLOG(3) << __func__ << "(" << frame.bitstream_id << ")";
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, STATE_DECODING);
 
   // If the next pending flush is for a reset, then the frame will be dropped.
   bool resetting = !pending_flush_tasks_.empty() &&
                    pending_flush_tasks_.front() == TASK_RESET;
 
   if (!resetting && frame.image.get()) {
     // If the |coded_size| has changed, request new picture buffers and then
     // wait for them.
@@ skipping 15 matching lines @@
       return false;
     }
     if (!SendFrame(frame))
       return false;
   }
 
   return true;
 }
 
 bool VTVideoDecodeAccelerator::SendFrame(const Frame& frame) {
+  DVLOG(2) << __func__ << "(" << frame.bitstream_id << ")";
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, STATE_DECODING);
 
   if (available_picture_ids_.empty())
     return false;
 
   int32_t picture_id = available_picture_ids_.back();
   auto it = picture_info_map_.find(picture_id);
   DCHECK(it != picture_info_map_.end());
   PictureInfo* picture_info = it->second.get();
@@ skipping 60 matching lines @@
   decoder_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&VTVideoDecodeAccelerator::FlushTask,
                             base::Unretained(this), type));
 
   // If this is a new flush request, see if we can make progress.
   if (pending_flush_tasks_.size() == 1)
     ProcessWorkQueues();
 }
 
 void VTVideoDecodeAccelerator::Flush() {
+  DVLOG(1) << __func__;
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   QueueFlush(TASK_FLUSH);
 }
 
 void VTVideoDecodeAccelerator::Reset() {
+  DVLOG(1) << __func__;
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   QueueFlush(TASK_RESET);
 }
 
 void VTVideoDecodeAccelerator::Destroy() {
+  DVLOG(1) << __func__;
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
 
   // In a forceful shutdown, the decoder thread may be dead already.
   if (!decoder_thread_.IsRunning()) {
     delete this;
     return;
   }
 
   // For a graceful shutdown, return assigned buffers and flush before
   // destructing |this|.
@@ skipping 20 matching lines @@
     SupportedProfile profile;
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(16, 16);
     profile.max_resolution.SetSize(4096, 2160);
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 }  // namespace media