mac: Remove more media/base/mac glue unneeded now that we target 10.9

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/coremedia_glue.h"
-#include "media/base/mac/corevideo_glue.h"
 #include "media/base/mac/video_frame_mac.h"
 #include "third_party/webrtc/system_wrappers/include/clock.h"
 
 namespace media {
 
 namespace {
 
 // TODO(emircan): Check if we can find the actual system capabilities via
 // creating VTCompressionSessions with varying requirements.
 // See crbug.com/584784.
@@ skipping 70 matching lines @@
   DCHECK(!encoder_thread_.IsRunning());
   DCHECK(!encoder_task_weak_factory_.HasWeakPtrs());
 }
 
 VideoEncodeAccelerator::SupportedProfiles
 VTVideoEncodeAccelerator::GetSupportedProfiles() {
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   SupportedProfiles profiles;
-  // Check if HW encoder is supported initially.
-  videotoolbox_glue_ = VideoToolboxGlue::Get();
-  if (!videotoolbox_glue_) {
-    DLOG(ERROR) << "Failed creating VideoToolbox glue.";
-    return profiles;
-  }
   const bool rv = CreateCompressionSession(
       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;
   }
 
@@ skipping 22 matching lines @@
   if (PIXEL_FORMAT_I420 != format) {
     DLOG(ERROR) << "Input format not supported= "
                 << VideoPixelFormatToString(format);
     return false;
   }
   if (H264PROFILE_BASELINE != output_profile) {
     DLOG(ERROR) << "Output profile not supported= " << output_profile;
     return false;
   }
 
-  videotoolbox_glue_ = VideoToolboxGlue::Get();
-  if (!videotoolbox_glue_) {
-    DLOG(ERROR) << "Failed creating VideoToolbox glue.";
-    return false;
-  }
-
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
   input_visible_size_ = input_visible_size;
   frame_rate_ = kMaxFrameRateNumerator / kMaxFrameRateDenominator;
   initial_bitrate_ = initial_bitrate;
   bitstream_buffer_size_ = input_visible_size.GetArea();
 
   if (!encoder_thread_.Start()) {
     DLOG(ERROR) << "Failed spawning encoder thread.";
     return false;
@@ skipping 87 matching lines @@
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK(compression_session_);
   DCHECK(frame);
 
   // TODO(emircan): See if we can eliminate a copy here by using
   // CVPixelBufferPool for the allocation of incoming VideoFrames.
   base::ScopedCFTypeRef<CVPixelBufferRef> pixel_buffer =
       WrapVideoFrameInCVPixelBuffer(*frame);
   base::ScopedCFTypeRef<CFDictionaryRef> frame_props =
       video_toolbox::DictionaryWithKeyValue(
-          videotoolbox_glue_->kVTEncodeFrameOptionKey_ForceKeyFrame(),
+          kVTEncodeFrameOptionKey_ForceKeyFrame,
           force_keyframe ? kCFBooleanTrue : kCFBooleanFalse);
 
   base::TimeTicks ref_time;
   if (!frame->metadata()->GetTimeTicks(VideoFrameMetadata::REFERENCE_TIME,
                                        &ref_time)) {
     ref_time = base::TimeTicks::Now();
   }
-  auto timestamp_cm = CoreMediaGlue::CMTimeMake(
-      frame->timestamp().InMicroseconds(), USEC_PER_SEC);
+  auto timestamp_cm =
+      CMTimeMake(frame->timestamp().InMicroseconds(), USEC_PER_SEC);
   // Wrap information we'll need after the frame is encoded in a heap object.
   // We'll get the pointer back from the VideoToolbox completion callback.
   std::unique_ptr<InProgressFrameEncode> request(
       new InProgressFrameEncode(frame->timestamp(), ref_time));
 
   // Update the bitrate if needed.
   SetAdjustedBitrate(bitrate_adjuster_.GetAdjustedBitrateBps());
 
   // We can pass the ownership of |request| to the encode callback if
   // successful. Otherwise let it fall out of scope.
-  OSStatus status = videotoolbox_glue_->VTCompressionSessionEncodeFrame(
-      compression_session_, pixel_buffer, timestamp_cm,
-      CoreMediaGlue::CMTime{0, 0, 0, 0}, frame_props,
-      reinterpret_cast<void*>(request.get()), nullptr);
+  OSStatus status = VTCompressionSessionEncodeFrame(
+      compression_session_, pixel_buffer, timestamp_cm, CMTime{0, 0, 0, 0},
+      frame_props, reinterpret_cast<void*>(request.get()), nullptr);
   if (status != noErr) {
     DLOG(ERROR) << " VTCompressionSessionEncodeFrame failed: " << status;
     NotifyError(kPlatformFailureError);
   } else {
     CHECK(request.release());
   }
 }
 
 void VTVideoEncodeAccelerator::UseOutputBitstreamBufferTask(
     std::unique_ptr<BitstreamBufferRef> buffer_ref) {
@@ skipping 16 matching lines @@
     uint32_t framerate) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (!compression_session_) {
     NotifyError(kPlatformFailureError);
     return;
   }
 
   if (framerate != static_cast<uint32_t>(frame_rate_)) {
     video_toolbox::SessionPropertySetter session_property_setter(
-        compression_session_, videotoolbox_glue_);
-    session_property_setter.Set(
-        videotoolbox_glue_->kVTCompressionPropertyKey_ExpectedFrameRate(),
-        frame_rate_);
+        compression_session_);
+    session_property_setter.Set(kVTCompressionPropertyKey_ExpectedFrameRate,
+                                frame_rate_);
   }
 
   if (bitrate != static_cast<uint32_t>(target_bitrate_) && bitrate > 0) {
     target_bitrate_ = bitrate;
     bitrate_adjuster_.SetTargetBitrateBps(target_bitrate_);
     SetAdjustedBitrate(bitrate_adjuster_.GetAdjustedBitrateBps());
   }
 }
 
 void VTVideoEncodeAccelerator::SetAdjustedBitrate(int32_t bitrate) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (bitrate == encoder_set_bitrate_)
     return;
 
   encoder_set_bitrate_ = bitrate;
   video_toolbox::SessionPropertySetter session_property_setter(
-      compression_session_, videotoolbox_glue_);
+      compression_session_);
   bool rv = session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_AverageBitRate(),
