Never reuse a VideoToolbox decompression session.

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>
 
@@ skipping 47 matching lines @@
 // 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;
 
 // 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;
 
-// When set to false, always create a new decoder instead of reusing the
-// existing configuration when the configuration changes. This works around a
-// bug in VideoToolbox that results in corruption before Mac OS X 10.10.3. The
-// value is set in InitializeVideoToolbox().
-static bool g_enable_compatible_configuration_reuse = true;
-
 // Build an |image_config| dictionary for VideoToolbox initialization.
 static base::ScopedCFTypeRef<CFMutableDictionaryRef>
 BuildImageConfig(CMVideoDimensions coded_dimensions) {
   base::ScopedCFTypeRef<CFMutableDictionaryRef> image_config;
 
   // 4:2:2 is used over the native 4:2:0 because only 4:2:2 can be directly
   // bound to a texture by CGLTexImageIOSurface2D().
   int32_t pixel_format = kCVPixelFormatType_422YpCbCr8;
 #define CFINT(i) CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &i)
   base::ScopedCFTypeRef<CFNumberRef> cf_pixel_format(CFINT(pixel_format));
@@ skipping 97 matching lines @@
 static bool InitializeVideoToolboxInternal() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableAcceleratedVideoDecode)) {
     return false;
   }
 
   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.
-    // TODO(sandersd): Fallback to PrivateFrameworks to support OS X < 10.8.
     StubPathMap paths;
     paths[kModuleVt].push_back(FILE_PATH_LITERAL(
         "/System/Library/Frameworks/VideoToolbox.framework/VideoToolbox"));
     if (!InitializeStubs(paths)) {
       LOG(WARNING) << "Failed to initialize VideoToolbox framework. "
                    << "Hardware accelerated video decoding will be disabled.";
       return false;
     }
   }
 
@@ skipping 16 matching lines @@
                                0x22, 0x10, 0x00, 0x00, 0x3e, 0x90, 0x00, 0x0e,
                                0xa6, 0x08, 0xf1, 0x22, 0x59, 0xa0};
   const uint8_t pps_small[] = {0x68, 0xe9, 0x79, 0x72, 0xc0};
   if (!CreateVideoToolboxSession(sps_small, arraysize(sps_small), pps_small,
                                  arraysize(pps_small), false)) {
     LOG(WARNING) << "Failed to create software VideoToolbox session. "
                  << "Hardware accelerated video decoding will be disabled.";
     return false;
   }
 
-  // Set |g_enable_compatible_configuration_reuse| to false on
-  // Mac OS X < 10.10.3.
-  base::Version os_x_version(base::SysInfo::OperatingSystemVersion());
-  if (os_x_version.IsOlderThan("10.10.3"))
-    g_enable_compatible_configuration_reuse = 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;
 
