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

media/cast/sender/h264_vt_encoder.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/cast/sender/h264_vt_encoder.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/synchronization/lock.h"
 #include "build/build_config.h"
-#include "media/base/mac/corevideo_glue.h"
 #include "media/base/mac/video_frame_mac.h"
 #include "media/cast/common/rtp_time.h"
 #include "media/cast/constants.h"
 #include "media/cast/sender/video_frame_factory.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
@@ skipping 109 matching lines @@
   ~Proxy() final {}
 
   const scoped_refptr<VideoFrameFactoryImpl> video_frame_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Proxy);
 };
 
 // static
 bool H264VideoToolboxEncoder::IsSupported(
     const FrameSenderConfig& video_config) {
-  return video_config.codec == CODEC_VIDEO_H264 && VideoToolboxGlue::Get();
+  return video_config.codec == CODEC_VIDEO_H264;
 }
 
 H264VideoToolboxEncoder::H264VideoToolboxEncoder(
     const scoped_refptr<CastEnvironment>& cast_environment,
     const FrameSenderConfig& video_config,
     const StatusChangeCallback& status_change_cb)
     : cast_environment_(cast_environment),
-      videotoolbox_glue_(VideoToolboxGlue::Get()),
       video_config_(video_config),
       status_change_cb_(status_change_cb),
       next_frame_id_(FrameId::first()),
       encode_next_frame_as_keyframe_(false),
       power_suspended_(false),
       weak_factory_(this) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(!status_change_cb_.is_null());
 
   OperationalStatus operational_status =
@@ skipping 49 matching lines @@
       base::Bind(status_change_cb_, STATUS_CODEC_REINIT_PENDING));
 
   // Destroy the current session, if any.
   DestroyCompressionSession();
 
   // On OS X, allow the hardware encoder. Don't require it, it does not support
   // all configurations (some of which are used for testing).
   base::ScopedCFTypeRef<CFDictionaryRef> encoder_spec;
 #if !defined(OS_IOS)
   encoder_spec = video_toolbox::DictionaryWithKeyValue(
-      videotoolbox_glue_
-          ->kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder(),
+      kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder,
       kCFBooleanTrue);
 #endif
 
   // Force 420v so that clients can easily use these buffers as GPU textures.
-  const int format[] = {
-      CoreVideoGlue::kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange};
+  const int format[] = {kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange};
 
   // Keep these attachment settings in-sync with those in ConfigureSession().
   CFTypeRef attachments_keys[] = {kCVImageBufferColorPrimariesKey,
                                   kCVImageBufferTransferFunctionKey,
                                   kCVImageBufferYCbCrMatrixKey};
   CFTypeRef attachments_values[] = {kCVImageBufferColorPrimaries_ITU_R_709_2,
                                     kCVImageBufferTransferFunction_ITU_R_709_2,
                                     kCVImageBufferYCbCrMatrix_ITU_R_709_2};
   CFTypeRef buffer_attributes_keys[] = {kCVPixelBufferPixelFormatTypeKey,
                                         kCVBufferPropagatedAttachmentsKey};
@@ skipping 12 matching lines @@
   // 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, frame_size_.width(), frame_size_.height(),
-      CoreMediaGlue::kCMVideoCodecType_H264, encoder_spec, buffer_attributes,
+      kCMVideoCodecType_H264, encoder_spec, buffer_attributes,
       nullptr /* compressedDataAllocator */,
       &H264VideoToolboxEncoder::CompressionCallback,
       reinterpret_cast<void*>(this), compression_session_.InitializeInto());
   if (status != noErr) {
     DLOG(ERROR) << " VTCompressionSessionCreate failed: " << status;
     // Notify that reinitialization has failed.
     cast_environment_->PostTask(
         CastEnvironment::MAIN, FROM_HERE,
         base::Bind(status_change_cb_, STATUS_CODEC_INIT_FAILED));
     return;
   }
 
   // Configure the session (apply session properties based on the current state
   // of the encoder, experimental tuning and requirements).
   ConfigureCompressionSession();
 
   // Update the video frame factory.
   base::ScopedCFTypeRef<CVPixelBufferPoolRef> pool(
-      videotoolbox_glue_->VTCompressionSessionGetPixelBufferPool(
-          compression_session_),
+      VTCompressionSessionGetPixelBufferPool(compression_session_),
       base::scoped_policy::RETAIN);
   video_frame_factory_->Update(pool, frame_size_);
 
   // Notify that reinitialization is done.
   cast_environment_->PostTask(
       CastEnvironment::MAIN, FROM_HERE,
       base::Bind(status_change_cb_, STATUS_INITIALIZED));
 }
 
 void H264VideoToolboxEncoder::ConfigureCompressionSession() {
   video_toolbox::SessionPropertySetter session_property_setter(
-      compression_session_, videotoolbox_glue_);
+      compression_session_);
+  session_property_setter.Set(kVTCompressionPropertyKey_ProfileLevel,
+                              kVTProfileLevel_H264_Main_AutoLevel);
+  session_property_setter.Set(kVTCompressionPropertyKey_RealTime, true);
+  session_property_setter.Set(kVTCompressionPropertyKey_AllowFrameReordering,
+                              false);
+  session_property_setter.Set(kVTCompressionPropertyKey_MaxKeyFrameInterval,
+                              240);
   session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_ProfileLevel(),
