Extend media glue code to support the VideoToolbox cast video encoder.

media/base/mac/coremedia_glue.mm

 // Copyright 2013 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/base/mac/coremedia_glue.h"
 
 #include <dlfcn.h>
 #import <Foundation/Foundation.h>
 
 #include "base/logging.h"
 #include "base/lazy_instance.h"
 
 namespace {
 
 // This class is used to retrieve some CoreMedia library functions. It must be
 // used as a LazyInstance so that it is initialised once and in a thread-safe
 // way. Normally no work is done in constructors: LazyInstance is an exception.
 class CoreMediaLibraryInternal {
  public:
   typedef CoreMediaGlue::CMTime (*CMTimeMakeMethod)(int64_t, int32_t);
+
+  typedef OSStatus (*CMBlockBufferCreateContiguousMethod)(
+      CFAllocatorRef,
+      CoreMediaGlue::CMBlockBufferRef,
+      CFAllocatorRef,
+      const CoreMediaGlue::CMBlockBufferCustomBlockSource*,
+      size_t,
+      size_t,
+      CoreMediaGlue::CMBlockBufferFlags,
+      CoreMediaGlue::CMBlockBufferRef*);
+  typedef size_t (*CMBlockBufferGetDataLengthMethod)(
+      CoreMediaGlue::CMBlockBufferRef);
+  typedef OSStatus (*CMBlockBufferGetDataPointerMethod)(
+      CoreMediaGlue::CMBlockBufferRef,
+      size_t,
+      size_t*,
+      size_t*,
+      char**);
+  typedef Boolean (*CMBlockBufferIsRangeContiguousMethod)(
+      CoreMediaGlue::CMBlockBufferRef,
+      size_t,
+      size_t);
+
+  typedef CoreMediaGlue::CMBlockBufferRef (*CMSampleBufferGetDataBufferMethod)(
+      CoreMediaGlue::CMSampleBufferRef);
+  typedef CoreMediaGlue::CMFormatDescriptionRef (
+      *CMSampleBufferGetFormatDescriptionMethod)(
+      CoreMediaGlue::CMSampleBufferRef);
   typedef CVImageBufferRef (*CMSampleBufferGetImageBufferMethod)(
       CoreMediaGlue::CMSampleBufferRef);
+  typedef CFArrayRef (*CMSampleBufferGetSampleAttachmentsArrayMethod)(
+      CoreMediaGlue::CMSampleBufferRef,
+      Boolean);
+
   typedef FourCharCode (*CMFormatDescriptionGetMediaSubTypeMethod)(
       CoreMediaGlue::CMFormatDescriptionRef desc);
   typedef CoreMediaGlue::CMVideoDimensions
       (*CMVideoFormatDescriptionGetDimensionsMethod)(
           CoreMediaGlue::CMVideoFormatDescriptionRef videoDesc);
+  typedef OSStatus (*CMVideoFormatDescriptionGetH264ParameterSetAtIndexMethod)(
+      CoreMediaGlue::CMFormatDescriptionRef,
+      size_t,
+      const uint8_t**,
+      size_t*,
+      size_t*,
+      int*);
 
   CoreMediaLibraryInternal() {
     NSBundle* bundle = [NSBundle
         bundleWithPath:@"/System/Library/Frameworks/CoreMedia.framework"];
 
     const char* path = [[bundle executablePath] fileSystemRepresentation];
     CHECK(path);
     void* library_handle = dlopen(path, RTLD_LAZY | RTLD_LOCAL);
     CHECK(library_handle) << dlerror();
 
     // Now extract the methods.
     cm_time_make_ = reinterpret_cast<CMTimeMakeMethod>(
         dlsym(library_handle, "CMTimeMake"));
     CHECK(cm_time_make_) << dlerror();
 
+    cm_block_buffer_create_contiguous_method_ =
+        reinterpret_cast<CMBlockBufferCreateContiguousMethod>(
+            dlsym(library_handle, "CMBlockBufferCreateContiguous"));
+    CHECK(cm_block_buffer_create_contiguous_method_) << dlerror();
+    cm_block_buffer_get_data_length_method_ =
+        reinterpret_cast<CMBlockBufferGetDataLengthMethod>(
+            dlsym(library_handle, "CMBlockBufferGetDataLength"));
+    CHECK(cm_block_buffer_get_data_length_method_) << dlerror();
+    cm_block_buffer_get_data_pointer_method_ =
+        reinterpret_cast<CMBlockBufferGetDataPointerMethod>(
+            dlsym(library_handle, "CMBlockBufferGetDataPointer"));
+    CHECK(cm_block_buffer_get_data_pointer_method_) << dlerror();
+    cm_block_buffer_is_range_contiguous_method_ =
+        reinterpret_cast<CMBlockBufferIsRangeContiguousMethod>(
+            dlsym(library_handle, "CMBlockBufferIsRangeContiguous"));
+    CHECK(cm_block_buffer_is_range_contiguous_method_) << dlerror();
+
+    cm_sample_buffer_get_data_buffer_method_ =
+        reinterpret_cast<CMSampleBufferGetDataBufferMethod>(
+            dlsym(library_handle, "CMSampleBufferGetDataBuffer"));
+    CHECK(cm_sample_buffer_get_data_buffer_method_) << dlerror();
+    cm_sample_buffer_get_format_description_method_ =
+        reinterpret_cast<CMSampleBufferGetFormatDescriptionMethod>(
+            dlsym(library_handle, "CMSampleBufferGetFormatDescription"));
+    CHECK(cm_sample_buffer_get_format_description_method_) << dlerror();
     cm_sample_buffer_get_image_buffer_method_ =
         reinterpret_cast<CMSampleBufferGetImageBufferMethod>(
             dlsym(library_handle, "CMSampleBufferGetImageBuffer"));
     CHECK(cm_sample_buffer_get_image_buffer_method_) << dlerror();
+    cm_sample_buffer_get_sample_attachments_array_method_ =
+        reinterpret_cast<CMSampleBufferGetSampleAttachmentsArrayMethod>(
+            dlsym(library_handle, "CMSampleBufferGetSampleAttachmentsArray"));
+    CHECK(cm_sample_buffer_get_sample_attachments_array_method_) << dlerror();
+    k_cm_sample_attachment_key_not_sync_ = reinterpret_cast<CFStringRef*>(
+        dlsym(library_handle, "kCMSampleAttachmentKey_NotSync"));
+    CHECK(k_cm_sample_attachment_key_not_sync_) << dlerror();
 
     cm_format_description_get_media_sub_type_method_ =
         reinterpret_cast<CMFormatDescriptionGetMediaSubTypeMethod>(
             dlsym(library_handle, "CMFormatDescriptionGetMediaSubType"));
     CHECK(cm_format_description_get_media_sub_type_method_) << dlerror();
-
     cm_video_format_description_get_dimensions_method_ =
         reinterpret_cast<CMVideoFormatDescriptionGetDimensionsMethod>(
             dlsym(library_handle, "CMVideoFormatDescriptionGetDimensions"));
     CHECK(cm_video_format_description_get_dimensions_method_) << dlerror();
+
+    // Available starting (OS X 10.9, iOS 7), allow to be null.
+    cm_video_format_description_get_h264_parameter_set_at_index_method_ =
+        reinterpret_cast<
+            CMVideoFormatDescriptionGetH264ParameterSetAtIndexMethod>(
+            dlsym(library_handle,
+                  "CMVideoFormatDescriptionGetH264ParameterSetAtIndex"));
   }
 
   const CMTimeMakeMethod& cm_time_make() const { return cm_time_make_; }
+
+  const CMBlockBufferCreateContiguousMethod&
+  cm_block_buffer_create_contiguous_method() const {
+    return cm_block_buffer_create_contiguous_method_;
+  }
+  const CMBlockBufferGetDataLengthMethod&
+  cm_block_buffer_get_data_length_method() const {
+    return cm_block_buffer_get_data_length_method_;
+  }
+  const CMBlockBufferGetDataPointerMethod&
+  cm_block_buffer_get_data_pointer_method() const {
+    return cm_block_buffer_get_data_pointer_method_;
+  }
+  const CMBlockBufferIsRangeContiguousMethod&
+  cm_block_buffer_is_range_contiguous_method() const {
+    return cm_block_buffer_is_range_contiguous_method_;
+  }
+
+  const CMSampleBufferGetDataBufferMethod&
+  cm_sample_buffer_get_data_buffer_method() const {
+    return cm_sample_buffer_get_data_buffer_method_;
+  }
+  const CMSampleBufferGetFormatDescriptionMethod&
+  cm_sample_buffer_get_format_description_method() const {
+    return cm_sample_buffer_get_format_description_method_;
+  }
   const CMSampleBufferGetImageBufferMethod&
       cm_sample_buffer_get_image_buffer_method() const {
     return cm_sample_buffer_get_image_buffer_method_;
   }
+  const CMSampleBufferGetSampleAttachmentsArrayMethod&
+  cm_sample_buffer_get_sample_attachments_array_method() const {
+    return cm_sample_buffer_get_sample_attachments_array_method_;
+  }
+  CFStringRef* const& k_cm_sample_attachment_key_not_sync() const {
+    return k_cm_sample_attachment_key_not_sync_;
+  }
+
   const CMFormatDescriptionGetMediaSubTypeMethod&
       cm_format_description_get_media_sub_type_method() const {
     return cm_format_description_get_media_sub_type_method_;
   }
   const CMVideoFormatDescriptionGetDimensionsMethod&
       cm_video_format_description_get_dimensions_method() const {
     return cm_video_format_description_get_dimensions_method_;
   }
+  const CMVideoFormatDescriptionGetH264ParameterSetAtIndexMethod&
+  cm_video_format_description_get_h264_parameter_set_at_index_method() const {
+    return cm_video_format_description_get_h264_parameter_set_at_index_method_;
+  }
 
  private:
   CMTimeMakeMethod cm_time_make_;
+
+  CMBlockBufferCreateContiguousMethod cm_block_buffer_create_contiguous_method_;
+  CMBlockBufferGetDataLengthMethod cm_block_buffer_get_data_length_method_;
+  CMBlockBufferGetDataPointerMethod cm_block_buffer_get_data_pointer_method_;
+  CMBlockBufferIsRangeContiguousMethod
+      cm_block_buffer_is_range_contiguous_method_;
+
+  CMSampleBufferGetDataBufferMethod cm_sample_buffer_get_data_buffer_method_;
+  CMSampleBufferGetFormatDescriptionMethod
+      cm_sample_buffer_get_format_description_method_;
   CMSampleBufferGetImageBufferMethod cm_sample_buffer_get_image_buffer_method_;
+  CMSampleBufferGetSampleAttachmentsArrayMethod
+      cm_sample_buffer_get_sample_attachments_array_method_;
+  CFStringRef* k_cm_sample_attachment_key_not_sync_;
+
   CMFormatDescriptionGetMediaSubTypeMethod
       cm_format_description_get_media_sub_type_method_;
   CMVideoFormatDescriptionGetDimensionsMethod
       cm_video_format_description_get_dimensions_method_;
+  CMVideoFormatDescriptionGetH264ParameterSetAtIndexMethod
+      cm_video_format_description_get_h264_parameter_set_at_index_method_;
 
   DISALLOW_COPY_AND_ASSIGN(CoreMediaLibraryInternal);
 };
 
 }  // namespace
 
 static base::LazyInstance<CoreMediaLibraryInternal> g_coremedia_handle =
     LAZY_INSTANCE_INITIALIZER;
 
 // static
 CoreMediaGlue::CMTime CoreMediaGlue::CMTimeMake(int64_t value,
                                                 int32_t timescale) {
   return g_coremedia_handle.Get().cm_time_make()(value, timescale);
 }
 
 // static