@@ skipping 19 matching lines @@
   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), reorder_window(0) {
+    : bitstream_id(bitstream_id),
+      pic_order_cnt(0),
+      is_idr(false),
+      reorder_window(0) {
 }
 
 VTVideoDecodeAccelerator::Frame::~Frame() {
 }
 
 VTVideoDecodeAccelerator::PictureInfo::PictureInfo(uint32_t client_texture_id,
                                                    uint32_t service_texture_id)
     : client_texture_id(client_texture_id),
       service_texture_id(service_texture_id) {}
 
@@ skipping 95 matching lines @@
   nalu_data_ptrs.push_back(&last_sps_.front());
   nalu_data_sizes.push_back(last_sps_.size());
   if (!last_spsext_.empty()) {
     nalu_data_ptrs.push_back(&last_spsext_.front());
     nalu_data_sizes.push_back(last_spsext_.size());
   }
   nalu_data_ptrs.push_back(&last_pps_.front());
   nalu_data_sizes.push_back(last_pps_.size());
 
   // Construct a new format description from the parameter sets.
-  // TODO(sandersd): Replace this with custom code to support OS X < 10.9.
   format_.reset();
   OSStatus status = CMVideoFormatDescriptionCreateFromH264ParameterSets(
       kCFAllocatorDefault,
       nalu_data_ptrs.size(),      // parameter_set_count
       &nalu_data_ptrs.front(),    // &parameter_set_pointers
       &nalu_data_sizes.front(),   // &parameter_set_sizes
       kNALUHeaderLength,          // nal_unit_header_length
       format_.InitializeInto());
   if (status) {
     NOTIFY_STATUS("CMVideoFormatDescriptionCreateFromH264ParameterSets()",
                   status, SFT_PLATFORM_ERROR);
     return false;
   }
 
   // Store the new configuration data.
+  // TODO(sandersd): Despite the documentation, this seems to return the visible
+  // size. However, the output always appears to be top-left aligned, so it
+  // makes no difference. Re-verify this and update the variable name.
   CMVideoDimensions coded_dimensions =
       CMVideoFormatDescriptionGetDimensions(format_);
   coded_size_.SetSize(coded_dimensions.width, coded_dimensions.height);
 
-  // If the session is compatible, there's nothing else to do.
-  if (g_enable_compatible_configuration_reuse && session_ &&
-      VTDecompressionSessionCanAcceptFormatDescription(session_, format_)) {
-    return true;
-  }
-
   // Prepare VideoToolbox configuration dictionaries.
   base::ScopedCFTypeRef<CFMutableDictionaryRef> decoder_config(
       CFDictionaryCreateMutable(
           kCFAllocatorDefault,
           1,  // capacity
           &kCFTypeDictionaryKeyCallBacks,
           &kCFTypeDictionaryValueCallBacks));
   if (!decoder_config.get()) {
     DLOG(ERROR) << "Failed to create CFMutableDictionary.";
     NotifyError(PLATFORM_FAILURE, SFT_PLATFORM_ERROR);
@@ skipping 126 matching lines @@
           NotifyError(UNREADABLE_INPUT, SFT_INVALID_STREAM);
           return;
         }
         pps.assign(nalu.data, nalu.data + nalu.size);
         break;
 
       case media::H264NALU::kSliceDataA:
       case media::H264NALU::kSliceDataB:
       case media::H264NALU::kSliceDataC:
       case media::H264NALU::kNonIDRSlice:
-        // TODO(sandersd): Check that there has been an IDR slice since the
-        // last reset.
       case media::H264NALU::kIDRSlice:
         // Compute the |pic_order_cnt| for the picture from the first slice.
-        // TODO(sandersd): Make sure that any further slices are part of the
-        // same picture or a redundant coded picture.
         if (!has_slice) {
           media::H264SliceHeader slice_hdr;
           result = parser_.ParseSliceHeader(nalu, &slice_hdr);
           if (result == media::H264Parser::kUnsupportedStream) {
             DLOG(ERROR) << "Unsupported slice header";
             NotifyError(PLATFORM_FAILURE, SFT_UNSUPPORTED_STREAM);
             return;
           }
           if (result != media::H264Parser::kOk) {
             DLOG(ERROR) << "Could not parse slice header";
@@ skipping 19 matching lines @@
             NotifyError(UNREADABLE_INPUT, SFT_INVALID_STREAM);
             return;
           }
 
           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 == media::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);
           }
         }
         has_slice = true;
       default:
         nalus.push_back(nalu);
         data_size += kNALUHeaderLength + nalu.size;
@@ skipping 16 matching lines @@
     if (last_sps_.empty()) {
       DLOG(ERROR) << "Invalid configuration; no SPS";
       NotifyError(INVALID_ARGUMENT, SFT_INVALID_STREAM);
       return;
     }
     if (last_pps_.empty()) {
       DLOG(ERROR) << "Invalid configuration; no PPS";
       NotifyError(INVALID_ARGUMENT, SFT_INVALID_STREAM);
       return;
     }
-    if (!ConfigureDecoder())
+
+    // If it's not an IDR frame, we can't reconfigure the decoder anyway. We
+    // assume that any config change not on an IDR must be compatible.
+    if (frame->is_idr && !ConfigureDecoder())
       return;
   }
 
   // If there are no image slices, drop the bitstream buffer by returning an
   // empty frame.
   if (!has_slice) {
     if (!FinishDelayedFrames())
       return;
     gpu_task_runner_->PostTask(FROM_HERE, base::Bind(
         &VTVideoDecodeAccelerator::DecodeDone, weak_this_, frame));
@@ skipping 236 matching lines @@
 bool VTVideoDecodeAccelerator::ProcessTaskQueue() {
   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:
-      // TODO(sandersd): Signal IDR explicitly (not using pic_order_cnt == 0).
       if (reorder_queue_.size() < kMaxReorderQueueSize &&
-          (task.frame->pic_order_cnt != 0 || reorder_queue_.empty())) {
+          (!task.frame->is_idr || reorder_queue_.empty())) {
         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());
@@ skipping 33 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->pic_order_cnt == 0);
+                   task_queue_.front().frame->is_idr);
 
   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;
@@ skipping 148 matching lines @@
   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|.
-  // TODO(sandersd): Make sure the decoder won't try to read the buffers again
-  // before discarding them.
+  // TODO(sandersd): Prevent the decoder from reading buffers before discarding
+  // them.
   for (int32_t bitstream_id : assigned_bitstream_ids_)
     client_->NotifyEndOfBitstreamBuffer(bitstream_id);
   assigned_bitstream_ids_.clear();
   state_ = STATE_DESTROYING;
   QueueFlush(TASK_DESTROY);
 }
 
 bool VTVideoDecodeAccelerator::CanDecodeOnIOThread() {
   return false;
 }
 
 // static
 media::VideoDecodeAccelerator::SupportedProfiles
 VTVideoDecodeAccelerator::GetSupportedProfiles() {
   SupportedProfiles profiles;
   for (const auto& supported_profile : kSupportedProfiles) {
     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 content