-      videotoolbox_glue_->kVTProfileLevel_H264_Main_AutoLevel());
-  session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_RealTime(), true);
-  session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_AllowFrameReordering(),
-      false);
-  session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_MaxKeyFrameInterval(), 240);
-  session_property_setter.Set(
-      videotoolbox_glue_
-          ->kVTCompressionPropertyKey_MaxKeyFrameIntervalDuration(),
-      240);
+      kVTCompressionPropertyKey_MaxKeyFrameIntervalDuration, 240);
   // TODO(jfroy): implement better bitrate control
   //              https://crbug.com/425352
   session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_AverageBitRate(),
+      kVTCompressionPropertyKey_AverageBitRate,
       (video_config_.min_bitrate + video_config_.max_bitrate) / 2);
   session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_ExpectedFrameRate(),
+      kVTCompressionPropertyKey_ExpectedFrameRate,
       static_cast<int>(video_config_.max_frame_rate + 0.5));
   // Keep these attachment settings in-sync with those in Initialize().
-  session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_ColorPrimaries(),
-      kCVImageBufferColorPrimaries_ITU_R_709_2);
-  session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_TransferFunction(),
-      kCVImageBufferTransferFunction_ITU_R_709_2);
-  session_property_setter.Set(
-      videotoolbox_glue_->kVTCompressionPropertyKey_YCbCrMatrix(),
-      kCVImageBufferYCbCrMatrix_ITU_R_709_2);
+  session_property_setter.Set(kVTCompressionPropertyKey_ColorPrimaries,
+                              kCVImageBufferColorPrimaries_ITU_R_709_2);
+  session_property_setter.Set(kVTCompressionPropertyKey_TransferFunction,
+                              kCVImageBufferTransferFunction_ITU_R_709_2);
+  session_property_setter.Set(kVTCompressionPropertyKey_YCbCrMatrix,
+                              kCVImageBufferYCbCrMatrix_ITU_R_709_2);
   if (video_config_.video_codec_params.max_number_of_video_buffers_used > 0) {
     session_property_setter.Set(
-        videotoolbox_glue_->kVTCompressionPropertyKey_MaxFrameDelayCount(),
+        kVTCompressionPropertyKey_MaxFrameDelayCount,
         video_config_.video_codec_params.max_number_of_video_buffers_used);
   }
 }
 
 void H264VideoToolboxEncoder::DestroyCompressionSession() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If the compression session exists, invalidate it. This blocks until all
   // pending output callbacks have returned and any internal threads have
   // joined, ensuring no output callback ever sees a dangling encoder pointer.
   //
   // Before destroying the compression session, the video frame factory's pool
   // is updated to null so that no thread will produce new video frames via the
   // factory until a new compression session is created. The current frame size
   // is passed to prevent the video frame factory from posting |UpdateFrameSize|
   // tasks. Indeed, |DestroyCompressionSession| is either called from
   // |ResetCompressionSession|, in which case a new pool and frame size will be
   // set, or from callsites that require that there be no compression session
   // (ex: the dtor).
   if (compression_session_) {
     video_frame_factory_->Update(
         base::ScopedCFTypeRef<CVPixelBufferPoolRef>(nullptr), frame_size_);
-    videotoolbox_glue_->VTCompressionSessionInvalidate(compression_session_);
+    VTCompressionSessionInvalidate(compression_session_);
     compression_session_.reset();
   }
 }
 
 bool H264VideoToolboxEncoder::EncodeVideoFrame(
     const scoped_refptr<media::VideoFrame>& video_frame,
     const base::TimeTicks& reference_time,
     const FrameEncodedCallback& frame_encoded_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!frame_encoded_callback.is_null());
@@ skipping 23 matching lines @@
   // compression session's pixel buffer pool. This will eliminate a copy of the
   // frame into memory visible by the hardware encoder. The VideoFrame's
   // lifetime is extended for the lifetime of the returned CVPixelBuffer.
   auto pixel_buffer = media::WrapVideoFrameInCVPixelBuffer(*video_frame);
   if (!pixel_buffer) {
     DLOG(ERROR) << "WrapVideoFrameInCVPixelBuffer failed.";
     return false;
   }
 
   // Convert the frame timestamp to CMTime.
