VTVDA: Optimize pic_order_cnt_type == 2.

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 191 matching lines @@
                                  arraysize(pps_small), false)) {
     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) {
+  // When |pic_order_cnt_type| == 2, decode order always matches presentation
+  // order.
+  // TODO(sandersd): For |pic_order_cnt_type| == 1, analyze the delta cycle to
+  // find the minimum required reorder window.
+  if (sps->pic_order_cnt_type == 2)
+    return 0;
+
   // TODO(sandersd): Compute MaxDpbFrames.
   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) {
@@ skipping 363 matching lines @@
           // later, since it comes from the decoder configuration.
           int32_t pic_order_cnt;
           if (!poc_.ComputePicOrderCnt(sps, slice_hdr, &pic_order_cnt)) {
             DLOG(ERROR) << "Unable to compute POC";
             NotifyError(UNREADABLE_INPUT, SFT_INVALID_STREAM);
             return;
           }
 
           frame->has_slice = true;
           frame->is_idr = nalu.nal_unit_type == media::H264NALU::kIDRSlice;
+          frame->has_mmco5 = poc_.IsPendingMMCO5();
           frame->pic_order_cnt = pic_order_cnt;
           frame->reorder_window = ComputeReorderWindow(sps);
         }
 
       // Intentional fallthrough.
       default:
         nalus.push_back(nalu);
         data_size += kNALUHeaderLength + nalu.size;
         break;
     }
   }
 
-  if (frame->is_idr) {
+  if (frame->is_idr)
     waiting_for_idr_ = false;
-  }
 
   // If no IDR has been seen yet, skip decoding. Note that Flash sends
   // configuration changes as a bitstream with only SPS/PPS; we don't print
   // error messages for those.
   if (frame->has_slice && waiting_for_idr_) {
     if (!missing_idr_logged_) {
       LOG(ERROR) << "Illegal attempt to decode without IDR. "
                  << "Discarding decode requests until next IDR.";
       missing_idr_logged_ = true;
     }
@@ skipping 314 matching lines @@
 bool VTVideoDecodeAccelerator::ProcessTaskQueue() {
   DVLOG(3) << __func__ << " size=" << task_queue_.size();
   DCHECK(gpu_task_runner_->BelongsToCurrentThread());
   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())) {
+    case TASK_FRAME: {
+      bool reorder_queue_has_space =
+          reorder_queue_.size() < kMaxReorderQueueSize;
+      bool reorder_queue_flush_needed =
+          task.frame->is_idr || task.frame->has_mmco5;
+      bool reorder_queue_flush_done = reorder_queue_.empty();
+      if (reorder_queue_has_space &&
+          (!reorder_queue_flush_needed || reorder_queue_flush_done)) {
         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;
       }
@@ skipping 23 matching lines @@
   DCHECK_EQ(state_, STATE_DECODING);
 
   if (reorder_queue_.empty())
     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);
+                               task_queue_.front().frame->is_idr ||
+                               task_queue_.front().frame->has_mmco5);
 
   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;
     }
   }
@@ skipping 170 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