VTVDA: Fix computation of |reorder_window|.

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 24 matching lines @@
 using media_gpu::StubPathMap;
 
 #define NOTIFY_STATUS(name, status, session_failure) \
   do {                                               \
     OSSTATUS_DLOG(ERROR, status) << name;            \
     NotifyError(PLATFORM_FAILURE, session_failure);  \
   } while (0)
 
 namespace media {
 
+namespace {
+
 // Only H.264 with 4:2:0 chroma sampling is supported.
-static const VideoCodecProfile kSupportedProfiles[] = {
+const VideoCodecProfile kSupportedProfiles[] = {
     H264PROFILE_BASELINE, H264PROFILE_MAIN, H264PROFILE_EXTENDED,
     H264PROFILE_HIGH,
     // TODO(hubbe): Try to re-enable this again somehow. Currently it seems
     // that some codecs fail to check the profile during initialization and
     // then fail on the first frame decode, which currently results in a
     // pipeline failure.
     // H264PROFILE_HIGH10PROFILE,
     H264PROFILE_SCALABLEBASELINE, H264PROFILE_SCALABLEHIGH,
     H264PROFILE_STEREOHIGH, H264PROFILE_MULTIVIEWHIGH,
 };
 
 // Size to use for NALU length headers in AVC format (can be 1, 2, or 4).
-static const int kNALUHeaderLength = 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.
-static const int kNumPictureBuffers = limits::kMaxVideoFrames + 1;
+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.)
-static const int kMaxReorderQueueSize = 16;
+const int kMaxReorderQueueSize = 16;
 
 // Build an |image_config| dictionary for VideoToolbox initialization.
-static base::ScopedCFTypeRef<CFMutableDictionaryRef> BuildImageConfig(
+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)
   base::ScopedCFTypeRef<CFNumberRef> cf_pixel_format(CFINT(pixel_format));
   base::ScopedCFTypeRef<CFNumberRef> cf_width(CFINT(coded_dimensions.width));
   base::ScopedCFTypeRef<CFNumberRef> cf_height(CFINT(coded_dimensions.height));
@@ skipping 15 matching lines @@
 
   return image_config;
 }
 
 // Create a VTDecompressionSession using the provided |pps| and |sps|. If
 // |require_hardware| is true, the session must uses real hardware decoding
 // (as opposed to software decoding inside of VideoToolbox) to be considered
 // successful.
 //
 // TODO(sandersd): Merge with ConfigureDecoder(), as the code is very similar.
-static bool CreateVideoToolboxSession(const uint8_t* sps,
-                                      size_t sps_size,
-                                      const uint8_t* pps,
-                                      size_t pps_size,
-                                      bool require_hardware) {
+bool CreateVideoToolboxSession(const uint8_t* sps,
+                               size_t sps_size,
+                               const uint8_t* pps,
+                               size_t pps_size,
+                               bool require_hardware) {
   const uint8_t* data_ptrs[] = {sps, pps};
   const size_t data_sizes[] = {sps_size, pps_size};
 
   base::ScopedCFTypeRef<CMFormatDescriptionRef> format;
   OSStatus status = CMVideoFormatDescriptionCreateFromH264ParameterSets(
       kCFAllocatorDefault,
       2,                  // parameter_set_count
       data_ptrs,          // &parameter_set_pointers
       data_sizes,         // &parameter_set_sizes
       kNALUHeaderLength,  // nal_unit_header_length
@@ skipping 41 matching lines @@
 
   return true;
 }
 
 // The purpose of this function is to preload the generic and hardware-specific
 // libraries required by VideoToolbox before the GPU sandbox is enabled.
 // VideoToolbox normally loads the hardware-specific libraries lazily, so we
 // must actually create a decompression session. If creating a decompression
 // session fails, hardware decoding will be disabled (Initialize() will always
 // return false).
-static bool InitializeVideoToolboxInternal() {
+bool InitializeVideoToolboxInternal() {
   if (!IsVtInitialized()) {
     // CoreVideo is also required, but the loader stops after the first path is
     // loaded. Instead we rely on the transitive dependency from VideoToolbox to
     // CoreVideo.
     StubPathMap paths;
     paths[kModuleVt].push_back(FILE_PATH_LITERAL(
         "/System/Library/Frameworks/VideoToolbox.framework/VideoToolbox"));
     if (!InitializeStubs(paths)) {
       DLOG(WARNING) << "Failed to initialize VideoToolbox framework";
       return false;
@@ skipping 20 matching lines @@
   const uint8_t pps_small[] = {0x68, 0xe9, 0x79, 0x72, 0xc0};
   if (!CreateVideoToolboxSession(sps_small, arraysize(sps_small), pps_small,
                                  arraysize(pps_small), false)) {
     DLOG(WARNING) << "Failed to create software VideoToolbox session";
     return false;
   }
 
   return true;
 }
 
-bool InitializeVideoToolbox() {
-  // InitializeVideoToolbox() is called only from the GPU process main thread;
-  // once for sandbox warmup, and then once each time a VTVideoDecodeAccelerator
-  // is initialized.
-  static bool attempted = false;
-  static bool succeeded = false;
+// 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;
 
-  if (!attempted) {
-    attempted = true;
-    succeeded = InitializeVideoToolboxInternal();
+  // 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;
+    }
   }
-
-  return succeeded;
+  return max_dpb_frames;
 }
 
 // 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) {
+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);
 }
 
+}  // namespace
+
+bool InitializeVideoToolbox() {
+  // InitializeVideoToolbox() is called only from the GPU process main thread:
+  // once for sandbox warmup, and then once each time a VTVideoDecodeAccelerator
+  // is initialized. This ensures that everything is loaded whether or not the
+  // sandbox is enabled.
+  static bool succeeded = InitializeVideoToolboxInternal();
+  return succeeded;
+}
+
 VTVideoDecodeAccelerator::Task::Task(TaskType type) : type(type) {}
 
 VTVideoDecodeAccelerator::Task::Task(const Task& other) = default;
 
 VTVideoDecodeAccelerator::Task::~Task() {}
 
 VTVideoDecodeAccelerator::Frame::Frame(int32_t bitstream_id)
     : bitstream_id(bitstream_id),
       pic_order_cnt(0),
       is_idr(false),
@@ skipping 336 matching lines @@
 
           if (!poc_.ComputePicOrderCnt(sps, slice_hdr, &frame->pic_order_cnt)) {
             DLOG(ERROR) << "Unable to compute POC";
             NotifyError(UNREADABLE_INPUT, SFT_INVALID_STREAM);
             return;
           }
 
           if (nalu.nal_unit_type == H264NALU::kIDRSlice)
             frame->is_idr = true;
 
-          if (sps->vui_parameters_present_flag &&
-              sps->bitstream_restriction_flag) {
-            frame->reorder_window =
-                std::min(sps->max_num_reorder_frames, kMaxReorderQueueSize - 1);
-          }
+          frame->reorder_window = ComputeReorderWindow(sps);
         }
         has_slice = true;
       default:
         nalus.push_back(nalu);
         data_size += kNALUHeaderLength + nalu.size;
         break;
     }
   }
 
   // Initialize VideoToolbox.
@@ skipping 528 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