-  auto timestamp_cm = CoreMediaGlue::CMTimeMake(
-      video_frame->timestamp().InMicroseconds(), USEC_PER_SEC);
+  auto timestamp_cm =
+      CMTimeMake(video_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(
       RtpTimeTicks::FromTimeDelta(video_frame->timestamp(), kVideoFrequency),
       reference_time, frame_encoded_callback));
 
   // Build a suitable frame properties dictionary for keyframes.
   base::ScopedCFTypeRef<CFDictionaryRef> frame_props;
   if (encode_next_frame_as_keyframe_) {
     frame_props = video_toolbox::DictionaryWithKeyValue(
-        videotoolbox_glue_->kVTEncodeFrameOptionKey_ForceKeyFrame(),
-        kCFBooleanTrue);
+        kVTEncodeFrameOptionKey_ForceKeyFrame, kCFBooleanTrue);
     encode_next_frame_as_keyframe_ = false;
   }
 
   // Submit the frame to the compression session. The function returns as soon
   // as the frame has been enqueued.
-  OSStatus status = videotoolbox_glue_->VTCompressionSessionEncodeFrame(
-      compression_session_, pixel_buffer, timestamp_cm,
-      CoreMediaGlue::CMTime{0, 0, 0, 0}, frame_props,
-      reinterpret_cast<void*>(request.release()), nullptr);
+  OSStatus status = VTCompressionSessionEncodeFrame(
+      compression_session_, pixel_buffer, timestamp_cm, CMTime{0, 0, 0, 0},
+      frame_props, reinterpret_cast<void*>(request.release()), nullptr);
   if (status != noErr) {
     DLOG(ERROR) << " VTCompressionSessionEncodeFrame failed: " << status;
     return false;
   }
 
   return true;
 }
 
 void H264VideoToolboxEncoder::UpdateFrameSize(const gfx::Size& size_needed) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 36 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   return std::unique_ptr<VideoFrameFactory>(
       new VideoFrameFactoryImpl::Proxy(video_frame_factory_));
 }
 
 void H264VideoToolboxEncoder::EmitFrames() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!compression_session_)
     return;
 
-  OSStatus status = videotoolbox_glue_->VTCompressionSessionCompleteFrames(
-      compression_session_, CoreMediaGlue::CMTime{0, 0, 0, 0});
+  OSStatus status = VTCompressionSessionCompleteFrames(compression_session_,
+                                                       CMTime{0, 0, 0, 0});
   if (status != noErr) {
     DLOG(ERROR) << " VTCompressionSessionCompleteFrames failed: " << status;
   }
 }
 
 void H264VideoToolboxEncoder::OnSuspend() {
   VLOG(1)
       << "OnSuspend: Emitting all frames and destroying compression session.";
   EmitFrames();
   DestroyCompressionSession();
@@ skipping 22 matching lines @@
   const std::unique_ptr<InProgressFrameEncode> request(
       reinterpret_cast<InProgressFrameEncode*>(request_opaque));
   bool keyframe = false;
   bool has_frame_data = false;
 
   if (status != noErr) {
     DLOG(ERROR) << " encoding failed: " << status;
     encoder->cast_environment_->PostTask(
         CastEnvironment::MAIN, FROM_HERE,
         base::Bind(encoder->status_change_cb_, STATUS_CODEC_RUNTIME_ERROR));
-  } else if ((info & VideoToolboxGlue::kVTEncodeInfo_FrameDropped)) {
+  } else if ((info & kVTEncodeInfo_FrameDropped)) {
     DVLOG(2) << " frame dropped";
   } else {
     auto* sample_attachments =
         static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(
-            CoreMediaGlue::CMSampleBufferGetSampleAttachmentsArray(sbuf, true),
-            0));
+            CMSampleBufferGetSampleAttachmentsArray(sbuf, true), 0));
 
     // If the NotSync key is not present, it implies Sync, which indicates a
     // keyframe (at least I think, VT documentation is, erm, sparse). Could
     // alternatively use kCMSampleAttachmentKey_DependsOnOthers == false.
-    keyframe = !CFDictionaryContainsKey(
-                   sample_attachments,
-                   CoreMediaGlue::kCMSampleAttachmentKey_NotSync());
+    keyframe = !CFDictionaryContainsKey(sample_attachments,
+                                        kCMSampleAttachmentKey_NotSync);
     has_frame_data = true;
   }
 
   // Grab the next frame ID and increment |next_frame_id_| for next time.
   // VideoToolbox calls the output callback serially, so this is safe.
   const FrameId frame_id = encoder->next_frame_id_++;
 
   std::unique_ptr<SenderEncodedFrame> encoded_frame(new SenderEncodedFrame());
   encoded_frame->frame_id = frame_id;
   encoded_frame->reference_time = request->reference_time;
@@ skipping 26 matching lines @@
   encoded_frame->encode_completion_time =
       encoder->cast_environment_->Clock()->NowTicks();
   encoder->cast_environment_->PostTask(
       CastEnvironment::MAIN, FROM_HERE,
       base::Bind(request->frame_encoded_callback,
                  base::Passed(&encoded_frame)));
 }
 
 }  // namespace cast
 }  // namespace media