+OSStatus CoreMediaGlue::CMBlockBufferCreateContiguous(
+    CFAllocatorRef structureAllocator,
+    CMBlockBufferRef sourceBuffer,
+    CFAllocatorRef blockAllocator,
+    const CMBlockBufferCustomBlockSource* customBlockSource,
+    size_t offsetToData,
+    size_t dataLength,
+    CMBlockBufferFlags flags,
+    CMBlockBufferRef* newBBufOut) {
+  return g_coremedia_handle.Get().cm_block_buffer_create_contiguous_method()(
+      structureAllocator,
+      sourceBuffer,
+      blockAllocator,
+      customBlockSource,
+      offsetToData,
+      dataLength,
+      flags,
+      newBBufOut);
+}
+
+// static
+size_t CoreMediaGlue::CMBlockBufferGetDataLength(CMBlockBufferRef theBuffer) {
+  return g_coremedia_handle.Get().cm_block_buffer_get_data_length_method()(
+      theBuffer);
+}
+
+// static
+OSStatus CoreMediaGlue::CMBlockBufferGetDataPointer(CMBlockBufferRef theBuffer,
+                                                    size_t offset,
+                                                    size_t* lengthAtOffset,
+                                                    size_t* totalLength,
+                                                    char** dataPointer) {
+  return g_coremedia_handle.Get().cm_block_buffer_get_data_pointer_method()(
+      theBuffer, offset, lengthAtOffset, totalLength, dataPointer);
+}
+
+// static
+Boolean CoreMediaGlue::CMBlockBufferIsRangeContiguous(
+    CMBlockBufferRef theBuffer,
+    size_t offset,
+    size_t length) {
+  return g_coremedia_handle.Get().cm_block_buffer_is_range_contiguous_method()(
+      theBuffer, offset, length);
+}
+
+// static
+CoreMediaGlue::CMBlockBufferRef CoreMediaGlue::CMSampleBufferGetDataBuffer(
+    CMSampleBufferRef sbuf) {
+  return g_coremedia_handle.Get().cm_sample_buffer_get_data_buffer_method()(
+      sbuf);
+}
+
+// static
+CoreMediaGlue::CMFormatDescriptionRef
+CoreMediaGlue::CMSampleBufferGetFormatDescription(
+    CoreMediaGlue::CMSampleBufferRef sbuf) {
+  return g_coremedia_handle.Get()
+      .cm_sample_buffer_get_format_description_method()(sbuf);
+}
+
+// static
 CVImageBufferRef CoreMediaGlue::CMSampleBufferGetImageBuffer(
     CMSampleBufferRef buffer) {
   return g_coremedia_handle.Get().cm_sample_buffer_get_image_buffer_method()(
       buffer);
 }
 
 // static