-      encoder_set_bitrate_);
+      kVTCompressionPropertyKey_AverageBitRate, encoder_set_bitrate_);
   rv &= session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_DataRateLimits(),
+      kVTCompressionPropertyKey_DataRateLimits,
       video_toolbox::ArrayWithIntegerAndFloat(
           encoder_set_bitrate_ / kBitsPerByte, 1.0f));
   DLOG_IF(ERROR, !rv)
       << "Couldn't change bitrate parameters of encode session.";
 }
 
 void VTVideoEncodeAccelerator::DestroyTask() {
   DCHECK(thread_checker_.CalledOnValidThread() ||
          (encoder_thread_.IsRunning() &&
           encoder_thread_task_runner_->BelongsToCurrentThread()));
@@ skipping 65 matching lines @@
   bitstream_buffer_queue_.pop_front();
   ReturnBitstreamBuffer(std::move(encode_output), std::move(buffer_ref));
 }
 
 void VTVideoEncodeAccelerator::ReturnBitstreamBuffer(
     std::unique_ptr<EncodeOutput> encode_output,
     std::unique_ptr<VTVideoEncodeAccelerator::BitstreamBufferRef> buffer_ref) {
   DVLOG(3) << __FUNCTION__;
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
-  if (encode_output->info & VideoToolboxGlue::kVTEncodeInfo_FrameDropped) {
+  if (encode_output->info & kVTEncodeInfo_FrameDropped) {
     DVLOG(2) << " frame dropped";
     client_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Client::BitstreamBufferReady, client_, buffer_ref->id, 0,
                    false, encode_output->capture_timestamp));
     return;
   }
 
