Revert of Enforce MaxFrameDelayCount in VTVideoEncodeAccelerator and cleanups

media/gpu/vt_video_encode_accelerator_mac.cc

 // Copyright 2016 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_encode_accelerator_mac.h"
 
 #include <memory>
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/base/mac/video_frame_mac.h"
@@ skipping 79 matching lines @@
   DCHECK(!encoder_task_weak_factory_.HasWeakPtrs());
 }
 
 VideoEncodeAccelerator::SupportedProfiles
 VTVideoEncodeAccelerator::GetSupportedProfiles() {
   DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   SupportedProfiles profiles;
   const bool rv = CreateCompressionSession(
-      gfx::Size(kDefaultResolutionWidth, kDefaultResolutionHeight));
+      video_toolbox::DictionaryWithKeysAndValues(nullptr, nullptr, 0),
+      gfx::Size(kDefaultResolutionWidth, kDefaultResolutionHeight), true);
   DestroyCompressionSession();
   if (!rv) {
     VLOG(1)
         << "Hardware encode acceleration is not available on this platform.";
     return profiles;
   }
 
   SupportedProfile profile;
   profile.profile = H264PROFILE_BASELINE;
   profile.max_framerate_numerator = kMaxFrameRateNumerator;
@@ skipping 334 matching lines @@
       FROM_HERE,
       base::Bind(&Client::BitstreamBufferReady, client_, buffer_ref->id,
                  used_buffer_size, keyframe, encode_output->capture_timestamp));
 }
 
 bool VTVideoEncodeAccelerator::ResetCompressionSession() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DestroyCompressionSession();
 
-  bool session_rv = CreateCompressionSession(input_visible_size_);
+  CFTypeRef attributes_keys[] = {kCVPixelBufferOpenGLCompatibilityKey,
+                                 kCVPixelBufferIOSurfacePropertiesKey,
+                                 kCVPixelBufferPixelFormatTypeKey};
+  const int format[] = {kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange};
+  CFTypeRef attributes_values[] = {
+      kCFBooleanTrue,
+      video_toolbox::DictionaryWithKeysAndValues(nullptr, nullptr, 0).release(),
+      video_toolbox::ArrayWithIntegers(format, arraysize(format)).release()};
+  const base::ScopedCFTypeRef<CFDictionaryRef> attributes =
+      video_toolbox::DictionaryWithKeysAndValues(
+          attributes_keys, attributes_values, arraysize(attributes_keys));
+  for (auto* v : attributes_values)
+    CFRelease(v);
+
+  bool session_rv =
+      CreateCompressionSession(attributes, input_visible_size_, false);
   if (!session_rv) {
     DestroyCompressionSession();
     return false;
   }
 
   const bool configure_rv = ConfigureCompressionSession();
   if (configure_rv)
     RequestEncodingParametersChange(initial_bitrate_, frame_rate_);
   return configure_rv;
 }
 
 bool VTVideoEncodeAccelerator::CreateCompressionSession(
-    const gfx::Size& input_size) {
+    base::ScopedCFTypeRef<CFDictionaryRef> attributes,
+    const gfx::Size& input_size,
+    bool require_hw_encoding) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  std::vector<CFTypeRef> encoder_keys(
-      1, kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder);
-  std::vector<CFTypeRef> encoder_values(1, kCFBooleanTrue);
+  std::vector<CFTypeRef> encoder_keys;
+  std::vector<CFTypeRef> encoder_values;
+  if (require_hw_encoding) {
+    encoder_keys.push_back(
+        kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder);
+    encoder_values.push_back(kCFBooleanTrue);
+  } else {
+    encoder_keys.push_back(
+        kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder);
+    encoder_values.push_back(kCFBooleanTrue);
+  }
   base::ScopedCFTypeRef<CFDictionaryRef> encoder_spec =
       video_toolbox::DictionaryWithKeysAndValues(
           encoder_keys.data(), encoder_values.data(), encoder_keys.size());
 
   // Create the compression session.
   // Note that the encoder object is given to the compression session as the
   // callback context using a raw pointer. The C API does not allow us to use a
   // smart pointer, nor is this encoder ref counted. However, this is still
   // safe, because we 1) we own the compression session and 2) we tear it down
   // safely. When destructing the encoder, the compression session is flushed
   // and invalidated. Internally, VideoToolbox will join all of its threads
   // before returning to the client. Therefore, when control returns to us, we
   // are guaranteed that the output callback will not execute again.
   OSStatus status = VTCompressionSessionCreate(
       kCFAllocatorDefault, input_size.width(), input_size.height(),
-      kCMVideoCodecType_H264, encoder_spec,
-      nullptr /* sourceImageBufferAttributes */,
+      kCMVideoCodecType_H264, encoder_spec, attributes,
       nullptr /* compressedDataAllocator */,
       &VTVideoEncodeAccelerator::CompressionCallback,
       reinterpret_cast<void*>(this), compression_session_.InitializeInto());
   if (status != noErr) {
     DLOG(ERROR) << " VTCompressionSessionCreate failed: " << status;
     return false;
   }
-  DVLOG(3) << " VTCompressionSession created with input size="
-           << input_size.ToString();
+  DVLOG(3) << " VTCompressionSession created with HW encode: "
+           << require_hw_encoding << ", input size=" << input_size.ToString();
   return true;
 }
 
 bool VTVideoEncodeAccelerator::ConfigureCompressionSession() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(compression_session_);
 
   video_toolbox::SessionPropertySetter session_property_setter(
       compression_session_);
   bool rv = true;
   rv &= session_property_setter.Set(kVTCompressionPropertyKey_ProfileLevel,
                                     kVTProfileLevel_H264_Baseline_AutoLevel);
   rv &= session_property_setter.Set(kVTCompressionPropertyKey_RealTime, true);
   rv &= session_property_setter.Set(
       kVTCompressionPropertyKey_AllowFrameReordering, false);
   // Limit keyframe output to 4 minutes, see crbug.com/658429.
   rv &= session_property_setter.Set(
       kVTCompressionPropertyKey_MaxKeyFrameInterval, 7200);
   rv &= session_property_setter.Set(
       kVTCompressionPropertyKey_MaxKeyFrameIntervalDuration, 240);
-  rv &=
-      session_property_setter.Set(kVTCompressionPropertyKey_MaxFrameDelayCount,
-                                  static_cast<int>(kNumInputBuffers));
   DLOG_IF(ERROR, !rv) << " Setting session property failed.";
   return rv;
 }
 
 void VTVideoEncodeAccelerator::DestroyCompressionSession() {
   DCHECK(thread_checker_.CalledOnValidThread() ||
          (encoder_thread_.IsRunning() &&
           encoder_thread_task_runner_->BelongsToCurrentThread()));
 
   if (compression_session_) {
     VTCompressionSessionInvalidate(compression_session_);
     compression_session_.reset();
   }
 }
 
 }  // namespace media