+CFArrayRef CoreMediaGlue::CMSampleBufferGetSampleAttachmentsArray(
+    CMSampleBufferRef sbuf,
+    Boolean createIfNecessary) {
+  return g_coremedia_handle.Get()
+      .cm_sample_buffer_get_sample_attachments_array_method()(
+          sbuf, createIfNecessary);
+}
+
+// static
+CFStringRef CoreMediaGlue::kCMSampleAttachmentKey_NotSync() {
+  return *g_coremedia_handle.Get().k_cm_sample_attachment_key_not_sync();
+}
+
+// static
 FourCharCode CoreMediaGlue::CMFormatDescriptionGetMediaSubType(
       CMFormatDescriptionRef desc) {
   return g_coremedia_handle.Get()
       .cm_format_description_get_media_sub_type_method()(desc);
 }
 
 // static
 CoreMediaGlue::CMVideoDimensions
     CoreMediaGlue::CMVideoFormatDescriptionGetDimensions(
         CMVideoFormatDescriptionRef videoDesc) {
   return g_coremedia_handle.Get()
       .cm_video_format_description_get_dimensions_method()(videoDesc);
 }
+
+// static
+OSStatus CoreMediaGlue::CMVideoFormatDescriptionGetH264ParameterSetAtIndex(
+    CMFormatDescriptionRef videoDesc,
+    size_t parameterSetIndex,
+    const uint8_t** parameterSetPointerOut,
+    size_t* parameterSetSizeOut,
+    size_t* parameterSetCountOut,
+    int* NALUnitHeaderLengthOut) {
+  return g_coremedia_handle.Get()
+      .cm_video_format_description_get_h264_parameter_set_at_index_method()(
+          videoDesc,
+          parameterSetIndex,
+          parameterSetPointerOut,
+          parameterSetSizeOut,
+          parameterSetCountOut,
+          NALUnitHeaderLengthOut);
+}