Implement |pic_order_cnt| computation for VTVideoDecode accelerator.

content/common/gpu/media/vt_video_decode_accelerator.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 <algorithm>
+
 #include <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/sys_byteorder.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/common/gpu/media/vt_video_decode_accelerator.h"
 #include "content/public/common/content_switches.h"
 #include "media/base/limits.h"
-#include "media/filters/h264_parser.h"
 #include "ui/gl/scoped_binders.h"
 
 using content_common_gpu_media::kModuleVt;
 using content_common_gpu_media::InitializeStubs;
 using content_common_gpu_media::IsVtInitialized;
 using content_common_gpu_media::StubPathMap;
 
 #define NOTIFY_STATUS(name, status)                             \
     do {                                                        \
       DLOG(ERROR) << name << " failed with status " << status;  \
       NotifyError(PLATFORM_FAILURE);                            \
     } while (0)
 
 namespace content {
 
 // Size to use for NALU length headers in AVC format (can be 1, 2, or 4).
 static 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.
 static const int kNumPictureBuffers = media::limits::kMaxVideoFrames + 1;
 
-// TODO(sandersd): Use the configured reorder window instead.
-static const int kMinReorderQueueSize = 4;
+// 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.)
 static const int kMaxReorderQueueSize = 16;
 
 // Route decoded frame callbacks back into the VTVideoDecodeAccelerator.
 static void OutputThunk(
     void* decompression_output_refcon,
     void* source_frame_refcon,
     OSStatus status,
     VTDecodeInfoFlags info_flags,
     CVImageBufferRef image_buffer,
     CMTime presentation_time_stamp,
     CMTime presentation_duration) {
   VTVideoDecodeAccelerator* vda =
       reinterpret_cast<VTVideoDecodeAccelerator*>(decompression_output_refcon);
   vda->Output(source_frame_refcon, status, image_buffer);
 }
 
 VTVideoDecodeAccelerator::Task::Task(TaskType type) : type(type) {
 }
 
 VTVideoDecodeAccelerator::Task::~Task() {
 }
 
 VTVideoDecodeAccelerator::Frame::Frame(int32_t bitstream_id)
-    : bitstream_id(bitstream_id), pic_order_cnt(0) {
+    : bitstream_id(bitstream_id), pic_order_cnt(0), reorder_window(0) {
 }
 
 VTVideoDecodeAccelerator::Frame::~Frame() {
 }
 
 bool VTVideoDecodeAccelerator::FrameOrder::operator()(
     const linked_ptr<Frame>& lhs,
     const linked_ptr<Frame>& rhs) const {
   if (lhs->pic_order_cnt != rhs->pic_order_cnt)
     return lhs->pic_order_cnt > rhs->pic_order_cnt;
-  // If the pic_order is the same, fallback on using the bitstream order.
-  // TODO(sandersd): Assign a sequence number in Decode().
+  // If |pic_order_cnt| is the same, fall back on using the bitstream order.
+  // TODO(sandersd): Assign a sequence number in Decode() and use that instead.
+  // TODO(sandersd): Using the sequence number, ensure that frames older than
+  // |kMaxReorderQueueSize| are ordered first, regardless of |pic_order_cnt|.
   return lhs->bitstream_id > rhs->bitstream_id;
 }
 
-
 VTVideoDecodeAccelerator::VTVideoDecodeAccelerator(
     CGLContextObj cgl_context,
     const base::Callback<bool(void)>& make_context_current)
     : cgl_context_(cgl_context),
       make_context_current_(make_context_current),
       client_(NULL),
       state_(STATE_DECODING),
       format_(NULL),
       session_(NULL),
       last_sps_id_(-1),
@@ skipping 218 matching lines @@
         break;
 
       case media::H264NALU::kSliceDataA:
       case media::H264NALU::kSliceDataB:
       case media::H264NALU::kSliceDataC:
         DLOG(ERROR) << "Coded slide data partitions not implemented.";
         NotifyError(PLATFORM_FAILURE);
         return;
 
       case media::H264NALU::kNonIDRSlice:
-        // TODO(sandersd): Check that there has been an SPS or IDR slice since
-        // the last reset.
+        // TODO(sandersd): Check that there has been an IDR slice since the
+        // last reset.
       case media::H264NALU::kIDRSlice:
         {
           // TODO(sandersd): Make sure this only happens once per frame.
           DCHECK_EQ(frame->pic_order_cnt, 0);
 
           media::H264SliceHeader slice_hdr;
           result = parser_.ParseSliceHeader(nalu, &slice_hdr);
           if (result != media::H264Parser::kOk) {
             DLOG(ERROR) << "Could not parse slice header";
             NotifyError(UNREADABLE_INPUT);
             return;
           }
 
-          // TODO(sandersd): Keep a cache of recent SPS/PPS units instead of
-          // only the most recent ones.
+          // TODO(sandersd): Maintain a cache of configurations and reconfigure
+          // only when a slice references a new config.
           DCHECK_EQ(slice_hdr.pic_parameter_set_id, last_pps_id_);
           const media::H264PPS* pps =
               parser_.GetPPS(slice_hdr.pic_parameter_set_id);
           if (!pps) {
             DLOG(ERROR) << "Mising PPS referenced by slice";
             NotifyError(UNREADABLE_INPUT);
             return;
           }
 
           DCHECK_EQ(pps->seq_parameter_set_id, last_sps_id_);
           const media::H264SPS* sps = parser_.GetSPS(pps->seq_parameter_set_id);
           if (!sps) {
             DLOG(ERROR) << "Mising SPS referenced by PPS";
             NotifyError(UNREADABLE_INPUT);
             return;
           }
 
-          // TODO(sandersd): Compute pic_order_cnt.
-          DCHECK(!slice_hdr.field_pic_flag);
-          frame->pic_order_cnt = 0;
+          if (!poc_.ComputePicOrderCnt(sps, slice_hdr, &frame->pic_order_cnt)) {
+            NotifyError(UNREADABLE_INPUT);
+            return;
+          }
+
+          if (sps->vui_parameters_present_flag &&
+              sps->bitstream_restriction_flag) {
+            frame->reorder_window = std::min(sps->max_num_reorder_frames,
+                                             kMaxReorderQueueSize - 1);
+          }
         }
       default:
         nalus.push_back(nalu);
         data_size += kNALUHeaderLength + nalu.size;
         break;
     }
   }
 
   // Initialize VideoToolbox.
   // TODO(sandersd): Instead of assuming that the last SPS and PPS units are
@@ skipping 243 matching lines @@
         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) {
+        last_sps_id_ = -1;
+        last_pps_id_ = -1;
+        last_sps_.clear();
+        last_spsext_.clear();
+        last_pps_.clear();
+        poc_.Reset();
         pending_flush_tasks_.pop();
         client_->NotifyResetDone();
         task_queue_.pop();
         return true;
       }
       return false;
 
     case TASK_DESTROY:
       NOTREACHED() << "Can't destroy while in STATE_DECODING.";
       NotifyError(ILLEGAL_STATE);
       return false;
   }
 }
 
 bool VTVideoDecodeAccelerator::ProcessReorderQueue() {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   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->pic_order_cnt == 0);
-  if (flushing || reorder_queue_.size() >= kMinReorderQueueSize) {
+
+  size_t reorder_window = std::max(0, reorder_queue_.top()->reorder_window);
+  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) {
@@ skipping 123 matching lines @@
   assigned_bitstream_ids_.clear();
   state_ = STATE_DESTROYING;
   QueueFlush(TASK_DESTROY);
 }
 
 bool VTVideoDecodeAccelerator::CanDecodeOnIOThread() {
   return false;
 }
 
 }  // namespace content