content/common/gpu/media/vt_video_encode_accelerator_mac.cc - chromium/src - Git at Google

 // 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 "content/common/gpu/media/vt_video_encode_accelerator_mac.h"

 #include "base/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"

 namespace content {

 namespace {

 // TODO(emircan): Check if we can find the actual system capabilities via
 // creating VTCompressionSessions with varying requirements.
 // See crbug.com/584784.
 const size_t kBitsPerByte = 8;
 const size_t kDefaultResolutionWidth = 640;
 const size_t kDefaultResolutionHeight = 480;
 const size_t kMaxFrameRateNumerator = 30;
 const size_t kMaxFrameRateDenominator = 1;
 const size_t kMaxResolutionWidth = 4096;
 const size_t kMaxResolutionHeight = 2160;
 const size_t kNumInputBuffers = 3;

 }  // namespace

 struct VTVideoEncodeAccelerator::InProgressFrameEncode {
   InProgressFrameEncode(base::TimeDelta rtp_timestamp,
                         base::TimeTicks ref_time)
       : timestamp(rtp_timestamp), reference_time(ref_time) {}
   const base::TimeDelta timestamp;
   const base::TimeTicks reference_time;

  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(InProgressFrameEncode);
 };

 struct VTVideoEncodeAccelerator::EncodeOutput {
   EncodeOutput(VTEncodeInfoFlags info_flags, CMSampleBufferRef sbuf)
       : info(info_flags), sample_buffer(sbuf, base::scoped_policy::RETAIN) {}
   const VTEncodeInfoFlags info;
   const base::ScopedCFTypeRef<CMSampleBufferRef> sample_buffer;

  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(EncodeOutput);
 };

 struct VTVideoEncodeAccelerator::BitstreamBufferRef {
   BitstreamBufferRef(int32_t id,
                      scoped_ptr<base::SharedMemory> shm,
                      size_t size)
       : id(id), shm(std::move(shm)), size(size) {}
   const int32_t id;
   const scoped_ptr<base::SharedMemory> shm;
   const size_t size;

  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(BitstreamBufferRef);
 };

 VTVideoEncodeAccelerator::VTVideoEncodeAccelerator()
     : client_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       encoder_thread_("VTEncoderThread"),
       encoder_task_weak_factory_(this) {
   encoder_weak_ptr_ = encoder_task_weak_factory_.GetWeakPtr();
 }

 VTVideoEncodeAccelerator::~VTVideoEncodeAccelerator() {
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());

   Destroy();
   DCHECK(!encoder_thread_.IsRunning());
   DCHECK(!encoder_task_weak_factory_.HasWeakPtrs());
 }

 media::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(
       media::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 = media::H264PROFILE_BASELINE;
   profile.max_framerate_numerator = kMaxFrameRateNumerator;
   profile.max_framerate_denominator = kMaxFrameRateDenominator;
   profile.max_resolution = gfx::Size(kMaxResolutionWidth, kMaxResolutionHeight);
   profiles.push_back(profile);
   return profiles;
 }

 bool VTVideoEncodeAccelerator::Initialize(
     media::VideoPixelFormat format,
     const gfx::Size& input_visible_size,
     media::VideoCodecProfile output_profile,
     uint32_t initial_bitrate,
     Client* client) {
   DVLOG(3) << __FUNCTION__
            << ": input_format=" << media::VideoPixelFormatToString(format)
            << ", input_visible_size=" << input_visible_size.ToString()
            << ", output_profile=" << output_profile
            << ", initial_bitrate=" << initial_bitrate;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(client);

   if (media::PIXEL_FORMAT_I420 != format) {
     DLOG(ERROR) << "Input format not supported= "
                 << media::VideoPixelFormatToString(format);
     return false;
   }
   if (media::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;
   target_bitrate_ = initial_bitrate;
   bitstream_buffer_size_ = input_visible_size.GetArea();

   if (!encoder_thread_.Start()) {
     DLOG(ERROR) << "Failed spawning encoder thread.";
     return false;
   }
   encoder_thread_task_runner_ = encoder_thread_.task_runner();

   if (!ResetCompressionSession()) {
     DLOG(ERROR) << "Failed creating compression session.";
     return false;
   }

   client_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Client::RequireBitstreamBuffers, client_, kNumInputBuffers,
                  input_visible_size_, bitstream_buffer_size_));
   return true;
 }

 void VTVideoEncodeAccelerator::Encode(
     const scoped_refptr<media::VideoFrame>& frame,
     bool force_keyframe) {
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());

   encoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VTVideoEncodeAccelerator::EncodeTask,
                             base::Unretained(this), frame, force_keyframe));
 }

 void VTVideoEncodeAccelerator::UseOutputBitstreamBuffer(
     const media::BitstreamBuffer& buffer) {
   DVLOG(3) << __FUNCTION__ << ": buffer size=" << buffer.size();
   DCHECK(thread_checker_.CalledOnValidThread());

   if (buffer.size() < bitstream_buffer_size_) {
     DLOG(ERROR) << "Output BitstreamBuffer isn't big enough: " << buffer.size()
                 << " vs. " << bitstream_buffer_size_;
     client_->NotifyError(kInvalidArgumentError);
     return;
   }

   scoped_ptr<base::SharedMemory> shm(
       new base::SharedMemory(buffer.handle(), false));
   if (!shm->Map(buffer.size())) {
     DLOG(ERROR) << "Failed mapping shared memory.";
     client_->NotifyError(kPlatformFailureError);
     return;
   }

   scoped_ptr<BitstreamBufferRef> buffer_ref(
       new BitstreamBufferRef(buffer.id(), std::move(shm), buffer.size()));

   encoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VTVideoEncodeAccelerator::UseOutputBitstreamBufferTask,
                  base::Unretained(this), base::Passed(&buffer_ref)));
 }

 void VTVideoEncodeAccelerator::RequestEncodingParametersChange(
     uint32_t bitrate,
     uint32_t framerate) {
   DVLOG(3) << __FUNCTION__ << ": bitrate=" << bitrate
            << ": framerate=" << framerate;
   DCHECK(thread_checker_.CalledOnValidThread());

   encoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VTVideoEncodeAccelerator::RequestEncodingParametersChangeTask,
                  base::Unretained(this), bitrate, framerate));
 }

 void VTVideoEncodeAccelerator::Destroy() {
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());

   // Cancel all callbacks.
   client_ptr_factory_.reset();

   if (encoder_thread_.IsRunning()) {
     encoder_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&VTVideoEncodeAccelerator::DestroyTask,
                    base::Unretained(this)));
     encoder_thread_.Stop();
   } else {
     DestroyTask();
   }
 }

 void VTVideoEncodeAccelerator::EncodeTask(
     const scoped_refptr<media::VideoFrame>& frame,
     bool force_keyframe) {
   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 =
       media::WrapVideoFrameInCVPixelBuffer(*frame);
   base::ScopedCFTypeRef<CFDictionaryRef> frame_props =
       media::video_toolbox::DictionaryWithKeyValue(
           videotoolbox_glue_->kVTEncodeFrameOptionKey_ForceKeyFrame(),
           force_keyframe ? kCFBooleanTrue : kCFBooleanFalse);

   base::TimeTicks ref_time;
   if (!frame->metadata()->GetTimeTicks(
           media::VideoFrameMetadata::REFERENCE_TIME, &ref_time)) {
     ref_time = base::TimeTicks::Now();
   }
   auto timestamp_cm = CoreMediaGlue::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.
   scoped_ptr<InProgressFrameEncode> request(new InProgressFrameEncode(
       frame->timestamp(), ref_time));

   // 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);
   if (status != noErr) {
     DLOG(ERROR) << " VTCompressionSessionEncodeFrame failed: " << status;
     NotifyError(kPlatformFailureError);
   } else {
     CHECK(request.release());
   }
 }

 void VTVideoEncodeAccelerator::UseOutputBitstreamBufferTask(
     scoped_ptr<BitstreamBufferRef> buffer_ref) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());

   // If there is already EncodeOutput waiting, copy its output first.
   if (!encoder_output_queue_.empty()) {
     scoped_ptr<VTVideoEncodeAccelerator::EncodeOutput> encode_output =
         std::move(encoder_output_queue_.front());
     encoder_output_queue_.pop_front();
     ReturnBitstreamBuffer(std::move(encode_output), std::move(buffer_ref));
     return;
   }

   bitstream_buffer_queue_.push_back(std::move(buffer_ref));
 }

 void VTVideoEncodeAccelerator::RequestEncodingParametersChangeTask(
     uint32_t bitrate,
     uint32_t framerate) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());

   frame_rate_ = framerate > 1 ? framerate : 1;
   target_bitrate_ = bitrate > 1 ? bitrate : 1;

   if (!compression_session_) {
     NotifyError(kPlatformFailureError);
     return;
   }

   media::video_toolbox::SessionPropertySetter session_property_setter(
       compression_session_, videotoolbox_glue_);
   // TODO(emircan): See crbug.com/425352.
   bool rv = session_property_setter.Set(
       videotoolbox_glue_->kVTCompressionPropertyKey_AverageBitRate(),
       target_bitrate_);
   rv &= session_property_setter.Set(
       videotoolbox_glue_->kVTCompressionPropertyKey_ExpectedFrameRate(),
       frame_rate_);
   rv &= session_property_setter.Set(
       videotoolbox_glue_->kVTCompressionPropertyKey_DataRateLimits(),
       media::video_toolbox::ArrayWithIntegerAndFloat(
           target_bitrate_ / kBitsPerByte, 1.0f));
   DLOG_IF(ERROR, !rv) << "Couldn't change session encoding parameters.";
 }

 void VTVideoEncodeAccelerator::DestroyTask() {
   DCHECK(thread_checker_.CalledOnValidThread() ||
          (encoder_thread_.IsRunning() &&
           encoder_thread_task_runner_->BelongsToCurrentThread()));

   // Cancel all encoder thread callbacks.
   encoder_task_weak_factory_.InvalidateWeakPtrs();

   // This call blocks until all pending frames are flushed out.
   DestroyCompressionSession();
 }

 void VTVideoEncodeAccelerator::NotifyError(
     media::VideoEncodeAccelerator::Error error) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
   client_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Client::NotifyError, client_, error));
 }

 // static
 void VTVideoEncodeAccelerator::CompressionCallback(void* encoder_opaque,
                                                    void* request_opaque,
                                                    OSStatus status,
                                                    VTEncodeInfoFlags info,
                                                    CMSampleBufferRef sbuf) {
   // This function may be called asynchronously, on a different thread from the
   // one that calls VTCompressionSessionEncodeFrame.
   DVLOG(3) << __FUNCTION__;

   auto encoder = reinterpret_cast<VTVideoEncodeAccelerator*>(encoder_opaque);
   DCHECK(encoder);

   // Release InProgressFrameEncode, since we don't have support to return
   // timestamps at this point.
   scoped_ptr<InProgressFrameEncode> request(
       reinterpret_cast<InProgressFrameEncode*>(request_opaque));
   request.reset();

   // EncodeOutput holds onto CMSampleBufferRef when posting task between
   // threads.
   scoped_ptr<EncodeOutput> encode_output(new EncodeOutput(info, sbuf));

   // This method is NOT called on |encoder_thread_|, so we still need to
   // post a task back to it to do work.
   encoder->encoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VTVideoEncodeAccelerator::CompressionCallbackTask,
                             encoder->encoder_weak_ptr_, status,
                             base::Passed(&encode_output)));
 }

 void VTVideoEncodeAccelerator::CompressionCallbackTask(
     OSStatus status,
     scoped_ptr<EncodeOutput> encode_output) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());

   if (status != noErr) {
     DLOG(ERROR) << " encode failed: " << status;
     NotifyError(kPlatformFailureError);
     return;
   }

   // If there isn't any BitstreamBuffer to copy into, add it to a queue for
   // later use.
   if (bitstream_buffer_queue_.empty()) {
     encoder_output_queue_.push_back(std::move(encode_output));
     return;
   }

   scoped_ptr<VTVideoEncodeAccelerator::BitstreamBufferRef> buffer_ref =
       std::move(bitstream_buffer_queue_.front());
   bitstream_buffer_queue_.pop_front();
   ReturnBitstreamBuffer(std::move(encode_output), std::move(buffer_ref));
 }

 void VTVideoEncodeAccelerator::ReturnBitstreamBuffer(
     scoped_ptr<EncodeOutput> encode_output,
     scoped_ptr<VTVideoEncodeAccelerator::BitstreamBufferRef> buffer_ref) {
   DVLOG(3) << __FUNCTION__;
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());

   if (encode_output->info & VideoToolboxGlue::kVTEncodeInfo_FrameDropped) {
     DVLOG(2) << " frame dropped";
     client_task_runner_->PostTask(
         FROM_HERE, base::Bind(&Client::BitstreamBufferReady, client_,
                               buffer_ref->id, 0, false));
     return;
   }

   auto sample_attachments = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(
       CoreMediaGlue::CMSampleBufferGetSampleAttachmentsArray(
           encode_output->sample_buffer.get(), true),
       0));
   const bool keyframe =
       !CFDictionaryContainsKey(sample_attachments,
                                CoreMediaGlue::kCMSampleAttachmentKey_NotSync());

   size_t used_buffer_size = 0;
   const bool copy_rv = media::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;
   }

   client_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Client::BitstreamBufferReady, client_,
                             buffer_ref->id, used_buffer_size, keyframe));
 }

 bool VTVideoEncodeAccelerator::ResetCompressionSession() {
   DCHECK(thread_checker_.CalledOnValidThread());

   DestroyCompressionSession();

   CFTypeRef attributes_keys[] = {
     kCVPixelBufferOpenGLCompatibilityKey,
     kCVPixelBufferIOSurfacePropertiesKey,
     kCVPixelBufferPixelFormatTypeKey
   };
   const int format[] = {
       CoreVideoGlue::kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange};
   CFTypeRef attributes_values[] = {
       kCFBooleanTrue,
       media::video_toolbox::DictionaryWithKeysAndValues(nullptr, nullptr, 0)
           .release(),
       media::video_toolbox::ArrayWithIntegers(format, arraysize(format))
           .release()};
   const base::ScopedCFTypeRef<CFDictionaryRef> attributes =
       media::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(target_bitrate_, frame_rate_);
   return configure_rv;
 }

 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());
     encoder_values.push_back(kCFBooleanTrue);
   } else {
     encoder_keys.push_back(videotoolbox_glue_
         ->kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder());
     encoder_values.push_back(kCFBooleanTrue);
   }
   base::ScopedCFTypeRef<CFDictionaryRef> encoder_spec =
       media::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(
       kCFAllocatorDefault,
       input_size.width(),
       input_size.height(),
       CoreMediaGlue::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_);

   media::video_toolbox::SessionPropertySetter session_property_setter(
       compression_session_, videotoolbox_glue_);
   bool rv = 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);
   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_);
     compression_session_.reset();
   }
 }

 } // namespace content
	// 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 "content/common/gpu/media/vt_video_encode_accelerator_mac.h"

	#include "base/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"

	namespace content {

	namespace {

	// TODO(emircan): Check if we can find the actual system capabilities via
	// creating VTCompressionSessions with varying requirements.
	// See crbug.com/584784.
	const size_t kBitsPerByte = 8;
	const size_t kDefaultResolutionWidth = 640;
	const size_t kDefaultResolutionHeight = 480;
	const size_t kMaxFrameRateNumerator = 30;
	const size_t kMaxFrameRateDenominator = 1;
	const size_t kMaxResolutionWidth = 4096;
	const size_t kMaxResolutionHeight = 2160;
	const size_t kNumInputBuffers = 3;

	} // namespace

	struct VTVideoEncodeAccelerator::InProgressFrameEncode {
	InProgressFrameEncode(base::TimeDelta rtp_timestamp,
	base::TimeTicks ref_time)
	: timestamp(rtp_timestamp), reference_time(ref_time) {}
	const base::TimeDelta timestamp;
	const base::TimeTicks reference_time;

	private:
	DISALLOW_IMPLICIT_CONSTRUCTORS(InProgressFrameEncode);
	};

	struct VTVideoEncodeAccelerator::EncodeOutput {
	EncodeOutput(VTEncodeInfoFlags info_flags, CMSampleBufferRef sbuf)
	: info(info_flags), sample_buffer(sbuf, base::scoped_policy::RETAIN) {}
	const VTEncodeInfoFlags info;
	const base::ScopedCFTypeRef<CMSampleBufferRef> sample_buffer;

	private:
	DISALLOW_IMPLICIT_CONSTRUCTORS(EncodeOutput);
	};

	struct VTVideoEncodeAccelerator::BitstreamBufferRef {
	BitstreamBufferRef(int32_t id,
	scoped_ptr<base::SharedMemory> shm,
	size_t size)
	: id(id), shm(std::move(shm)), size(size) {}
	const int32_t id;
	const scoped_ptr<base::SharedMemory> shm;
	const size_t size;

	private:
	DISALLOW_IMPLICIT_CONSTRUCTORS(BitstreamBufferRef);
	};

	VTVideoEncodeAccelerator::VTVideoEncodeAccelerator()
	: client_task_runner_(base::ThreadTaskRunnerHandle::Get()),
	encoder_thread_("VTEncoderThread"),
	encoder_task_weak_factory_(this) {
	encoder_weak_ptr_ = encoder_task_weak_factory_.GetWeakPtr();
	}

	VTVideoEncodeAccelerator::~VTVideoEncodeAccelerator() {
	DVLOG(3) << __FUNCTION__;
	DCHECK(thread_checker_.CalledOnValidThread());

	Destroy();
	DCHECK(!encoder_thread_.IsRunning());
	DCHECK(!encoder_task_weak_factory_.HasWeakPtrs());
	}

	media::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(
	media::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 = media::H264PROFILE_BASELINE;
	profile.max_framerate_numerator = kMaxFrameRateNumerator;
	profile.max_framerate_denominator = kMaxFrameRateDenominator;
	profile.max_resolution = gfx::Size(kMaxResolutionWidth, kMaxResolutionHeight);
	profiles.push_back(profile);
	return profiles;
	}

	bool VTVideoEncodeAccelerator::Initialize(
	media::VideoPixelFormat format,
	const gfx::Size& input_visible_size,
	media::VideoCodecProfile output_profile,
	uint32_t initial_bitrate,
	Client* client) {
	DVLOG(3) << __FUNCTION__
	<< ": input_format=" << media::VideoPixelFormatToString(format)
	<< ", input_visible_size=" << input_visible_size.ToString()
	<< ", output_profile=" << output_profile
	<< ", initial_bitrate=" << initial_bitrate;
	DCHECK(thread_checker_.CalledOnValidThread());
	DCHECK(client);

	if (media::PIXEL_FORMAT_I420 != format) {
	DLOG(ERROR) << "Input format not supported= "
	<< media::VideoPixelFormatToString(format);
	return false;
	}
	if (media::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;
	target_bitrate_ = initial_bitrate;
	bitstream_buffer_size_ = input_visible_size.GetArea();

	if (!encoder_thread_.Start()) {
	DLOG(ERROR) << "Failed spawning encoder thread.";
	return false;
	}
	encoder_thread_task_runner_ = encoder_thread_.task_runner();

	if (!ResetCompressionSession()) {
	DLOG(ERROR) << "Failed creating compression session.";
	return false;
	}

	client_task_runner_->PostTask(
	FROM_HERE,
	base::Bind(&Client::RequireBitstreamBuffers, client_, kNumInputBuffers,
	input_visible_size_, bitstream_buffer_size_));
	return true;
	}

	void VTVideoEncodeAccelerator::Encode(
	const scoped_refptr<media::VideoFrame>& frame,
	bool force_keyframe) {
	DVLOG(3) << __FUNCTION__;
	DCHECK(thread_checker_.CalledOnValidThread());

	encoder_thread_task_runner_->PostTask(
	FROM_HERE, base::Bind(&VTVideoEncodeAccelerator::EncodeTask,
	base::Unretained(this), frame, force_keyframe));
	}

	void VTVideoEncodeAccelerator::UseOutputBitstreamBuffer(
	const media::BitstreamBuffer& buffer) {
	DVLOG(3) << __FUNCTION__ << ": buffer size=" << buffer.size();
	DCHECK(thread_checker_.CalledOnValidThread());

	if (buffer.size() < bitstream_buffer_size_) {
	DLOG(ERROR) << "Output BitstreamBuffer isn't big enough: " << buffer.size()
	<< " vs. " << bitstream_buffer_size_;
	client_->NotifyError(kInvalidArgumentError);
	return;
	}

	scoped_ptr<base::SharedMemory> shm(
	new base::SharedMemory(buffer.handle(), false));
	if (!shm->Map(buffer.size())) {
	DLOG(ERROR) << "Failed mapping shared memory.";
	client_->NotifyError(kPlatformFailureError);
	return;
	}

	scoped_ptr<BitstreamBufferRef> buffer_ref(
	new BitstreamBufferRef(buffer.id(), std::move(shm), buffer.size()));

	encoder_thread_task_runner_->PostTask(
	FROM_HERE,
	base::Bind(&VTVideoEncodeAccelerator::UseOutputBitstreamBufferTask,
	base::Unretained(this), base::Passed(&buffer_ref)));
	}

	void VTVideoEncodeAccelerator::RequestEncodingParametersChange(
	uint32_t bitrate,
	uint32_t framerate) {
	DVLOG(3) << __FUNCTION__ << ": bitrate=" << bitrate
	<< ": framerate=" << framerate;
	DCHECK(thread_checker_.CalledOnValidThread());

	encoder_thread_task_runner_->PostTask(
	FROM_HERE,
	base::Bind(&VTVideoEncodeAccelerator::RequestEncodingParametersChangeTask,
	base::Unretained(this), bitrate, framerate));
	}

	void VTVideoEncodeAccelerator::Destroy() {
	DVLOG(3) << __FUNCTION__;
	DCHECK(thread_checker_.CalledOnValidThread());

	// Cancel all callbacks.
	client_ptr_factory_.reset();

	if (encoder_thread_.IsRunning()) {
	encoder_thread_task_runner_->PostTask(
	FROM_HERE,
	base::Bind(&VTVideoEncodeAccelerator::DestroyTask,
	base::Unretained(this)));
	encoder_thread_.Stop();
	} else {
	DestroyTask();
	}
	}

	void VTVideoEncodeAccelerator::EncodeTask(
	const scoped_refptr<media::VideoFrame>& frame,
	bool force_keyframe) {
	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 =
	media::WrapVideoFrameInCVPixelBuffer(*frame);
	base::ScopedCFTypeRef<CFDictionaryRef> frame_props =
	media::video_toolbox::DictionaryWithKeyValue(
	videotoolbox_glue_->kVTEncodeFrameOptionKey_ForceKeyFrame(),
	force_keyframe ? kCFBooleanTrue : kCFBooleanFalse);

	base::TimeTicks ref_time;
	if (!frame->metadata()->GetTimeTicks(
	media::VideoFrameMetadata::REFERENCE_TIME, &ref_time)) {
	ref_time = base::TimeTicks::Now();
	}
	auto timestamp_cm = CoreMediaGlue::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.
	scoped_ptr<InProgressFrameEncode> request(new InProgressFrameEncode(
	frame->timestamp(), ref_time));

	// 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);
	if (status != noErr) {
	DLOG(ERROR) << " VTCompressionSessionEncodeFrame failed: " << status;
	NotifyError(kPlatformFailureError);
	} else {
	CHECK(request.release());
	}
	}

	void VTVideoEncodeAccelerator::UseOutputBitstreamBufferTask(
	scoped_ptr<BitstreamBufferRef> buffer_ref) {
	DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());

	// If there is already EncodeOutput waiting, copy its output first.
	if (!encoder_output_queue_.empty()) {
	scoped_ptr<VTVideoEncodeAccelerator::EncodeOutput> encode_output =
	std::move(encoder_output_queue_.front());
	encoder_output_queue_.pop_front();
	ReturnBitstreamBuffer(std::move(encode_output), std::move(buffer_ref));
	return;
	}

	bitstream_buffer_queue_.push_back(std::move(buffer_ref));
	}

	void VTVideoEncodeAccelerator::RequestEncodingParametersChangeTask(
	uint32_t bitrate,
	uint32_t framerate) {
	DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());

	frame_rate_ = framerate > 1 ? framerate : 1;
	target_bitrate_ = bitrate > 1 ? bitrate : 1;

	if (!compression_session_) {
	NotifyError(kPlatformFailureError);
	return;
	}

	media::video_toolbox::SessionPropertySetter session_property_setter(
	compression_session_, videotoolbox_glue_);
	// TODO(emircan): See crbug.com/425352.
	bool rv = session_property_setter.Set(
	videotoolbox_glue_->kVTCompressionPropertyKey_AverageBitRate(),
	target_bitrate_);
	rv &= session_property_setter.Set(
	videotoolbox_glue_->kVTCompressionPropertyKey_ExpectedFrameRate(),
	frame_rate_);
	rv &= session_property_setter.Set(
	videotoolbox_glue_->kVTCompressionPropertyKey_DataRateLimits(),
	media::video_toolbox::ArrayWithIntegerAndFloat(
	target_bitrate_ / kBitsPerByte, 1.0f));
	DLOG_IF(ERROR, !rv) << "Couldn't change session encoding parameters.";
	}

	void VTVideoEncodeAccelerator::DestroyTask() {
	DCHECK(thread_checker_.CalledOnValidThread() \|\|
	(encoder_thread_.IsRunning() &&
	encoder_thread_task_runner_->BelongsToCurrentThread()));

	// Cancel all encoder thread callbacks.
	encoder_task_weak_factory_.InvalidateWeakPtrs();

	// This call blocks until all pending frames are flushed out.
	DestroyCompressionSession();
	}

	void VTVideoEncodeAccelerator::NotifyError(
	media::VideoEncodeAccelerator::Error error) {
	DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
	client_task_runner_->PostTask(
	FROM_HERE, base::Bind(&Client::NotifyError, client_, error));
	}

	// static
	void VTVideoEncodeAccelerator::CompressionCallback(void* encoder_opaque,
	void* request_opaque,
	OSStatus status,
	VTEncodeInfoFlags info,
	CMSampleBufferRef sbuf) {
	// This function may be called asynchronously, on a different thread from the
	// one that calls VTCompressionSessionEncodeFrame.
	DVLOG(3) << __FUNCTION__;

	auto encoder = reinterpret_cast<VTVideoEncodeAccelerator*>(encoder_opaque);
	DCHECK(encoder);

	// Release InProgressFrameEncode, since we don't have support to return
	// timestamps at this point.
	scoped_ptr<InProgressFrameEncode> request(
	reinterpret_cast<InProgressFrameEncode*>(request_opaque));
	request.reset();

	// EncodeOutput holds onto CMSampleBufferRef when posting task between
	// threads.
	scoped_ptr<EncodeOutput> encode_output(new EncodeOutput(info, sbuf));

	// This method is NOT called on \|encoder_thread_\|, so we still need to
	// post a task back to it to do work.
	encoder->encoder_thread_task_runner_->PostTask(
	FROM_HERE, base::Bind(&VTVideoEncodeAccelerator::CompressionCallbackTask,
	encoder->encoder_weak_ptr_, status,
	base::Passed(&encode_output)));
	}

	void VTVideoEncodeAccelerator::CompressionCallbackTask(
	OSStatus status,
	scoped_ptr<EncodeOutput> encode_output) {
	DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());

	if (status != noErr) {
	DLOG(ERROR) << " encode failed: " << status;
	NotifyError(kPlatformFailureError);
	return;
	}

	// If there isn't any BitstreamBuffer to copy into, add it to a queue for
	// later use.
	if (bitstream_buffer_queue_.empty()) {
	encoder_output_queue_.push_back(std::move(encode_output));
	return;
	}

	scoped_ptr<VTVideoEncodeAccelerator::BitstreamBufferRef> buffer_ref =
	std::move(bitstream_buffer_queue_.front());
	bitstream_buffer_queue_.pop_front();
	ReturnBitstreamBuffer(std::move(encode_output), std::move(buffer_ref));
	}

	void VTVideoEncodeAccelerator::ReturnBitstreamBuffer(
	scoped_ptr<EncodeOutput> encode_output,
	scoped_ptr<VTVideoEncodeAccelerator::BitstreamBufferRef> buffer_ref) {
	DVLOG(3) << __FUNCTION__;
	DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());

	if (encode_output->info & VideoToolboxGlue::kVTEncodeInfo_FrameDropped) {
	DVLOG(2) << " frame dropped";
	client_task_runner_->PostTask(
	FROM_HERE, base::Bind(&Client::BitstreamBufferReady, client_,
	buffer_ref->id, 0, false));
	return;
	}

	auto sample_attachments = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(
	CoreMediaGlue::CMSampleBufferGetSampleAttachmentsArray(
	encode_output->sample_buffer.get(), true),
	0));
	const bool keyframe =
	!CFDictionaryContainsKey(sample_attachments,
	CoreMediaGlue::kCMSampleAttachmentKey_NotSync());

	size_t used_buffer_size = 0;
	const bool copy_rv = media::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;
	}

	client_task_runner_->PostTask(
	FROM_HERE, base::Bind(&Client::BitstreamBufferReady, client_,
	buffer_ref->id, used_buffer_size, keyframe));
	}

	bool VTVideoEncodeAccelerator::ResetCompressionSession() {
	DCHECK(thread_checker_.CalledOnValidThread());

	DestroyCompressionSession();

	CFTypeRef attributes_keys[] = {
	kCVPixelBufferOpenGLCompatibilityKey,
	kCVPixelBufferIOSurfacePropertiesKey,
	kCVPixelBufferPixelFormatTypeKey
	};
	const int format[] = {
	CoreVideoGlue::kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange};
	CFTypeRef attributes_values[] = {
	kCFBooleanTrue,
	media::video_toolbox::DictionaryWithKeysAndValues(nullptr, nullptr, 0)
	.release(),
	media::video_toolbox::ArrayWithIntegers(format, arraysize(format))
	.release()};
	const base::ScopedCFTypeRef<CFDictionaryRef> attributes =
	media::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(target_bitrate_, frame_rate_);
	return configure_rv;
	}

	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());
	encoder_values.push_back(kCFBooleanTrue);
	} else {
	encoder_keys.push_back(videotoolbox_glue_
	->kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder());
	encoder_values.push_back(kCFBooleanTrue);
	}
	base::ScopedCFTypeRef<CFDictionaryRef> encoder_spec =
	media::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(
	kCFAllocatorDefault,
	input_size.width(),
	input_size.height(),
	CoreMediaGlue::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_);

	media::video_toolbox::SessionPropertySetter session_property_setter(
	compression_session_, videotoolbox_glue_);
	bool rv = 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);
	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_);
	compression_session_.reset();
	}
	}

	} // namespace content