-  auto* sample_attachments =
-      static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(
-          CoreMediaGlue::CMSampleBufferGetSampleAttachmentsArray(
-              encode_output->sample_buffer.get(), true),
-          0));
+  auto* sample_attachments = static_cast<CFDictionaryRef>(
+      CFArrayGetValueAtIndex(CMSampleBufferGetSampleAttachmentsArray(
+                                 encode_output->sample_buffer.get(), true),
+                             0));
   const bool keyframe = !CFDictionaryContainsKey(
-      sample_attachments, CoreMediaGlue::kCMSampleAttachmentKey_NotSync());
+      sample_attachments, kCMSampleAttachmentKey_NotSync);
 
   size_t used_buffer_size = 0;
   const bool copy_rv = video_toolbox::CopySampleBufferToAnnexBBuffer(
       encode_output->sample_buffer.get(), keyframe, buffer_ref->size,
       reinterpret_cast<char*>(buffer_ref->shm->memory()), &used_buffer_size);
   if (!copy_rv) {
     DLOG(ERROR) << "Cannot copy output from SampleBuffer to AnnexBBuffer.";
     used_buffer_size = 0;
   }
   bitrate_adjuster_.Update(used_buffer_size);
 
   client_task_runner_->PostTask(
       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();
 
   CFTypeRef attributes_keys[] = {kCVPixelBufferOpenGLCompatibilityKey,
                                  kCVPixelBufferIOSurfacePropertiesKey,
                                  kCVPixelBufferPixelFormatTypeKey};
-  const int format[] = {
-      CoreVideoGlue::kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange};
+  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);
 
@@ skipping 13 matching lines @@
 bool VTVideoEncodeAccelerator::CreateCompressionSession(
     base::ScopedCFTypeRef<CFDictionaryRef> attributes,
     const gfx::Size& input_size,
     bool require_hw_encoding) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::vector<CFTypeRef> encoder_keys;
   std::vector<CFTypeRef> encoder_values;
   if (require_hw_encoding) {
     encoder_keys.push_back(
-        videotoolbox_glue_
-            ->kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder());
+        kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder);
     encoder_values.push_back(kCFBooleanTrue);
   } else {
     encoder_keys.push_back(
-        videotoolbox_glue_
-            ->kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder());
+        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 = videotoolbox_glue_->VTCompressionSessionCreate(
+  OSStatus status = VTCompressionSessionCreate(
       kCFAllocatorDefault, input_size.width(), input_size.height(),
-      CoreMediaGlue::kCMVideoCodecType_H264, encoder_spec, attributes,
+      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 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_, videotoolbox_glue_);
+      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(
-      videotoolbox_glue_->kVTCompressionPropertyKey_ProfileLevel(),
-      videotoolbox_glue_->kVTProfileLevel_H264_Baseline_AutoLevel());
-  rv &= session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_RealTime(), true);
-  rv &= session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_AllowFrameReordering(),
-      false);
+      kVTCompressionPropertyKey_AllowFrameReordering, false);
   // Limit keyframe output to 4 minutes, see crbug.com/658429.
   rv &= session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_MaxKeyFrameInterval(),
-      7200);
+      kVTCompressionPropertyKey_MaxKeyFrameInterval, 7200);
   rv &= session_property_setter.Set(
-      videotoolbox_glue_
-          ->kVTCompressionPropertyKey_MaxKeyFrameIntervalDuration(),
-      240);
+      kVTCompressionPropertyKey_MaxKeyFrameIntervalDuration, 240);
   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_) {
-    videotoolbox_glue_->VTCompressionSessionInvalidate(compression_session_);
+    VTCompressionSessionInvalidate(compression_session_);
     compression_session_.reset();
   }
 }
 
 }  // namespace media