Package apple.coremedia.c

Class CoreMedia

  • public final class CoreMedia
extends java.lang.Object

    • Method Detail

      • CMTimeMake

        public static CMTime CMTimeMake​(long value,
                                int timescale)
        [@function] CMTimeMake Make a valid CMTime with value and timescale. Epoch is implied to be 0.
        Returns:
        The resulting CMTime.

      • CMTimeMakeWithEpoch

        public static CMTime CMTimeMakeWithEpoch​(long value,
                                         int timescale,
                                         long epoch)
        [@function] CMTimeMakeWithEpoch Make a valid CMTime with value, scale and epoch.
        Returns:
        The resulting CMTime.

      • CMTimeMakeWithSeconds

        public static CMTime CMTimeMakeWithSeconds​(double seconds,
                                           int preferredTimescale)
        [@function] CMTimeMakeWithSeconds Make a CMTime from a Float64 number of seconds, and a preferred timescale. The epoch of the result will be zero. If preferredTimescale is <= 0, the result will be an invalid CMTime. If the preferred timescale will cause an overflow, the timescale will be halved repeatedly until the overflow goes away, or the timescale is 1. If it still overflows at that point, the result will be +/- infinity. The kCMTimeFlags_HasBeenRounded flag will be set if the result, when converted back to seconds, is not exactly equal to the original seconds value.
        Returns:
        The resulting CMTime.

      • CMTimeGetSeconds

        public static double CMTimeGetSeconds​(CMTime time)
        [@function] CMTimeGetSeconds Converts a CMTime to seconds. If the CMTime is invalid or indefinite, NAN is returned. If the CMTime is infinite, +/- __inf() is returned. If the CMTime is numeric, epoch is ignored, and time.value / time.timescale is returned. The division is done in Float64, so the fraction is not lost in the returned result.
        Returns:
        The resulting Float64 number of seconds.

      • CMTimeConvertScale

        public static CMTime CMTimeConvertScale​(CMTime time,
                                        int newTimescale,
                                        int method)
        [@function] CMTimeConvertScale Returns a new CMTime containing the source CMTime converted to a new timescale (rounding as requested). If the value needs to be rounded, the kCMTimeFlags_HasBeenRounded flag will be set. See definition of CMTimeRoundingMethod for a discussion of the various rounding methods available. If the source time is non-numeric (ie. infinite, indefinite, invalid), the result will be similarly non-numeric.
        Returns:
        The converted result CMTime.

      • CMTimeAdd

        public static CMTime CMTimeAdd​(CMTime lhs,
                               CMTime rhs)
        [@function] CMTimeAdd Returns the sum of two CMTimes. If the operands both have the same timescale, the timescale of the result will be the same as the operands' timescale. If the operands have different timescales, the timescale of the result will be the least common multiple of the operands' timescales. If that LCM timescale is greater than kCMTimeMaxTimescale, the result timescale will be kCMTimeMaxTimescale, and default rounding will be applied when converting the result to this timescale. If the result value overflows, the result timescale will be repeatedly halved until the result value no longer overflows. Again, default rounding will be applied when converting the result to this timescale. If the result value still overflows when timescale == 1, then the result will be either positive or negative infinity, depending on the direction of the overflow. If any rounding occurs for any reason, the result's kCMTimeFlags_HasBeenRounded flag will be set. This flag will also be set if either of the operands has kCMTimeFlags_HasBeenRounded set. If either of the operands is invalid, the result will be invalid. If the operands are valid, but just one operand is infinite, the result will be similarly infinite. If the operands are valid, and both are infinite, the results will be as follows:
          +infinity + +infinity == +infinity
        • -infinity + -infinity == -infinity
        • +infinity + -infinity == invalid
        • -infinity + +infinity == invalid
        If the operands are valid, not infinite, and either or both is indefinite, the result will be indefinite. If the two operands are numeric (ie. valid, not infinite, not indefinite), but have different nonzero epochs, the result will be invalid. If they have the same nonzero epoch, the result will have epoch zero (a duration). Times in different epochs cannot be added or subtracted, because epoch length is unknown. Times in epoch zero are considered to be durations and can be added to times in other epochs. Times in different epochs can be compared, however, because numerically greater epochs always occur after numerically lesser epochs.
        Returns:
        The sum of the two CMTimes (lhs + rhs).

      • CMTimeSubtract

        public static CMTime CMTimeSubtract​(CMTime lhs,
                                    CMTime rhs)
        [@function] CMTimeSubtract Returns the difference of two CMTimes. If the operands both have the same timescale, the timescale of the result will be the same as the operands' timescale. If the operands have different timescales, the timescale of the result will be the least common multiple of the operands' timescales. If that LCM timescale is greater than kCMTimeMaxTimescale, the result timescale will be kCMTimeMaxTimescale, and default rounding will be applied when converting the result to this timescale. If the result value overflows, the result timescale will be repeatedly halved until the result value no longer overflows. Again, default rounding will be applied when converting the result to this timescale. If the result value still overflows when timescale == 1, then the result will be either positive or negative infinity, depending on the direction of the overflow. If any rounding occurs for any reason, the result's kCMTimeFlags_HasBeenRounded flag will be set. This flag will also be set if either of the operands has kCMTimeFlags_HasBeenRounded set. If either of the operands is invalid, the result will be invalid. If the operands are valid, but just one operand is infinite, the result will be similarly infinite. If the operands are valid, and both are infinite, the results will be as follows:
          +infinity - +infinity == invalid
        • -infinity - -infinity == invalid
        • +infinity - -infinity == +infinity
        • -infinity - +infinity == -infinity
        If the operands are valid, not infinite, and either or both is indefinite, the result will be indefinite. If the two operands are numeric (ie. valid, not infinite, not indefinite), but have different nonzero epochs, the result will be invalid. If they have the same nonzero epoch, the result will have epoch zero (a duration). Times in different epochs cannot be added or subtracted, because epoch length is unknown. Times in epoch zero are considered to be durations and can be subtracted from times in other epochs. Times in different epochs can be compared, however, because numerically greater epochs always occur after numerically lesser epochs.
        Returns:
        The difference of the two CMTimes (lhs - rhs).

      • CMTimeMultiply

        public static CMTime CMTimeMultiply​(CMTime time,
                                    int multiplier)
        [@function] CMTimeMultiply Returns the product of a CMTime and a 32-bit integer. The result will have the same timescale as the CMTime operand. If the result value overflows, the result timescale will be repeatedly halved until the result value no longer overflows. Again, default rounding will be applied when converting the result to this timescale. If the result value still overflows when timescale == 1, then the result will be either positive or negative infinity, depending on the direction of the overflow. If any rounding occurs for any reason, the result's kCMTimeFlags_HasBeenRounded flag will be set. This flag will also be set if the CMTime operand has kCMTimeFlags_HasBeenRounded set. If the CMTime operand is invalid, the result will be invalid. If the CMTime operand is valid, but infinite, the result will be infinite, and of an appropriate sign, given the signs of both operands. If the CMTime operand is valid, but indefinite, the result will be indefinite.
        Returns:
        The product of the CMTime and the 32-bit integer.

      • CMTimeMultiplyByFloat64

        public static CMTime CMTimeMultiplyByFloat64​(CMTime time,
                                             double multiplier)
        [@function] CMTimeMultiplyByFloat64 Returns the product of a CMTime and a 64-bit float. The result will initially have the same timescale as the CMTime operand. If the result timescale is less than 65536, it will be repeatedly doubled until it is at least 65536. If the result value overflows, the result timescale will be repeatedly halved until the result value no longer overflows. Again, default rounding will be applied when converting the result to this timescale. If the result value still overflows when timescale == 1, then the result will be either positive or negative infinity, depending on the direction of the overflow. If any rounding occurs for any reason, the result's kCMTimeFlags_HasBeenRounded flag will be set. This flag will also be set if the CMTime operand has kCMTimeFlags_HasBeenRounded set. If the CMTime operand is invalid, the result will be invalid. If the CMTime operand is valid, but infinite, the result will be infinite, and of an appropriate sign, given the signs of both operands. If the CMTime operand is valid, but indefinite, the result will be indefinite.
        Returns:
        The product of the CMTime and the 64-bit float.

      • CMTimeMultiplyByRatio

        public static CMTime CMTimeMultiplyByRatio​(CMTime time,
                                           int multiplier,
                                           int divisor)
        [@function] CMTimeMultiplyByRatio Returns the result of multiplying a CMTime by an integer, then dividing by another integer. The exact rational value will be preserved, if possible without overflow. If an overflow would occur, a new timescale will be chosen so as to minimize the rounding error. Default rounding will be applied when converting the result to this timescale. If the result value still overflows when timescale == 1, then the result will be either positive or negative infinity, depending on the direction of the overflow. If any rounding occurs for any reason, the result's kCMTimeFlags_HasBeenRounded flag will be set. This flag will also be set if the CMTime operand has kCMTimeFlags_HasBeenRounded set. If the denominator, and either the time or the numerator, are zero, the result will be kCMTimeInvalid. If only the denominator is zero, the result will be either kCMTimePositiveInfinity or kCMTimeNegativeInfinity, depending on the signs of the other arguments. If time is invalid, the result will be invalid. If time is infinite, the result will be similarly infinite. If time is indefinite, the result will be indefinite.
        Returns:
        (time * multiplier) / divisor

      • CMTimeCompare

        public static int CMTimeCompare​(CMTime time1,
                                CMTime time2)
        [@function] CMTimeCompare Returns the numerical relationship (-1 = less than, 1 = greater than, 0 = equal) of two CMTimes. If the two CMTimes are numeric (ie. not invalid, infinite, or indefinite), and have different epochs, it is considered that times in numerically larger epochs are always greater than times in numerically smaller epochs. Since this routine will be used to sort lists by time, it needs to give all values (even invalid and indefinite ones) a strict ordering to guarantee that sort algorithms terminate safely. The order chosen is somewhat arbitrary: -infinity < all finite values < indefinite < +infinity < invalid Invalid CMTimes are considered to be equal to other invalid CMTimes, and greater than any other CMTime. Positive infinity is considered to be less than any invalid CMTime, equal to itself, and greater than any other CMTime. An indefinite CMTime is considered to be less than any invalid CMTime, less than positive infinity, equal to itself, and greater than any other CMTime. Negative infinity is considered to be equal to itself, and less than any other CMTime. -1 is returned if time1 is less than time2. 0 is returned if they are equal. 1 is returned if time1 is greater than time2.
        Returns:
        The numerical relationship of the two CMTimes (-1 = less than, 1 = greater than, 0 = equal).

      • CMTimeMinimum

        public static CMTime CMTimeMinimum​(CMTime time1,
                                   CMTime time2)
        [@function] CMTimeMinimum Returns the lesser of two CMTimes (as defined by CMTimeCompare).
        Returns:
        The lesser of the two CMTimes.

      • CMTimeMaximum

        public static CMTime CMTimeMaximum​(CMTime time1,
                                   CMTime time2)
        [@function] CMTimeMaximum Returns the greater of two CMTimes (as defined by CMTimeCompare).
        Returns:
        The greater of the two CMTimes.

      • CMTimeAbsoluteValue

        public static CMTime CMTimeAbsoluteValue​(CMTime time)
        [@function] CMTimeAbsoluteValue Returns the absolute value of a CMTime.
        Returns:
        Same as the argument time, with sign inverted if negative.

      • CMTimeCopyAsDictionary

        public static CFDictionaryRef CMTimeCopyAsDictionary​(CMTime time,
                                                     CFAllocatorRef allocator)
        [@function] CMTimeCopyAsDictionary Returns a CFDictionary version of a CMTime. This is useful when putting CMTimes in CF container types.
        Returns:
        A CFDictionary version of the CMTime.

      • CMTimeMakeFromDictionary

        public static CMTime CMTimeMakeFromDictionary​(CFDictionaryRef dictionaryRepresentation)
        [@function] CMTimeMakeFromDictionary Reconstitutes a CMTime struct from a CFDictionary previously created by CMTimeCopyAsDictionary. This is useful when getting CMTimes from CF container types. If the CFDictionary does not have the requisite keyed values, an invalid time is returned.
        Returns:
        The created CMTime.

      • CMTimeCopyDescription

        public static CFStringRef CMTimeCopyDescription​(CFAllocatorRef allocator,
                                                CMTime time)
        [@function] CMTimeCopyDescription Creates a CFString with a description of a CMTime (just like CFCopyDescription). This is used from within CFShow on an object that contains CMTime fields. It is also useful from other client debugging code. The caller owns the returned CFString, and is responsible for releasing it.
        Returns:
        The created CFString description.

      • CMTimeShow

        public static void CMTimeShow​(CMTime time)
        [@function] CMTimeShow Prints a description of the CMTime (just like CFShow). This is most useful from within gdb.

      • CMTimeRangeMake

        public static CMTimeRange CMTimeRangeMake​(CMTime start,
                                          CMTime duration)
        [@function] CMTimeRangeMake Make a valid CMTimeRange with start and duration. The duration parameter must have an epoch of 0; otherwise an invalid time range will be returned.
        Returns:
        The resulting CMTimeRange.

      • CMTimeRangeGetUnion

        public static CMTimeRange CMTimeRangeGetUnion​(CMTimeRange range,
                                              CMTimeRange otherRange)
        [@function] CMTimeRangeGetUnion Returns the union of two CMTimeRanges. This function returns a CMTimeRange structure that represents the union of the time ranges specified by the range and otherRange parameters. This is the smallest range that includes all times that are in either range.
        Returns:
        The union of the two CMTimeRanges.

      • CMTimeRangeGetIntersection

        public static CMTimeRange CMTimeRangeGetIntersection​(CMTimeRange range,
                                                     CMTimeRange otherRange)
        [@function] CMTimeRangeGetIntersection Returns the intersection of two CMTimeRanges. This function returns a CMTimeRange structure that represents the intersection of the time ranges specified by the range and otherRange parameters. This is the largest range that both ranges include.
        Returns:
        The intersection of the two CMTimeRanges.

      • CMTimeRangeEqual

        public static byte CMTimeRangeEqual​(CMTimeRange range1,
                                    CMTimeRange range2)
        [@function] CMTimeRangeEqual Returns a Boolean value that indicates whether two CMTimeRanges are identical. This function returns a Boolean value that indicates whether the time ranges specified by the range1 and range2 parameters are identical.
        Returns:
        Returns true if the two time ranges are identical, false if they differ.

      • CMTimeRangeContainsTime

        public static byte CMTimeRangeContainsTime​(CMTimeRange range,
                                           CMTime time)
        [@function] CMTimeRangeContainsTime Indicates whether a time is contained within a time range. This function returns a Boolean value that indicates whether the time specified by the time parameter is contained within the range specified by the range parameter.
        Returns:
        Returns true if the specified time is contained within the specified time range, false if it is not.

      • CMTimeRangeContainsTimeRange

        public static byte CMTimeRangeContainsTimeRange​(CMTimeRange range,
                                                CMTimeRange otherRange)
        [@function] CMTimeRangeContainsTimeRange Indicates whether a time range is contained within a time range. This function returns a Boolean value that indicates whether the time range specified by the range parameter contains the range specified by the otherRange parameter.
        Returns:
        Returns true if the second time range is contained within the first time range, false if it is not.

      • CMTimeRangeGetEnd

        public static CMTime CMTimeRangeGetEnd​(CMTimeRange range)
        [@function] CMTimeRangeGetEnd Returns a CMTime structure representing the end of a time range. This function returns a CMTime structure that indicates the end of the time range specified by the range parameter. CMTimeRangeContainsTime(range, CMTimeRangeGetEnd(range)) is always false.
        Returns:
        A CMTime structure representing the end of the specified time range.

      • CMTimeMapTimeFromRangeToRange

        public static CMTime CMTimeMapTimeFromRangeToRange​(CMTime t,
                                                   CMTimeRange fromRange,
                                                   CMTimeRange toRange)
        [@function] CMTimeMapTimeFromRangeToRange Translates a time through a mapping from CMTimeRange to CMTimeRange. The start and end time of fromRange will be mapped to the start and end time of toRange respectively. Other times will be mapped linearly, using the formula: result = (t-fromRange.start)*(toRange.duration/fromRange.duration)+toRange.start If either CMTimeRange argument is empty, an invalid CMTime will be returned. If t does not have the same epoch as fromRange.start, an invalid CMTime will be returned. If both fromRange and toRange have duration kCMTimePositiveInfinity, t will be offset relative to the differences between their starts, but not scaled.
        Returns:
        A CMTime structure representing the translated time.

      • CMTimeClampToRange

        public static CMTime CMTimeClampToRange​(CMTime time,
                                        CMTimeRange range)
        [@function] CMTimeClampToRange For a given CMTime and CMTimeRange, returns the nearest CMTime inside that time range. Times inside the given time range will be returned unmodified. Times before the start and after the end time of the time range will return the start and end time of the range respectively. If the CMTimeRange argument is empty, an invalid CMTime will be returned. If the given CMTime is invalid, the returned CMTime will be invalid,
        Returns:
        A CMTime structure inside the given time range.

      • CMTimeMapDurationFromRangeToRange

        public static CMTime CMTimeMapDurationFromRangeToRange​(CMTime dur,
                                                       CMTimeRange fromRange,
                                                       CMTimeRange toRange)
        [@function] CMTimeMapDurationFromRangeToRange Translates a duration through a mapping from CMTimeRange to CMTimeRange. The duration will be scaled in proportion to the ratio between the ranges' durations: result = dur*(toRange.duration/fromRange.duration) If dur does not have the epoch zero, an invalid CMTime will be returned.
        Returns:
        A CMTime structure representing the translated duration.

      • CMTimeRangeFromTimeToTime

        public static CMTimeRange CMTimeRangeFromTimeToTime​(CMTime start,
                                                    CMTime end)
        [@function] CMTimeRangeFromTimeToTime Make a valid CMTimeRange with the given starting and ending times.
        Returns:
        The resulting CMTimeRange.

      • CMTimeRangeCopyAsDictionary

        public static CFDictionaryRef CMTimeRangeCopyAsDictionary​(CMTimeRange range,
                                                          CFAllocatorRef allocator)
        [@function] CMTimeRangeCopyAsDictionary Returns a CFDictionary version of a CMTimeRange. This is useful when putting CMTimeRanges in CF container types.
        Returns:
        A CFDictionary version of the CMTimeRange.

      • CMTimeRangeMakeFromDictionary

        public static CMTimeRange CMTimeRangeMakeFromDictionary​(CFDictionaryRef dictionaryRepresentation)
        [@function] CMTimeRangeMakeFromDictionary Reconstitutes a CMTimeRange struct from a CFDictionary previously created by CMTimeRangeCopyAsDictionary. This is useful when getting CMTimeRanges from CF container types. If the CFDictionary does not have the requisite keyed values, an invalid time range is returned.
        Returns:
        The created CMTimeRange.

      • CMTimeRangeCopyDescription

        public static CFStringRef CMTimeRangeCopyDescription​(CFAllocatorRef allocator,
                                                     CMTimeRange range)
        [@function] CMTimeRangeCopyDescription Creates a CFString with a description of a CMTimeRange (just like CFCopyDescription). This is used from within CFShow on an object that contains CMTimeRange fields. It is also useful from other client debugging code. The caller owns the returned CFString and is responsible for releasing it.
        Returns:
        The created CFString description.

      • CMTimeRangeShow

        public static void CMTimeRangeShow​(CMTimeRange range)
        [@function] CMTimeRangeShow Prints a description of the CMTimeRange (just like CFShow). This is most useful from within gdb.

      • CMTimeMappingMake

        public static CMTimeMapping CMTimeMappingMake​(CMTimeRange source,
                                              CMTimeRange target)
        [@function] CMTimeMappingMake Make a valid CMTimeMapping with source and target. The source and target parameters must have durations whose epoch is 0; otherwise an invalid time mapping will be returned.
        Returns:
        The resulting CMTimeMapping.

      • CMTimeMappingMakeEmpty

        public static CMTimeMapping CMTimeMappingMakeEmpty​(CMTimeRange target)
        [@function] CMTimeMappingMakeEmpty Make a valid CMTimeMapping with an empty source. The target parameter must have a duration whose epoch is 0; otherwise an invalid time mapping will be returned.
        Returns:
        The resulting CMTimeMapping.

      • CMTimeMappingCopyAsDictionary

        public static CFDictionaryRef CMTimeMappingCopyAsDictionary​(CMTimeMapping mapping,
                                                            CFAllocatorRef allocator)
        [@function] CMTimeMappingCopyAsDictionary Returns a CFDictionary version of a CMTimeMapping. This is useful when putting CMTimeMappings in CF container types.
        Returns:
        A CFDictionary version of the CMTimeMapping.

      • CMTimeMappingMakeFromDictionary

        public static CMTimeMapping CMTimeMappingMakeFromDictionary​(CFDictionaryRef dictionaryRepresentation)
        [@function] CMTimeMappingMakeFromDictionary Reconstitutes a CMTimeMapping struct from a CFDictionary previously created by CMTimeMappingCopyAsDictionary. This is useful when getting CMTimeMappings from CF container types. If the CFDictionary does not have the requisite keyed values, an invalid time mapping is returned.
        Returns:
        The created CMTimeMapping.

      • CMTimeMappingCopyDescription

        public static CFStringRef CMTimeMappingCopyDescription​(CFAllocatorRef allocator,
                                                       CMTimeMapping mapping)
        [@function] CMTimeMappingCopyDescription Creates a CFString with a description of a CMTimeMapping (just like CFCopyDescription). This is used from within CFShow on an object that contains CMTimeMapping fields. It is also useful from other client debugging code. The caller owns the returned CFString and is responsible for releasing it.
        Returns:
        The created CFString description.

      • CMTimeMappingShow

        public static void CMTimeMappingShow​(CMTimeMapping mapping)
        [@function] CMTimeMappingShow Prints a description of a CMTimeMapping (just like CFShow). This is most useful from within gdb.

      • CMSetAttachment

        public static void CMSetAttachment​(org.moe.natj.general.ptr.ConstVoidPtr target,
                                   CFStringRef key,
                                   org.moe.natj.general.ptr.ConstVoidPtr value,
                                   int attachmentMode)
        [@function] CMSetAttachment Sets or adds a attachment of a CMAttachmentBearer You can attach any CF object to a CMAttachmentBearer object to store additional information. CMSetAttachment stores an attachment identified by a key. If the key doesn't exist, the attachment will be added. If the key does exist, the existing attachment will be replaced. In both cases the retain count of the attachment will be incremented. The value can be any CFType but nil has no defined behavior. Given a CVBufferRef, CMSetAttachment is equivalent to CVBufferSetAttachment.
        Parameters:
        target - Target CMAttachmentBearer.
        key - Key in form of a CFString identifying the desired attachment.
        value - Attachment in form af a CF object.
        attachmentMode - Specifies which attachment mode is desired for this attachment. A particular attachment key may only exist in a single mode at a time.

      • CMGetAttachment

        public static org.moe.natj.general.ptr.ConstVoidPtr CMGetAttachment​(org.moe.natj.general.ptr.ConstVoidPtr target,
                                                                    CFStringRef key,
                                                                    org.moe.natj.general.ptr.IntPtr attachmentModeOut)
        [@function] CMGetAttachment Returns a specific attachment of a CMAttachmentBearer You can attach any CF object to a CMAttachmentBearer to store additional information. CMGetAttachment retrieves an attachment identified by a key. Given a CVBufferRef, CMGetAttachment is equivalent to CVBufferGetAttachment.
        Parameters:
        target - Target CMAttachmentBearer.
        key - Key in form of a CFString identifying the desired attachment.
        attachmentModeOut - Returns the mode of the attachment, if desired. May be NULL.
        Returns:
        If found the attachment object; else NULL.

      • CMRemoveAttachment

        public static void CMRemoveAttachment​(org.moe.natj.general.ptr.ConstVoidPtr target,
                                      CFStringRef key)
        [@function] CMRemoveAttachment Removes a specific attachment of a CMAttachmentBearer CMRemoveAttachment removes an attachment identified by a key. If found the attachment is removed and the retain count decremented. Given a CVBufferRef, CMRemoveAttachment is equivalent to CVBufferRemoveAttachment.
        Parameters:
        target - Target CMAttachmentBearer.
        key - Key in form of a CFString identifying the desired attachment.

      • CMRemoveAllAttachments

        public static void CMRemoveAllAttachments​(org.moe.natj.general.ptr.ConstVoidPtr target)
        [@function] CMRemoveAllAttachments Removes all attachments of a CMAttachmentBearer While CMRemoveAttachment removes a specific attachment identified by a key CMRemoveAllAttachments removes all attachments of a buffer and decrements their retain counts. Given a CVBufferRef, CMRemoveAllAttachments is equivalent to CVBufferRemoveAllAttachments.
        Parameters:
        target - Target CMAttachmentBearer.

      • CMCopyDictionaryOfAttachments

        public static CFDictionaryRef CMCopyDictionaryOfAttachments​(CFAllocatorRef allocator,
                                                            org.moe.natj.general.ptr.ConstVoidPtr target,
                                                            int attachmentMode)
        [@function] CMCopyDictionaryOfAttachments Returns all attachments of a CMAttachmentBearer CMCopyDictionaryOfAttachments is a convenience call that returns all attachments with their corresponding keys in a new CFDictionary that the caller must dispose by calling CFRelease. Given a CVBufferRef, CMCopyDictionaryOfAttachments is similar to CVBufferGetAttachments, except that CVBufferGetAttachments returns a CFDictionary that may change if attachments are added later.
        Parameters:
        allocator - Allocator for the new dictionary; pass kCFAllocatorDefault or NULL to use the default allocator.
        target - Target CMAttachmentBearer.
        Returns:
        A CFDictionary with all buffer attachments identified by there keys. If no attachment is present, NULL is returned. Returns NULL for invalid attachment mode.

      • CMSetAttachments

        public static void CMSetAttachments​(org.moe.natj.general.ptr.ConstVoidPtr target,
                                    CFDictionaryRef theAttachments,
                                    int attachmentMode)
        [@function] CMSetAttachments Sets a set of attachments for a CMAttachmentBearer CMSetAttachments is a convenience call that in turn calls CMSetAttachment for each key and value in the given dictionary. All key value pairs must be in the root level of the dictionary. Given a CVBufferRef, CMSetAttachments is equivalent to CVBufferSetAttachments.
        Parameters:
        target - Target CMAttachmentBearer.

      • CMPropagateAttachments

        public static void CMPropagateAttachments​(org.moe.natj.general.ptr.ConstVoidPtr source,
                                          org.moe.natj.general.ptr.ConstVoidPtr destination)
        [@function] CMPropagateAttachments Copy all propagatable attachments from one buffer to another. CMPropagateAttachments is a convenience call that copies all attachments with a mode of kCMAttachmentMode_ShouldPropagate from one buffer to another. Given a CVBufferRef, CMPropagateAttachments is equivalent to CVBufferPropagateAttachments.
        Parameters:
        source - CMAttachmentBearer to copy attachments from.
        destination - CMAttachmentBearer to copy attachments to.

      • CMBlockBufferCreateEmpty

        public static int CMBlockBufferCreateEmpty​(CFAllocatorRef structureAllocator,
                                           int subBlockCapacity,
                                           int flags,
                                           org.moe.natj.general.ptr.Ptr<CMBlockBufferRef> blockBufferOut)
        [@function] CMBlockBufferCreateEmpty Creates an empty CMBlockBuffer Creates an empty CMBlockBuffer, i.e. one which has no memory block nor reference to a CMBlockBuffer supplying bytes to it. It is ready to be populated using CMBlockBufferAppendMemoryBlock() and/or CMBlockBufferAppendBufferReference(). CMBlockBufferGetDataLength() will return zero for an empty CMBlockBuffer and CMBlockBufferGetDataPointer() and CMBlockBufferAssureBufferMemory() will fail. The memory for the CMBlockBuffer object will be allocated using the given allocator. If NULL is passed for the allocator, the default allocator is used.
        Parameters:
        structureAllocator - Allocator to use for allocating the CMBlockBuffer object. NULL will cause the default allocator to be used.
        subBlockCapacity - Number of subBlocks the newBlockBuffer shall accommodate before expansion occurs. A value of zero means "do the reasonable default"
        flags - Feature and control flags
        blockBufferOut - Receives newly-created empty CMBlockBuffer object with retain count of 1. Must not be NULL.
        Returns:
        Returns kCMBlockBufferNoErr if successful.

      • CMBlockBufferCreateWithMemoryBlock

        public static int CMBlockBufferCreateWithMemoryBlock​(CFAllocatorRef structureAllocator,
                                                     org.moe.natj.general.ptr.VoidPtr memoryBlock,
                                                     long blockLength,
                                                     CFAllocatorRef blockAllocator,
                                                     CMBlockBufferCustomBlockSource customBlockSource,
                                                     long offsetToData,
                                                     long dataLength,
                                                     int flags,
                                                     org.moe.natj.general.ptr.Ptr<CMBlockBufferRef> blockBufferOut)
        [@function] CMBlockBufferCreateWithMemoryBlock Creates a new CMBlockBuffer backed by a memory block (or promise thereof). Creates a new CMBlockBuffer backed by a memory block. The memory block may be statically allocated, dynamically allocated using the given allocator (or customBlockSource) or not yet allocated. The returned CMBlockBuffer may be further expanded using CMBlockBufferAppendMemoryBlock() and/or CMBlockBufferAppendBufferReference(). If the kCMBlockBufferAssureMemoryNowFlag is set in the flags parameter, the memory block is allocated immediately using the blockAllocator or customBlockSource.
        Parameters:
        structureAllocator - Allocator to use for allocating the CMBlockBuffer object. NULL will cause the default allocator to be used.
        memoryBlock - Block of memory to hold buffered data. If NULL, a memory block will be allocated when needed (via a call to CMBlockBufferAssureBlockMemory()) using the provided blockAllocator or customBlockSource. If non-NULL, the block will be used and will be deallocated when the new CMBlockBuffer is finalized (i.e. released for the last time).
        blockLength - Overall length of the memory block in bytes. Must not be zero. This is the size of the supplied memory block or the size to allocate if memoryBlock is NULL.
        blockAllocator - Allocator to be used for allocating the memoryBlock, if memoryBlock is NULL. If memoryBlock is non-NULL, this allocator will be used to deallocate it if provided. Passing NULL will cause the default allocator (as set at the time of the call) to be used. Pass kCFAllocatorNull if no deallocation is desired.
        customBlockSource - If non-NULL, it will be used for the allocation and freeing of the memory block (the blockAllocator parameter is ignored). If provided, and the memoryBlock parameter is NULL, its Allocate() routine must be non-NULL. Allocate will be called once, if successful, when the memoryBlock is allocated. Free() will be called once when the CMBlockBuffer is disposed.
        offsetToData - Offset within the memoryBlock at which the CMBlockBuffer should refer to data.
        dataLength - Number of relevant data bytes, starting at offsetToData, within the memory block.
        flags - Feature and control flags
        blockBufferOut - Receives newly-created CMBlockBuffer object with a retain count of 1. Must not be NULL.
        Returns:
        Returns kCMBlockBufferNoErr if successful.

      • CMBlockBufferCreateWithBufferReference

        public static int CMBlockBufferCreateWithBufferReference​(CFAllocatorRef structureAllocator,
                                                         CMBlockBufferRef bufferReference,
                                                         long offsetToData,
                                                         long dataLength,
                                                         int flags,
                                                         org.moe.natj.general.ptr.Ptr<CMBlockBufferRef> blockBufferOut)
        [@function] CMBlockBufferCreateWithBufferReference Creates a new CMBlockBuffer that refers to another CMBlockBuffer. Creates a new CMBlockBuffer that refers to (a possibly subset portion of) another CMBlockBuffer. The returned CMBlockBuffer may be further expanded using CMBlockBufferAppendMemoryBlock() and/or CMBlockBufferAppendBufferReference().
        Parameters:
        structureAllocator - Allocator to use for allocating the CMBlockBuffer object. NULL will cause the default allocator to be used.
        bufferReference - CMBlockBuffer to refer to. This parameter must not be NULL. Unless the kCMBlockBufferPermitEmptyReferenceFlag is passed, it must not be empty and it must have a data length at least large enough to supply the data subset specified (i.e. offsetToData+dataLength bytes).
        offsetToData - Offset within the reference CMBlockBuffer at which the new CMBlockBuffer should refer to data.
        dataLength - Number of relevant data bytes, starting at offsetToData, within the target CMBlockBuffer.
        flags - Feature and control flags
        blockBufferOut - Receives newly-created CMBlockBuffer object with a retain count of 1. Must not be NULL.
        Returns:
        Returns kCMBlockBufferNoErr if successful.

      • CMBlockBufferCreateContiguous

        public static int CMBlockBufferCreateContiguous​(CFAllocatorRef structureAllocator,
                                                CMBlockBufferRef sourceBuffer,
                                                CFAllocatorRef blockAllocator,
                                                CMBlockBufferCustomBlockSource customBlockSource,
                                                long offsetToData,
                                                long dataLength,
                                                int flags,
                                                org.moe.natj.general.ptr.Ptr<CMBlockBufferRef> blockBufferOut)
        [@function] CMBlockBufferCreateContiguous Produces a CMBlockBuffer containing a contiguous copy of or reference to the data specified by the parameters. Produces a CMBlockBuffer containing a contiguous copy of or reference to the data specified by the parameters. The resulting new CMBlockBuffer may contain an allocated copy of the data, or may contain a contiguous CMBlockBuffer reference. If the kCMBlockBufferAlwaysCopyDataFlag is set in the flags parameter, the resulting CMBlockBuffer will contain an allocated copy of the data rather than a reference to sourceBuffer.
        Parameters:
        structureAllocator - Allocator to use for allocating the CMBlockBuffer object. NULL will cause the default allocator to be used.
        sourceBuffer - CMBlockBuffer from which data will be copied or referenced. Must not be NULL nor empty,
        blockAllocator - Allocator to be used for allocating the memoryBlock if a contiguous copy of the data is to be made. Passing NULL will cause the default allocator (as set at the time of the call) to be used.
        customBlockSource - If non-NULL, it will be used for the allocation and freeing of the memory block (the blockAllocator parameter is ignored). If provided, and the memoryBlock parameter is NULL, its Allocate() routine must be non-NULL. Allocate will be called once, if successful, when the memoryBlock is allocated. Free() will be called once when the CMBlockBuffer is disposed.
        offsetToData - Offset within the source CMBlockBuffer at which the new CMBlockBuffer should obtain data.
        dataLength - Number of relevant data bytes, starting at offsetToData, within the source CMBlockBuffer. If zero, the target buffer's total available dataLength (starting at offsetToData) will be referenced.
        flags - Feature and control flags
        blockBufferOut - Receives newly-created CMBlockBuffer object with a retain count of 1. Must not be NULL.
        Returns:
        Returns kCMBlockBufferNoErr if successful

      • CMBlockBufferGetTypeID

        public static long CMBlockBufferGetTypeID()
        [@function] CMBlockBufferGetTypeID Obtains the CoreFoundation type ID for the CMBlockBuffer type. Obtains the CoreFoundation type ID for the CMBlockBuffer type.
        Returns:
        Returns the CFTypeID corresponding to CMBlockBuffer.

      • CMBlockBufferAppendMemoryBlock

        public static int CMBlockBufferAppendMemoryBlock​(CMBlockBufferRef theBuffer,
                                                 org.moe.natj.general.ptr.VoidPtr memoryBlock,
                                                 long blockLength,
                                                 CFAllocatorRef blockAllocator,
                                                 CMBlockBufferCustomBlockSource customBlockSource,
                                                 long offsetToData,
                                                 long dataLength,
                                                 int flags)
        [@function] CMBlockBufferAppendMemoryBlock Adds a memoryBlock to an existing CMBlockBuffer. Adds a memoryBlock to an existing CMBlockBuffer. The memory block may be statically allocated, dynamically allocated using the given allocator or not yet allocated. The CMBlockBuffer's total data length will be increased by the specified dataLength. If the kCMBlockBufferAssureMemoryNowFlag is set in the flags parameter, the memory block is allocated immediately using the blockAllocator or customBlockSource. Note that append operations are not thread safe, so care must be taken when appending to BlockBuffers that are used by multiple threads.
        Parameters:
        theBuffer - CMBlockBuffer to which the new memoryBlock will be added. Must not be NULL
        memoryBlock - Block of memory to hold buffered data. If NULL, a memory block will be allocated when needed (via a call to CMBlockBufferAssureBlockMemory()) using the provided blockAllocator or customBlockSource. If non-NULL, the block will be used and will be deallocated when the CMBlockBuffer is finalized (i.e. released for the last time).
        blockLength - Overall length of the memory block in bytes. Must not be zero. This is the size of the supplied memory block or the size to allocate if memoryBlock is NULL.
        blockAllocator - Allocator to be used for allocating the memoryBlock, if memoryBlock is NULL. If memoryBlock is non-NULL, this allocator will be used to deallocate it if provided. Passing NULL will cause the default allocator (as set at the time of the call) to be used. Pass kCFAllocatorNull if no deallocation is desired.
        customBlockSource - If non-NULL, it will be used for the allocation and freeing of the memory block (the blockAllocator parameter is ignored). If provided, and the memoryBlock parameter is NULL, its Allocate() routine must be non-NULL. Allocate will be called once, if successful, when the memoryBlock is allocated. Free() will be called once when the CMBlockBuffer is disposed.
        offsetToData - Offset within the memoryBlock at which the CMBlockBuffer should refer to data.
        dataLength - Number of relevant data bytes, starting at offsetToData, within the memory block.
        flags - Feature and control flags
        Returns:
        Returns kCMBlockBufferNoErr if successful.

      • CMBlockBufferAppendBufferReference

        public static int CMBlockBufferAppendBufferReference​(CMBlockBufferRef theBuffer,
                                                     CMBlockBufferRef targetBBuf,
                                                     long offsetToData,
                                                     long dataLength,
                                                     int flags)
        [@function] CMBlockBufferAppendBufferReference Adds a CMBlockBuffer reference to an existing CMBlockBuffer. Adds a buffer reference to (a possibly subset portion of) another CMBlockBuffer to an existing CMBlockBuffer. The CMBlockBuffer's total data length will be increased by the specified dataLength. Note that append operations are not thread safe, so care must be taken when appending to BlockBuffers that are used by multiple threads.
        Parameters:
        theBuffer - CMBlockBuffer to which the new CMBlockBuffer reference will be added. Must not be NULL
        targetBBuf - CMBlockBuffer to refer to. This parameter must not be NULL. Unless the kCMBlockBufferPermitEmptyReferenceFlag is passed, it must not be empty and it must have a data length at least large enough to supply the data subset specified (i.e. offsetToData+dataLength bytes).
        offsetToData - Offset within the target CMBlockBuffer at which the CMBlockBuffer should refer to data.
        dataLength - Number of relevant data bytes, starting at offsetToData, within the target CMBlockBuffer. If zero, the target buffer's total available dataLength (starting at offsetToData) will be referenced.
        flags - Feature and control flags
        Returns:
        Returns kCMBlockBufferNoErr if successful.

      • CMBlockBufferAssureBlockMemory

        public static int CMBlockBufferAssureBlockMemory​(CMBlockBufferRef theBuffer)
        [@function] CMBlockBufferAssureBlockMemory Assures all memory blocks in a CMBlockBuffer are allocated. Traverses the possibly complex CMBlockBuffer, allocating the memory for any constituent memory blocks that are not yet allocated.
        Parameters:
        theBuffer - CMBlockBuffer to operate on. Must not be NULL
        Returns:
        Returns kCMBlockBufferNoErr if successful.

      • CMBlockBufferAccessDataBytes

        public static int CMBlockBufferAccessDataBytes​(CMBlockBufferRef theBuffer,
                                               long offset,
                                               long length,
                                               org.moe.natj.general.ptr.VoidPtr temporaryBlock,
                                               org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.BytePtr> returnedPointerOut)
        [@function] CMBlockBufferAccessDataBytes Accesses potentially noncontiguous data in a CMBlockBuffer. Used for accessing potentially noncontiguous data, this routine will return a pointer directly into the given CMBlockBuffer if possible, otherwise the data will be assembled and copied into the given temporary block and its pointer will be returned.
        Parameters:
        theBuffer - CMBlockBuffer to operate on. Must not be NULL
        offset - Offset within the CMBlockBuffer's offset range.
        length - Desired number of bytes to access at offset
        temporaryBlock - A piece of memory, assumed to be at least length bytes in size. Must not be NULL
        returnedPointerOut - Receives NULL if the desired amount of data could not be accessed at the given offset. Receives non-NULL if it could. The value returned will either be a direct pointer into the CMBlockBuffer or temporaryBlock Must not be NULL.
        Returns:
        Returns kCMBlockBufferNoErr if the desired amount of data could be accessed at the given offset.

      • CMBlockBufferCopyDataBytes

        public static int CMBlockBufferCopyDataBytes​(CMBlockBufferRef theSourceBuffer,
                                             long offsetToData,
                                             long dataLength,
                                             org.moe.natj.general.ptr.VoidPtr destination)
        [@function] CMBlockBufferCopyDataBytes Copies bytes from a CMBlockBuffer into a provided memory area. This function is used to copy bytes out of a CMBlockBuffer into a provided piece of memory. It deals with the possibility of the desired range of data being noncontiguous. The function assumes that the memory at the destination is sufficient to hold the data. If length bytes of data are not available in the CMBlockBuffer, an error is returned and the contents of the destination are undefined.
        Parameters:
        theSourceBuffer - The buffer from which data will be copied into the destination
        offsetToData - Offset within the source CMBlockBuffer at which the copy should begin.
        dataLength - Number of bytes to copy, starting at offsetToData, within the source CMBlockBuffer. Must not be zero.
        destination - Memory into which the data should be copied.
        Returns:
        Returns kCMBlockBufferNoErr if the copy succeeded, returns an error otherwise.

      • CMBlockBufferReplaceDataBytes

        public static int CMBlockBufferReplaceDataBytes​(org.moe.natj.general.ptr.ConstVoidPtr sourceBytes,
                                                CMBlockBufferRef destinationBuffer,
                                                long offsetIntoDestination,
                                                long dataLength)
        [@function] CMBlockBufferReplaceDataBytes Copies bytes from a given memory block into a CMBlockBuffer, replacing bytes in the underlying data blocks This function is used to replace bytes in a CMBlockBuffer's memory blocks with those from a provided piece of memory. It deals with the possibility of the destination range of data being noncontiguous. CMBlockBufferAssureBlockMemory() is called on the given CMBlockBuffer. If desired range is subsequently not accessible in the CMBlockBuffer, an error is returned and the contents of the CMBlockBuffer are untouched.
        Parameters:
        sourceBytes - Memory block from which bytes are copied into the CMBlockBuffer
        destinationBuffer - CMBlockBuffer whose range of bytes will be replaced by the sourceBytes.
        offsetIntoDestination - Offset within the destination CMBlockBuffer at which replacement should begin.
        dataLength - Number of bytes to be replaced, starting at offsetIntoDestination, in the destinationBuffer.
        Returns:
        Returns kCMBlockBufferNoErr if the replacement succeeded, returns an error otherwise.

      • CMBlockBufferFillDataBytes

        public static int CMBlockBufferFillDataBytes​(byte fillByte,
                                             CMBlockBufferRef destinationBuffer,
                                             long offsetIntoDestination,
                                             long dataLength)
        [@function] CMBlockBufferFillDataBytes Fills a CMBlockBuffer with a given byte value, replacing bytes in the underlying data blocks This function is used to fill bytes in a CMBlockBuffer's memory blocks with a given byte value. It deals with the possibility of the destination range of data being noncontiguous. CMBlockBufferAssureBlockMemory() is called on the given CMBlockBuffer. If desired range is subsequently not accessible in the CMBlockBuffer, an error is returned and the contents of the CMBlockBuffer are untouched.
        Parameters:
        fillByte - The value with which to fill the specified data range
        destinationBuffer - CMBlockBuffer whose range of bytes will be filled.
        offsetIntoDestination - Offset within the destination CMBlockBuffer at which filling should begin.
        dataLength - Number of bytes to be filled, starting at offsetIntoDestination, in the destinationBuffer. If zero, the destinationBuffer's total available dataLength (starting at offsetToData) will be filled.
        Returns:
        Returns kCMBlockBufferNoErr if the fill succeeded, returns an error otherwise.

      • CMBlockBufferGetDataPointer

        public static int CMBlockBufferGetDataPointer​(CMBlockBufferRef theBuffer,
                                              long offset,
                                              org.moe.natj.general.ptr.NUIntPtr lengthAtOffsetOut,
                                              org.moe.natj.general.ptr.NUIntPtr totalLengthOut,
                                              org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.BytePtr> dataPointerOut)
        [@function] CMBlockBufferGetDataPointer Gains access to the data represented by a CMBlockBuffer. Gains access to the data represented by a CMBlockBuffer. A pointer into a memory block is returned which corresponds to the offset within the CMBlockBuffer. The number of bytes addressable at the pointer can also be returned. This length-at-offset may be smaller than the number of bytes actually available starting at the offset if the dataLength of the CMBlockBuffer is covered by multiple memory blocks (a noncontiguous CMBlockBuffer). The data pointer returned will remain valid as long as the original CMBlockBuffer is referenced - once the CMBlockBuffer is released for the last time, any pointers into it will be invalid.
        Parameters:
        theBuffer - CMBlockBuffer to operate on. Must not be NULL
        offset - Offset within the buffer's offset range.
        lengthAtOffsetOut - On return, contains the amount of data available at the specified offset. May be NULL.
        totalLengthOut - On return, contains the block buffer's total data length (from offset 0). May be NULL. The caller can compare (offset+lengthAtOffset) with totalLength to determine whether the entire CMBlockBuffer has been referenced and whether it is possible to access the CMBlockBuffer's data with a contiguous reference.
        dataPointerOut - On return, contains a pointer to the data byte at the specified offset; lengthAtOffset bytes are available at this address. May be NULL.
        Returns:
        Returns kCMBlockBufferNoErr if data was accessible at the specified offset within the given CMBlockBuffer, false otherwise.

      • CMBlockBufferGetDataLength

        public static long CMBlockBufferGetDataLength​(CMBlockBufferRef theBuffer)
        [@function] CMBlockBufferGetDataLength Obtains the total data length reachable via a CMBlockBuffer. Obtains the total data length reachable via a CMBlockBuffer. This total is the sum of the dataLengths of the CMBlockBuffer's memoryBlocks and buffer references. Note that the dataLengths are the _portions_ of those constituents that this CMBlockBuffer subscribes to. This CMBlockBuffer presents a contiguous range of offsets from zero to its totalDataLength as returned by this routine.
        Parameters:
        theBuffer - CMBlockBuffer to examine.
        Returns:
        Returns the total data length available via this CMBlockBuffer, or zero if it is empty, NULL, or somehow invalid.

      • CMBlockBufferIsRangeContiguous

        public static byte CMBlockBufferIsRangeContiguous​(CMBlockBufferRef theBuffer,
                                                  long offset,
                                                  long length)
        [@function] CMBlockBufferIsRangeContiguous Determines whether the specified range within the given CMBlockBuffer is contiguous. Determines whether the specified range within the given CMBlockBuffer is contiguous. if CMBlockBufferGetDataPointer() were to be called with the same parameters, the returned pointer would address the desired number of bytes.
        Parameters:
        theBuffer - CMBlockBuffer to examine. Must not be NULL
        offset - Offset within the buffer's offset range.
        length - Desired number of bytes to access at offset. If zero, the number of bytes available at offset (dataLength – offset), contiguous or not, is used.
        Returns:
        Returns true if the specified range is contiguous within the CMBlockBuffer, false otherwise. Also returns false if the CMBlockBuffer is NULL or empty.

      • CMBlockBufferIsEmpty

        public static byte CMBlockBufferIsEmpty​(CMBlockBufferRef theBuffer)
        [@function] CMBlockBufferIsEmpty Indicates whether the given CMBlockBuffer is empty. Indicates whether the given CMBlockBuffer is empty, i.e., devoid of any memoryBlocks or CMBlockBuffer references. Note that a CMBlockBuffer containing a not-yet allocated memoryBlock is not considered empty.
        Parameters:
        theBuffer - CMBlockBuffer to examine. Must not be NULL
        Returns:
        Returns the result of the emptiness test. Will return false if the CMBlockBuffer is NULL.

      • CMFormatDescriptionCreate

        public static int CMFormatDescriptionCreate​(CFAllocatorRef allocator,
                                            int mediaType,
                                            int mediaSubType,
                                            CFDictionaryRef extensions,
                                            org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMFormatDescriptionCreate Creates a generic CMFormatDescription object. Use this call to create any CMFormatDescription that is composed solely of extensions, and for which CFEqual() of a the extensions dictionaries is a valid test for Format Description equality. Note that for some media types using this routine may result in creating a format description that is not fully specified for the purpose of media processing. Whenever possible, use media-specific format description creations routines such as CMVideoFormatDescriptionCreate, CMAudioFormatDescriptionCreate, etc.
        Returns:
        A new CMFormatDescription object.

      • CMFormatDescriptionGetTypeID

        public static long CMFormatDescriptionGetTypeID()
        [@function] CMFormatDescriptionGetTypeID Returns the CFTypeID of CMFormatDescription objects. You can check if a CFTypeRef object is actually a CMFormatDescription by comparing CFGetTypeID(object) with CMFormatDescriptionGetTypeID().

      • CMFormatDescriptionEqual

        public static byte CMFormatDescriptionEqual​(CMFormatDescriptionRef formatDescription,
                                            CMFormatDescriptionRef otherFormatDescription)
        [@function] CMFormatDescriptionEqual Compares two CMFormatDescription objects for equality. This calls CFEqual on the provided CMFormatDescription objects. In contrast to the CF call it is NULL safe.

      • CMFormatDescriptionEqualIgnoringExtensionKeys

        public static byte CMFormatDescriptionEqualIgnoringExtensionKeys​(CMFormatDescriptionRef formatDescription,
                                                                 CMFormatDescriptionRef otherFormatDescription,
                                                                 org.moe.natj.general.ptr.ConstVoidPtr formatDescriptionExtensionKeysToIgnore,
                                                                 org.moe.natj.general.ptr.ConstVoidPtr sampleDescriptionExtensionAtomKeysToIgnore)
        [@function] CMFormatDescriptionEqualIgnoringExtensionKeys Compares two CMFormatDescription objects for equality, ignoring differences in specified lists of format description extension keys and sample description extension keys. This function is NULL safe. If any keys are passed, kCMFormatDescriptionExtension_VerbatimSampleDescription and kCMFormatDescriptionExtension_VerbatimISOSampleEntry will also be automatically ignored for the purpose of comparison.
        Parameters:
        formatDescriptionExtensionKeysToIgnore - Either a single format description extension key (CFString) or a CFArray of such keys.
        sampleDescriptionExtensionAtomKeysToIgnore - Either a single sample description extension atom key (four-character CFString) or a CFArray of such keys. See kCMFormatDescriptionExtension_SampleDescriptionExtensionAtoms.

      • CMFormatDescriptionGetMediaType

        public static int CMFormatDescriptionGetMediaType​(CMFormatDescriptionRef desc)
        [@function] CMFormatDescriptionGetMediaType Returns the media type of a CMFormatDescription. For example, returns kCMMediaType_Audio for a description of an audio stream.
        Returns:
        The media type of the CMFormatDescription.

      • CMFormatDescriptionGetMediaSubType

        public static int CMFormatDescriptionGetMediaSubType​(CMFormatDescriptionRef desc)
        [@function] CMFormatDescriptionGetMediaSubType Returns the media subtype of a CMFormatDescription. The media subtype is defined in a media-specific way. For audio streams, the media subtype is the asbd.mFormatID. For video streams, the media subtype is the video codec type. For muxed streams, it is the format of the muxed stream. For example, 'aac ' is returned for a description of an AAC audio stream, 'avc1' is returned for a description of an H.264 video stream, and 'mp2t' is returned for a description of an MPEG-2 transport (muxed) stream. If a particular type of media stream does not have subtypes, this API may return 0.
        Returns:
        The media subtype of the CMFormatDescription.

      • CMFormatDescriptionGetExtensions

        public static CFDictionaryRef CMFormatDescriptionGetExtensions​(CMFormatDescriptionRef desc)
        [@function] CMFormatDescriptionGetExtensions Returns an immutable dictionary containing all the extensions of a CMFormatDescription. If there are no extensions, NULL is returned. Extensions dictionaries are valid property list objects. This means that dictionary keys are all CFStrings, and the values are all either CFNumber, CFString, CFBoolean, CFArray, CFDictionary, CFDate, or CFData. The returned dictionary is not retained by this call, so clients are required to retain it if they need to keep it longer.
        Returns:
        An immutable dictionary containing all the extensions of the CMFormatDescription. May be NULL.

      • CMFormatDescriptionGetExtension

        public static org.moe.natj.general.ptr.ConstVoidPtr CMFormatDescriptionGetExtension​(CMFormatDescriptionRef desc,
                                                                                    CFStringRef extensionKey)
        [@function] CMFormatDescriptionGetExtension Returns the specified extension of a CMFormatDescription. If the named extension does not exist, NULL is returned. The extension is always a valid property list object. This means that it will be either a CFNumber, CFString, CFBoolean, CFArray, CFDictionary, CFDate, or CFData. If it is a CFDictionary, the keys will all be CFStrings. The returned extension is not retained by this call, so it is only valid as long as the CMFormatDescription is valid. Clients are required to retain it if they need to keep it longer.
        Returns:
        The specified extension of the CMFormatDescription. May be NULL.

      • CMAudioFormatDescriptionCreate

        public static int CMAudioFormatDescriptionCreate​(CFAllocatorRef allocator,
                                                 AudioStreamBasicDescription asbd,
                                                 long layoutSize,
                                                 AudioChannelLayout layout,
                                                 long magicCookieSize,
                                                 org.moe.natj.general.ptr.ConstVoidPtr magicCookie,
                                                 CFDictionaryRef extensions,
                                                 org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMAudioFormatDescriptionCreate Creates a format description for an audio media stream. The ASBD is required, the channel layout is optional, and the magic cookie is required for some compression formats (and must be NULL for all others). The caller owns the returned CMFormatDescription, and must release it when done with it. The ASBD, magic cookie, channel layout, and extensions are all copied (the extensions are deep-copied). The caller can deallocate them or re-use them after making this call.

      • CMAudioFormatDescriptionGetStreamBasicDescription

        public static AudioStreamBasicDescription CMAudioFormatDescriptionGetStreamBasicDescription​(CMFormatDescriptionRef desc)
        [@function] CMAudioFormatDescriptionGetStreamBasicDescription Returns a read-only pointer to the AudioStreamBasicDescription inside an audio CMFormatDescription. See CoreAudioTypes.h for the definition of AudioStreamBasicDescription. This API is specific to audio format descriptions, and will return NULL if used with a non-audio format descriptions.

      • CMAudioFormatDescriptionGetMagicCookie

        public static org.moe.natj.general.ptr.ConstVoidPtr CMAudioFormatDescriptionGetMagicCookie​(CMFormatDescriptionRef desc,
                                                                                           org.moe.natj.general.ptr.NUIntPtr sizeOut)
        [@function] CMAudioFormatDescriptionGetMagicCookie Returns a read-only pointer to (and size of) the magic cookie inside an audio CMFormatDescription. The magic cookie is a completely opaque piece of data, written and read only by the codec itself. A magic cookie is only present for codecs that require it; this API will return NULL if one does not exist. This API is specific to audio format descriptions, and will return NULL if called with a non-audio format description.
        Returns:
        A read-only pointer to the magic cookie inside the audio format description.

      • CMAudioFormatDescriptionGetChannelLayout

        public static AudioChannelLayout CMAudioFormatDescriptionGetChannelLayout​(CMFormatDescriptionRef desc,
                                                                          org.moe.natj.general.ptr.NUIntPtr sizeOut)
        [@function] CMAudioFormatDescriptionGetChannelLayout Returns a read-only pointer to (and size of) the AudioChannelLayout inside an audio CMFormatDescription. See CoreAudioTypes.h for the definition of AudioChannelLayout. AudioChannelLayouts are optional; this API will return NULL if one does not exist. This API is specific to audio format descriptions, and will return NULL if called with a non-audio format description.
        Returns:
        A read-only pointer to the AudioChannelLayout inside the audio format description.

      • CMAudioFormatDescriptionGetFormatList

        public static AudioFormatListItem CMAudioFormatDescriptionGetFormatList​(CMFormatDescriptionRef desc,
                                                                        org.moe.natj.general.ptr.NUIntPtr sizeOut)
        [@function] CMAudioFormatDescriptionGetFormatList Returns a read-only pointer to (and size of) the array of AudioFormatListItem structs inside an audio CMFormatDescription. This property is analogous to kAudioFormatProperty_FormatList (See AudioFormat.h) and follows its conventions. Namely, formats are returned in order from the most to least 'rich', with channel count taking the highest precedence followed by sample rate. This API is specific to audio format descriptions, and will return NULL if called with a non-audio format description.
        Returns:
        A read-only pointer to the array of AudioFormatListItem structs inside the audio format description.

      • CMAudioFormatDescriptionGetRichestDecodableFormat

        public static AudioFormatListItem CMAudioFormatDescriptionGetRichestDecodableFormat​(CMFormatDescriptionRef desc)
        [@function] CMAudioFormatDescriptionGetRichestDecodableFormat Returns a read-only pointer to the appropriate AudioFormatListItem inside an audio CMFormatDescription. This property performs validation on the formats represented by the audio in the description. It finds the first AudioFormatListItem for which the current system has a valid decoder. This API is specific to audio format descriptions, and will return NULL if called with a non-audio format description. It may also return NULL if there is no suitable decoder available on the current system for this audio format.
        Returns:
        A read-only pointer to the appropriate AudioFormatListItem inside the audio format description.

      • CMAudioFormatDescriptionGetMostCompatibleFormat

        public static AudioFormatListItem CMAudioFormatDescriptionGetMostCompatibleFormat​(CMFormatDescriptionRef desc)
        [@function] CMAudioFormatDescriptionGetMostCompatibleFormat Returns a read-only pointer to the appropriate AudioFormatListItem inside an audio CMFormatDescription. This property returns a pointer to the last AudioFormatListItem in the kAudioFormatProperty_FormatList (see AudioFormat.h). This API is specific to audio format descriptions, and will return NULL if called with a non-audio format description.
        Returns:
        A read-only pointer to the appropriate AudioFormatListItem inside the audio format description.

      • CMAudioFormatDescriptionCreateSummary

        public static int CMAudioFormatDescriptionCreateSummary​(CFAllocatorRef allocator,
                                                        CFArrayRef formatDescriptionArray,
                                                        int flags,
                                                        org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMAudioFormatDescriptionCreateSummary Creates a summary audio format description from an array of audio format descriptions. The summary format description will be canonical LPCM and deep enough in sample rate, channel layout and channel count to sensibly contain the result of decoding and mixing the constituent format descriptions.

      • CMAudioFormatDescriptionEqual

        public static byte CMAudioFormatDescriptionEqual​(CMFormatDescriptionRef formatDescription,
                                                 CMFormatDescriptionRef otherFormatDescription,
                                                 int equalityMask,
                                                 org.moe.natj.general.ptr.IntPtr equalityMaskOut)
        [@function] CMAudioFormatDescriptionEqual Evaluates equality for the specified parts of two audio format descriptions. Bits in equalityMask specify the caller's interest in the equality of various parts of the descriptions. Bits set and returned in equalityMaskOut represent the subset of those parts that are equal. If there is any sort of error that prevents the comparison from occurring, false will be returned, and all bits in equalityMaskOut will be cleared. If you pass kCMAudioFormatDescriptionMask_All in equalityMask, and NULL for equalityMaskOut, this API is equivalent to CFEqual(desc1, desc2).
        Returns:
        The result of the comparison. True if all parts in which the caller is interested are equal. False if any of the parts in which the caller is interested are not equal.

      • CMVideoFormatDescriptionCreate

        public static int CMVideoFormatDescriptionCreate​(CFAllocatorRef allocator,
                                                 int codecType,
                                                 int width,
                                                 int height,
                                                 CFDictionaryRef extensions,
                                                 org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMVideoFormatDescriptionCreate Creates a format description for a video media stream. The caller owns the returned CMFormatDescription, and must release it when done with it. All input parameters are copied (the extensions are deep-copied). The caller can deallocate them or re-use them after making this call.

      • CMVideoFormatDescriptionCreateForImageBuffer

        public static int CMVideoFormatDescriptionCreateForImageBuffer​(CFAllocatorRef allocator,
                                                               CVBufferRef imageBuffer,
                                                               org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMVideoFormatDescriptionCreateForImageBuffer Creates a format description for a video media stream contained in CVImageBuffers of the type provided. This convenience function is equivalent to: CMVideoFormatDescriptionCreate( allocator, ( CVPixelBufferGetTypeID() == CFGetTypeID( imageBuffer ) ? CVPixelBufferGetPixelFormatType( imageBuffer ) : 0, width of image, height of image, extensions ); where extensions is a CFDictionary of attachments to image buffer with keys specified by CMVideoFormatDescriptionGetExtensionKeysCommonWithImageBuffers, and also kCMFormatDescriptionExtension_BytesPerRow if applicable.

      • CMVideoFormatDescriptionCreateFromH264ParameterSets

        public static int CMVideoFormatDescriptionCreateFromH264ParameterSets​(CFAllocatorRef allocator,
                                                                      long parameterSetCount,
                                                                      java.lang.String[] parameterSetPointers,
                                                                      org.moe.natj.general.ptr.ConstNUIntPtr parameterSetSizes,
                                                                      int NALUnitHeaderLength,
                                                                      org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMVideoFormatDescriptionCreateFromH264ParameterSets Creates a format description for a video media stream described by H.264 parameter set NAL units. This function parses the dimensions provided by the parameter sets and creates a format description suitable for a raw H.264 stream. The parameter sets' data can come from raw NAL units and must have any emulation prevention bytes needed. The supported NAL unit types to be included in the format description are 7 (sequence parameter set), 8 (picture parameter set) and 13 (sequence parameter set extension). At least one sequence parameter set and one picture parameter set must be provided.

      • CMVideoFormatDescriptionGetH264ParameterSetAtIndex

        public static int CMVideoFormatDescriptionGetH264ParameterSetAtIndex​(CMFormatDescriptionRef videoDesc,
                                                                     long parameterSetIndex,
                                                                     java.lang.String[] parameterSetPointerOut,
                                                                     org.moe.natj.general.ptr.NUIntPtr parameterSetSizeOut,
                                                                     org.moe.natj.general.ptr.NUIntPtr parameterSetCountOut,
                                                                     org.moe.natj.general.ptr.IntPtr NALUnitHeaderLengthOut)
        [@function] CMVideoFormatDescriptionGetH264ParameterSetAtIndex Returns a parameter set contained in a H.264 format description. This function parses the AVC decoder configuration record contained in a H.264 video format description and returns the NAL unit at the given index from it. These NAL units are typically parameter sets (e.g. SPS, PPS), but may contain others as specified by ISO/IEC 14496-15 (e.g. user-data SEI). Both parameterSetPointerOut and parameterSetSizeOut may be NULL, parameterSetCountOut will return the total number of parameter set NAL units contained in the AVC decoder configuration record. The parameter set NAL units returned will already have any emulation prevention bytes needed. The pointer returned in parameterSetPointerOut points to internal memory of videoDesc, and may only be accessed as long as a retain on videoDesc is held.

      • CMVideoFormatDescriptionGetDimensions

        public static CMVideoDimensions CMVideoFormatDescriptionGetDimensions​(CMFormatDescriptionRef videoDesc)
        [@function] CMVideoFormatDescriptionGetDimensions Returns the dimensions (in encoded pixels) This does not take into account pixel aspect ratio or clean aperture tags.

      • CMVideoFormatDescriptionGetPresentationDimensions

        public static CGSize CMVideoFormatDescriptionGetPresentationDimensions​(CMFormatDescriptionRef videoDesc,
                                                                       byte usePixelAspectRatio,
                                                                       byte useCleanAperture)
        [@function] CMVideoFormatDescriptionGetPresentationDimensions Returns the dimensions, adjusted to take pixel aspect ratio and/or clean aperture into account. Pixel aspect ratio is used to adjust the width, leaving the height alone.

      • CMVideoFormatDescriptionGetCleanAperture

        public static CGRect CMVideoFormatDescriptionGetCleanAperture​(CMFormatDescriptionRef videoDesc,
                                                              byte originIsAtTopLeft)
        [@function] CMVideoFormatDescriptionGetCleanAperture Returns the clean aperture. The clean aperture is a rectangle that defines the portion of the encoded pixel dimensions that represents image data valid for display.

      • CMVideoFormatDescriptionGetExtensionKeysCommonWithImageBuffers

        public static CFArrayRef CMVideoFormatDescriptionGetExtensionKeysCommonWithImageBuffers()
        [@function] CMVideoFormatDescriptionGetExtensionKeysCommonWithImageBuffers Returns an array of the keys that are used both as CMVideoFormatDescription extensions and CVImageBuffer attachments and attributes. When specifying a CMFormatDescription for a CMSampleBuffer, the format description must be consistent with formatting information attached to the CVImageBuffer. The width, height, and codecType must match (for CVPixelBuffers the codec type is given by CVPixelBufferGetPixelFormatType(pixelBuffer); for other CVImageBuffers, the codecType must be 0). The format description extensions must match the image buffer attachments for all the keys in the list returned by this function (if absent in either they must be absent in both). Currently, the list is: kCMFormatDescriptionExtension_CleanAperture kCMFormatDescriptionExtension_FieldCount kCMFormatDescriptionExtension_FieldDetail kCMFormatDescriptionExtension_PixelAspectRatio kCMFormatDescriptionExtension_ColorPrimaries kCMFormatDescriptionExtension_TransferFunction kCMFormatDescriptionExtension_GammaLevel kCMFormatDescriptionExtension_YCbCrMatrix kCMFormatDescriptionExtension_ICCProfile kCMFormatDescriptionExtension_ChromaLocationTopField kCMFormatDescriptionExtension_ChromaLocationBottomField kCMFormatDescriptionExtension_MasteringDisplayColorVolume kCMFormatDescriptionExtension_ContentLightLevelInfo

      • CMVideoFormatDescriptionMatchesImageBuffer

        public static byte CMVideoFormatDescriptionMatchesImageBuffer​(CMFormatDescriptionRef desc,
                                                              CVBufferRef imageBuffer)
        [@function] CMVideoFormatDescriptionMatchesImageBuffer Checks to see if a given format description matches an image buffer. This function uses the keys returned by CMVideoFormatDescriptionGetExtensionKeysCommonWithImageBuffers to compares the extensions of the given format description to the attachments of the given image buffer (if an attachment is absent in either it must be absent in both). It also checks kCMFormatDescriptionExtension_BytesPerRow against CVPixelBufferGetBytesPerRow, if applicable.

      • CMMuxedFormatDescriptionCreate

        public static int CMMuxedFormatDescriptionCreate​(CFAllocatorRef allocator,
                                                 int muxType,
                                                 CFDictionaryRef extensions,
                                                 org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMMuxedFormatDescriptionCreate Creates a format description for a muxed media stream. A muxed format description does not know what the formats are of the substreams within the muxed stream. That information will only be discoverable by the demuxer software (or other software which understands the details of the muxed bitstream) which will need to produce separate format descriptions for each of its output streams. The caller owns the returned CMFormatDescription, and must release it when done with it. All input parameters are copied (the extensions are deep-copied). The caller can deallocate them or re-use them after making this call.

      • CMTextFormatDescriptionGetDisplayFlags

        public static int CMTextFormatDescriptionGetDisplayFlags​(CMFormatDescriptionRef desc,
                                                         org.moe.natj.general.ptr.IntPtr displayFlagsOut)
        [@function] CMTextFormatDescriptionGetDisplayFlags Returns the displayFlags. These are the flags that control how the text appears. The function can return kCMFormatDescriptionError_ValueNotAvailable for formats without display flags.

      • CMTextFormatDescriptionGetJustification

        public static int CMTextFormatDescriptionGetJustification​(CMFormatDescriptionRef desc,
                                                          org.moe.natj.general.ptr.BytePtr horizontaJustificationlOut,
                                                          org.moe.natj.general.ptr.BytePtr verticalJustificationOut)
        [@function] CMTextFormatDescriptionGetJustification Returns horizontal and vertical justification. Values are kCMTextJustification_* constants. The function returns kCMFormatDescriptionError_ValueNotAvailable for format descriptions that do not carry text justification.

      • CMTextFormatDescriptionGetDefaultTextBox

        public static int CMTextFormatDescriptionGetDefaultTextBox​(CMFormatDescriptionRef desc,
                                                           byte originIsAtTopLeft,
                                                           double heightOfTextTrack,
                                                           CGRect defaultTextBoxOut)
        [@function] CMTextFormatDescriptionGetDefaultTextBox Returns the default text box. Within a text track, text is rendered within a text box. There is a default text box set, which can be over-ridden by a sample. The function can return kCMFormatDescriptionError_ValueNotAvailable for format descriptions that do not carry a default text box.

      • CMTextFormatDescriptionGetFontName

        public static int CMTextFormatDescriptionGetFontName​(CMFormatDescriptionRef desc,
                                                     char localFontID,
                                                     org.moe.natj.general.ptr.Ptr<CFStringRef> fontNameOut)
        [@function] CMTextFormatDescriptionGetFontName Returns the font name for a local font ID. Some format descriptions carry a mapping from local font IDs to font names. The function returns kCMFormatDescriptionError_ValueNotAvailable for format descriptions that do not carry such a font mapping table.

      • CMTimeCodeFormatDescriptionCreate

        public static int CMTimeCodeFormatDescriptionCreate​(CFAllocatorRef allocator,
                                                    int timeCodeFormatType,
                                                    CMTime frameDuration,
                                                    int frameQuanta,
                                                    int flags,
                                                    CFDictionaryRef extensions,
                                                    org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMTimeCodeFormatDescriptionCreate Creates a format description for a timecode media. The caller owns the returned CMFormatDescription, and must release it when done with it. All input parameters are copied (the extensions are deep-copied). The caller can deallocate them or re-use them after making this call.

      • CMTimeCodeFormatDescriptionGetFrameDuration

        public static CMTime CMTimeCodeFormatDescriptionGetFrameDuration​(CMFormatDescriptionRef timeCodeFormatDescription)
        [@function] CMTimeCodeFormatDescriptionGetFrameDuration Returns the duration of each frame (eg. 100/2997)

      • CMTimeCodeFormatDescriptionGetFrameQuanta

        public static int CMTimeCodeFormatDescriptionGetFrameQuanta​(CMFormatDescriptionRef timeCodeFormatDescription)
        [@function] CMTimeCodeFormatDescriptionGetFrameQuanta Returns the frames/sec for timecode (eg. 30) OR frames/tick for counter mode

      • CMTimeCodeFormatDescriptionGetTimeCodeFlags

        public static int CMTimeCodeFormatDescriptionGetTimeCodeFlags​(CMFormatDescriptionRef desc)
        [@function] CMTimeCodeFormatDescriptionGetTimeCodeFlags Returns the flags for kCMTimeCodeFlag_DropFrame, kCMTimeCodeFlag_24HourMax, kCMTimeCodeFlag_NegTimesOK

      • CMMetadataFormatDescriptionCreateWithKeys

        public static int CMMetadataFormatDescriptionCreateWithKeys​(CFAllocatorRef allocator,
                                                            int metadataType,
                                                            CFArrayRef keys,
                                                            org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)

      • CMMetadataFormatDescriptionCreateWithMetadataSpecifications

        public static int CMMetadataFormatDescriptionCreateWithMetadataSpecifications​(CFAllocatorRef allocator,
                                                                              int metadataType,
                                                                              CFArrayRef metadataSpecifications,
                                                                              org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)

      • CMMetadataFormatDescriptionCreateWithMetadataFormatDescriptionAndMetadataSpecifications

        public static int CMMetadataFormatDescriptionCreateWithMetadataFormatDescriptionAndMetadataSpecifications​(CFAllocatorRef allocator,
                                                                                                          CMFormatDescriptionRef sourceDescription,
                                                                                                          CFArrayRef metadataSpecifications,
                                                                                                          org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)

      • CMSampleBufferCreate

        public static int CMSampleBufferCreate​(CFAllocatorRef allocator,
                                       CMBlockBufferRef dataBuffer,
                                       byte dataReady,
                                       CoreMedia.Function_CMSampleBufferCreate makeDataReadyCallback,
                                       org.moe.natj.general.ptr.VoidPtr makeDataReadyRefcon,
                                       CMFormatDescriptionRef formatDescription,
                                       long numSamples,
                                       long numSampleTimingEntries,
                                       CMSampleTimingInfo sampleTimingArray,
                                       long numSampleSizeEntries,
                                       org.moe.natj.general.ptr.ConstNUIntPtr sampleSizeArray,
                                       org.moe.natj.general.ptr.Ptr<CMSampleBufferRef> sampleBufferOut)
        [@function] CMSampleBufferCreate Creates a CMSampleBuffer. Array parameters (sampleSizeArray, sampleTimingArray) should have only one element if that same element applies to all samples. All parameters are copied; on return, the caller can release them, free them, reuse them or whatever. On return, the caller owns the returned CMSampleBuffer, and must release it when done with it. Example of usage for in-display-order video frames:
          dataBuffer: contains 7 Motion JPEG frames
        • dataFormatDescription: describes Motion JPEG video
        • numSamples: 7
        • numSampleTimingEntries: 1
        • sampleTimingArray: one entry = {duration = 1001/30000, presentationTimeStamp = 0/30000, decodeTimeStamp = invalid }
        • numSampleSizeEntries: 7
        • sampleSizeArray: {105840, 104456, 103464, 116460, 100412, 94808, 120400}
        Example of usage for out-of-display-order video frames:
          dataBuffer: contains 6 H.264 frames in decode order (P2,B0,B1,I5,B3,B4)
        • dataFormatDescription: describes H.264 video
        • numSamples: 6
        • numSampleTimingEntries: 6
        • sampleTimingArray: 6 entries = {
            {duration = 1001/30000, presentationTimeStamp = 12012/30000, decodeTimeStamp = 10010/30000},
          • {duration = 1001/30000, presentationTimeStamp = 10010/30000, decodeTimeStamp = 11011/30000},
          • {duration = 1001/30000, presentationTimeStamp = 11011/30000, decodeTimeStamp = 12012/30000},
          • {duration = 1001/30000, presentationTimeStamp = 15015/30000, decodeTimeStamp = 13013/30000},
          • {duration = 1001/30000, presentationTimeStamp = 13013/30000, decodeTimeStamp = 14014/30000},
          • {duration = 1001/30000, presentationTimeStamp = 14014/30000, decodeTimeStamp = 15015/30000}}
        • numSampleSizeEntries: 6
        • sampleSizeArray: {10580, 1234, 1364, 75660, 1012, 988}
        Example of usage for compressed audio:
          dataBuffer: contains 24 compressed AAC packets
        • dataFormatDescription: describes 44.1kHz AAC audio
        • numSamples: 24
        • numSampleTimingEntries: 1
        • sampleTimingArray: one entry = {
            {duration = 1024/44100, presentationTimeStamp = 0/44100, decodeTimeStamp = invalid }}
        • numSampleSizeEntries: 24
        • sampleSizeArray:
            {191, 183, 208, 213, 202, 206, 209, 206, 204, 192, 202, 277,
          • 282, 240, 209, 194, 193, 197, 196, 198, 168, 199, 171, 194}
        Example of usage for uncompressed interleaved audio:
          dataBuffer: contains 24000 uncompressed interleaved stereo frames, each containing 2 Float32s =
            {{L,R},
          • {L,R},
          • {L,R}, ...}
        • dataFormatDescription: describes 48kHz Float32 interleaved audio
        • numSamples: 24000
        • numSampleTimingEntries: 1
        • sampleTimingArray: one entry = {
            {duration = 1/48000, presentationTimeStamp = 0/48000, decodeTimeStamp = invalid }}
        • numSampleSizeEntries: 1
        • sampleSizeArray: {8}
        Example of usage for uncompressed non-interleaved audio:
          dataBuffer: contains 24000 uncompressed non-interleaved stereo frames, each containing 2 (non-contiguous) Float32s =
            {{L,L,L,L,L,...},
          • {R,R,R,R,R,...}}
        • dataFormatDescription: describes 48kHz Float32 non-interleaved audio
        • numSamples: 24000
        • numSampleTimingEntries: 1
        • sampleTimingArray: one entry = {duration = 1/48000, presentationTimeStamp = 0/48000, decodeTimeStamp = invalid }
        • numSampleSizeEntries: 0
        • sampleSizeArray: NULL (because the samples are not contiguous)

      • CMSampleBufferCreateReady

        public static int CMSampleBufferCreateReady​(CFAllocatorRef allocator,
                                            CMBlockBufferRef dataBuffer,
                                            CMFormatDescriptionRef formatDescription,
                                            long numSamples,
                                            long numSampleTimingEntries,
                                            CMSampleTimingInfo sampleTimingArray,
                                            long numSampleSizeEntries,
                                            org.moe.natj.general.ptr.ConstNUIntPtr sampleSizeArray,
                                            org.moe.natj.general.ptr.Ptr<CMSampleBufferRef> sampleBufferOut)
        [@function] CMSampleBufferCreateReady Creates a CMSampleBuffer. Array parameters (sampleSizeArray, sampleTimingArray) should have only one element if that same element applies to all samples. All parameters are copied; on return, the caller can release them, free them, reuse them or whatever. On return, the caller owns the returned CMSampleBuffer, and must release it when done with it. CMSampleBufferCreateReady is identical to CMSampleBufferCreate except that dataReady is always true, and so no makeDataReadyCallback or refcon needs to be passed. Example of usage for in-display-order video frames:
          dataBuffer: contains 7 Motion JPEG frames
        • dataFormatDescription: describes Motion JPEG video
        • numSamples: 7
        • numSampleTimingEntries: 1
        • sampleTimingArray: one entry = {duration = 1001/30000, presentationTimeStamp = 0/30000, decodeTimeStamp = invalid }
        • numSampleSizeEntries: 7
        • sampleSizeArray: {105840, 104456, 103464, 116460, 100412, 94808, 120400}
        Example of usage for out-of-display-order video frames:
          dataBuffer: contains 6 H.264 frames in decode order (P2,B0,B1,I5,B3,B4)
        • dataFormatDescription: describes H.264 video
        • numSamples: 6
        • numSampleTimingEntries: 6
        • sampleTimingArray: 6 entries = {
            {duration = 1001/30000, presentationTimeStamp = 12012/30000, decodeTimeStamp = 10010/30000},
          • {duration = 1001/30000, presentationTimeStamp = 10010/30000, decodeTimeStamp = 11011/30000},
          • {duration = 1001/30000, presentationTimeStamp = 11011/30000, decodeTimeStamp = 12012/30000},
          • {duration = 1001/30000, presentationTimeStamp = 15015/30000, decodeTimeStamp = 13013/30000},
          • {duration = 1001/30000, presentationTimeStamp = 13013/30000, decodeTimeStamp = 14014/30000},
          • {duration = 1001/30000, presentationTimeStamp = 14014/30000, decodeTimeStamp = 15015/30000}}
        • numSampleSizeEntries: 6
        • sampleSizeArray: {10580, 1234, 1364, 75660, 1012, 988}
        Example of usage for compressed audio:
          dataBuffer: contains 24 compressed AAC packets
        • dataFormatDescription: describes 44.1kHz AAC audio
        • numSamples: 24
        • numSampleTimingEntries: 1
        • sampleTimingArray: one entry = {
            {duration = 1024/44100, presentationTimeStamp = 0/44100, decodeTimeStamp = invalid }}
        • numSampleSizeEntries: 24
        • sampleSizeArray:
            {191, 183, 208, 213, 202, 206, 209, 206, 204, 192, 202, 277,
          • 282, 240, 209, 194, 193, 197, 196, 198, 168, 199, 171, 194}
        Example of usage for uncompressed interleaved audio:
          dataBuffer: contains 24000 uncompressed interleaved stereo frames, each containing 2 Float32s =
            {{L,R},
          • {L,R},
          • {L,R}, ...}
        • dataFormatDescription: describes 48kHz Float32 interleaved audio
        • numSamples: 24000
        • numSampleTimingEntries: 1
        • sampleTimingArray: one entry = {
            {duration = 1/48000, presentationTimeStamp = 0/48000, decodeTimeStamp = invalid }}
        • numSampleSizeEntries: 1
        • sampleSizeArray: {8}
        Example of usage for uncompressed non-interleaved audio:
          dataBuffer: contains 24000 uncompressed non-interleaved stereo frames, each containing 2 (non-contiguous) Float32s =
            {{L,L,L,L,L,...},
          • {R,R,R,R,R,...}}
        • dataFormatDescription: describes 48kHz Float32 non-interleaved audio
        • numSamples: 24000
        • numSampleTimingEntries: 1
        • sampleTimingArray: one entry = {duration = 1/48000, presentationTimeStamp = 0/48000, decodeTimeStamp = invalid }
        • numSampleSizeEntries: 0
        • sampleSizeArray: NULL (because the samples are not contiguous)

      • CMAudioSampleBufferCreateWithPacketDescriptions

        public static int CMAudioSampleBufferCreateWithPacketDescriptions​(CFAllocatorRef allocator,
                                                                  CMBlockBufferRef dataBuffer,
                                                                  byte dataReady,
                                                                  CoreMedia.Function_CMAudioSampleBufferCreateWithPacketDescriptions makeDataReadyCallback,
                                                                  org.moe.natj.general.ptr.VoidPtr makeDataReadyRefcon,
                                                                  CMFormatDescriptionRef formatDescription,
                                                                  long numSamples,
                                                                  CMTime presentationTimeStamp,
                                                                  AudioStreamPacketDescription packetDescriptions,
                                                                  org.moe.natj.general.ptr.Ptr<CMSampleBufferRef> sampleBufferOut)
        [@function] CMAudioSampleBufferCreateWithPacketDescriptions Creates an CMSampleBuffer containing audio given packetDescriptions instead of sizing and timing info Provides an optimization over CMSampleBufferCreate() when the caller already has packetDescriptions for the audio data. This routine will use the packetDescriptions to create the sizing and timing arrays required to make the sample buffer if necessary.

      • CMAudioSampleBufferCreateReadyWithPacketDescriptions

        public static int CMAudioSampleBufferCreateReadyWithPacketDescriptions​(CFAllocatorRef allocator,
                                                                       CMBlockBufferRef dataBuffer,
                                                                       CMFormatDescriptionRef formatDescription,
                                                                       long numSamples,
                                                                       CMTime presentationTimeStamp,
                                                                       AudioStreamPacketDescription packetDescriptions,
                                                                       org.moe.natj.general.ptr.Ptr<CMSampleBufferRef> sampleBufferOut)
        [@function] CMAudioSampleBufferCreateReadyWithPacketDescriptions Creates an CMSampleBuffer containing audio given packetDescriptions instead of sizing and timing info Provides an optimization over CMSampleBufferCreate() when the caller already has packetDescriptions for the audio data. This routine will use the packetDescriptions to create the sizing and timing arrays required to make the sample buffer if necessary. CMAudioSampleBufferCreateReadyWithPacketDescriptions is identical to CMAudioSampleBufferCreateWithPacketDescriptions except that dataReady is always true, and so no makeDataReadyCallback or refcon needs to be passed.

      • CMSampleBufferCreateForImageBuffer

        public static int CMSampleBufferCreateForImageBuffer​(CFAllocatorRef allocator,
                                                     CVBufferRef imageBuffer,
                                                     byte dataReady,
                                                     CoreMedia.Function_CMSampleBufferCreateForImageBuffer makeDataReadyCallback,
                                                     org.moe.natj.general.ptr.VoidPtr makeDataReadyRefcon,
                                                     CMFormatDescriptionRef formatDescription,
                                                     CMSampleTimingInfo sampleTiming,
                                                     org.moe.natj.general.ptr.Ptr<CMSampleBufferRef> sampleBufferOut)
        [@function] CMSampleBufferCreateForImageBuffer Creates a CMSampleBuffer that contains a CVImageBuffer instead of a CMBlockBuffer. Unlike a CMBlockBuffer which can reference many samples, a CVImageBuffer is defined to reference only one sample; therefore this routine has fewer parameters then CMSampleBufferCreate. Sample timing information, which is a vector for CMSampleBufferCreate, consists of only one value for this routine. The concept of sample size does not apply to CVImageBuffers. As such, CMSampleBufferGetSampleSizeArray will return kCMSampleBufferError_BufferHasNoSampleSizes, and CMSampleBufferGetSampleSize will return 0. Because CVImageBuffers hold visual data, the format description provided is a CMVideoFormatDescription. The format description must be consistent with the attributes and formatting information attached to the CVImageBuffer. The width, height, and codecType must match (for CVPixelBuffers the codec type is given by CVPixelBufferGetPixelFormatType(pixelBuffer); for other CVImageBuffers, the codecType must be 0). The format description extensions must match the image buffer attachments for all the keys in the list returned by CMVideoFormatDescriptionGetExtensionKeysCommonWithImageBuffers (if absent in either they must be absent in both).

      • CMSampleBufferCreateReadyWithImageBuffer

        public static int CMSampleBufferCreateReadyWithImageBuffer​(CFAllocatorRef allocator,
                                                           CVBufferRef imageBuffer,
                                                           CMFormatDescriptionRef formatDescription,
                                                           CMSampleTimingInfo sampleTiming,
                                                           org.moe.natj.general.ptr.Ptr<CMSampleBufferRef> sampleBufferOut)
        [@function] CMSampleBufferCreateReadyWithImageBuffer Creates a CMSampleBuffer that contains a CVImageBuffer instead of a CMBlockBuffer. Unlike a CMBlockBuffer which can reference many samples, a CVImageBuffer is defined to reference only one sample; therefore this routine has fewer parameters then CMSampleBufferCreate. Sample timing information, which is a vector for CMSampleBufferCreate, consists of only one value for this routine. The concept of sample size does not apply to CVImageBuffers. As such, CMSampleBufferGetSampleSizeArray will return kCMSampleBufferError_BufferHasNoSampleSizes, and CMSampleBufferGetSampleSize will return 0. Because CVImageBuffers hold visual data, the format description provided is a CMVideoFormatDescription. The format description must be consistent with the attributes and formatting information attached to the CVImageBuffer. The width, height, and codecType must match (for CVPixelBuffers the codec type is given by CVPixelBufferGetPixelFormatType(pixelBuffer); for other CVImageBuffers, the codecType must be 0). The format description extensions must match the image buffer attachments for all the keys in the list returned by CMVideoFormatDescriptionGetExtensionKeysCommonWithImageBuffers (if absent in either they must be absent in both). CMSampleBufferCreateReadyWithImageBuffer is identical to CMSampleBufferCreateForImageBuffer except that dataReady is always true, and so no makeDataReadyCallback or refcon needs to be passed.

      • CMSampleBufferCreateCopy

        public static int CMSampleBufferCreateCopy​(CFAllocatorRef allocator,
                                           CMSampleBufferRef sbuf,
                                           org.moe.natj.general.ptr.Ptr<CMSampleBufferRef> sampleBufferOut)
        [@function] CMSampleBufferCreateCopy Creates a copy of a CMSampleBuffer. The copy is shallow: scalar properties (sizes and timing) are copied directly, the data buffer and format description are retained, and the propogatable attachments are retained by the copy's dictionary. If sbuf's data is not ready, the copy will be set to track its readiness.

      • CMSampleBufferCreateCopyWithNewTiming

        public static int CMSampleBufferCreateCopyWithNewTiming​(CFAllocatorRef allocator,
                                                        CMSampleBufferRef originalSBuf,
                                                        long numSampleTimingEntries,
                                                        CMSampleTimingInfo sampleTimingArray,
                                                        org.moe.natj.general.ptr.Ptr<CMSampleBufferRef> sampleBufferOut)
        [@function] CMSampleBufferCreateCopyWithNewTiming Creates a CMSampleBuffer with new timing information from another sample buffer. This emulates CMSampleBufferCreateCopy, but changes the timing. Array parameters (sampleTimingArray) should have only one element if that same element applies to all samples. All parameters are copied; on return, the caller can release them, free them, reuse them or whatever. Any outputPresentationTimestamp that has been set on the original Buffer will not be copied because it is no longer relevant. On return, the caller owns the returned CMSampleBuffer, and must release it when done with it.

      • CMSampleBufferCopySampleBufferForRange

        public static int CMSampleBufferCopySampleBufferForRange​(CFAllocatorRef allocator,
                                                         CMSampleBufferRef sbuf,
                                                         CFRange sampleRange,
                                                         org.moe.natj.general.ptr.Ptr<CMSampleBufferRef> sampleBufferOut)
        [@function] CMSampleBufferCopySampleBufferForRange Creates a CMSampleBuffer containing a range of samples from an existing CMSampleBuffer. Samples containing non-interleaved audio are currently not supported.

      • CMSampleBufferGetTypeID

        public static long CMSampleBufferGetTypeID()
        [@function] CMSampleBufferGetTypeID Returns the CFTypeID of CMSampleBuffer objects. You can check if a CFTypeRef object is actually a CMSampleBuffer by comparing CFGetTypeID(object) with CMSampleBufferGetTypeID().
        Returns:
        CFTypeID of CMSampleBuffer objects.

      • CMSampleBufferSetDataBuffer

        public static int CMSampleBufferSetDataBuffer​(CMSampleBufferRef sbuf,
                                              CMBlockBufferRef dataBuffer)
        [@function] CMSampleBufferSetDataBuffer Associates a CMSampleBuffer with its CMBlockBuffer of media data. If successful, this operation retains the dataBuffer thereafter, so the caller can release the dataBuffer after calling this API, if it has no further need to reference it. This is a write-once operation; it will fail if the CMSampleBuffer already has a dataBuffer. This API allows a CMSampleBuffer to exist, with timing and format information, before the associated data shows up. Example of usage: Some media services may have access to sample size, timing, and format information before the data is read. Such services may create CMSampleBuffers with that information and insert them into queues early, and use this API to attach the CMBlockBuffers later, when the data becomes ready.

      • CMSampleBufferGetDataBuffer

        public static CMBlockBufferRef CMSampleBufferGetDataBuffer​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferGetDataBuffer Returns a CMSampleBuffer's CMBlockBuffer of media data. The caller does not own the returned dataBuffer, and must retain it explicitly if the caller needs to maintain a reference to it.
        Returns:
        CMBlockBuffer of media data. The result will be NULL if the CMSampleBuffer does not contain a CMBlockBuffer, if the CMSampleBuffer contains a CVImageBuffer, or if there is some other error.

      • CMSampleBufferGetImageBuffer

        public static CVBufferRef CMSampleBufferGetImageBuffer​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferGetImageBuffer Returns a CMSampleBuffer's CVImageBuffer of media data. The caller does not own the returned dataBuffer, and must retain it explicitly if the caller needs to maintain a reference to it.
        Returns:
        CVImageBuffer of media data. The result will be NULL if the CMSampleBuffer does not contain a CVImageBuffer, if the CMSampleBuffer contains a CMBlockBuffer, or if there is some other error.

      • CMSampleBufferSetDataBufferFromAudioBufferList

        public static int CMSampleBufferSetDataBufferFromAudioBufferList​(CMSampleBufferRef sbuf,
                                                                 CFAllocatorRef blockBufferStructureAllocator,
                                                                 CFAllocatorRef blockBufferBlockAllocator,
                                                                 int flags,
                                                                 AudioBufferList bufferList)
        [@function] CMSampleBufferSetDataBufferFromAudioBufferList Creates a CMBlockBuffer containing a copy of the data from the AudioBufferList, and sets that as the CMSampleBuffer's data buffer. The resulting buffer(s) in the sample buffer will be 16-byte-aligned if kCMSampleBufferFlag_AudioBufferList_Assure16ByteAlignment is passed in.

      • CMSampleBufferGetAudioBufferListWithRetainedBlockBuffer

        public static int CMSampleBufferGetAudioBufferListWithRetainedBlockBuffer​(CMSampleBufferRef sbuf,
                                                                          org.moe.natj.general.ptr.NUIntPtr bufferListSizeNeededOut,
                                                                          AudioBufferList bufferListOut,
                                                                          long bufferListSize,
                                                                          CFAllocatorRef blockBufferStructureAllocator,
                                                                          CFAllocatorRef blockBufferBlockAllocator,
                                                                          int flags,
                                                                          org.moe.natj.general.ptr.Ptr<CMBlockBufferRef> blockBufferOut)
        [@function] CMSampleBufferGetAudioBufferListWithRetainedBlockBuffer Creates an AudioBufferList containing the data from the CMSampleBuffer, and a CMBlockBuffer which references (and manages the lifetime of) the data in that AudioBufferList. The data may or may not be copied, depending on the contiguity and 16-byte alignment of the CMSampleBuffer's data. The buffers placed in the AudioBufferList are guaranteed to be contiguous. The buffers in the AudioBufferList will be 16-byte-aligned if kCMSampleBufferFlag_AudioBufferList_Assure16ByteAlignment is passed in.

      • CMSampleBufferGetAudioStreamPacketDescriptions

        public static int CMSampleBufferGetAudioStreamPacketDescriptions​(CMSampleBufferRef sbuf,
                                                                 long packetDescriptionsSize,
                                                                 AudioStreamPacketDescription packetDescriptionsOut,
                                                                 org.moe.natj.general.ptr.NUIntPtr packetDescriptionsSizeNeededOut)
        [@function] CMSampleBufferGetAudioStreamPacketDescriptions Creates an array of AudioStreamPacketDescriptions for the variable bytes per packet or variable frames per packet audio data in the provided CMSampleBuffer. Constant bitrate, constant frames-per-packet audio yields a return value of noErr and no packet descriptions. This API is specific to audio format sample buffers, and will return kCMSampleBufferError_InvalidMediaTypeForOperation if called with a non-audio sample buffer.

      • CMSampleBufferGetAudioStreamPacketDescriptionsPtr

        public static int CMSampleBufferGetAudioStreamPacketDescriptionsPtr​(CMSampleBufferRef sbuf,
                                                                    org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstPtr<AudioStreamPacketDescription>> packetDescriptionsPointerOut,
                                                                    org.moe.natj.general.ptr.NUIntPtr packetDescriptionsSizeOut)
        [@function] CMSampleBufferGetAudioStreamPacketDescriptionsPtr Returns a pointer to (and size of) a constant array of AudioStreamPacketDescriptions for the variable bytes per packet or variable frames per packet audio data in the provided CMSampleBuffer. The pointer will remain valid as long as the sbuf continues to be retained. Constant bitrate, constant frames-per-packet audio yields a return value of noErr and no packet descriptions. This API is specific to audio format sample buffers, and will return kCMSampleBufferError_InvalidMediaTypeForOperation if called with a non-audio sample buffer.

      • CMSampleBufferCopyPCMDataIntoAudioBufferList

        public static int CMSampleBufferCopyPCMDataIntoAudioBufferList​(CMSampleBufferRef sbuf,
                                                               int frameOffset,
                                                               int numFrames,
                                                               AudioBufferList bufferList)
        [@function] CMSampleBufferCopyPCMDataIntoAudioBufferList Copies PCM audio data from the given CMSampleBuffer into a pre-populated AudioBufferList. The AudioBufferList must contain the same number of channels and its data buffers must be sized to hold the specified number of frames. This API is specific to audio format sample buffers, and will return kCMSampleBufferError_InvalidMediaTypeForOperation if called with a non-audio sample buffer. It will return an error if the CMSampleBuffer does not contain PCM audio data or if its dataBuffer is not ready.

      • CMSampleBufferSetDataReady

        public static int CMSampleBufferSetDataReady​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferSetDataReady Marks a CMSampleBuffer's data as "ready". There is no way to undo this operation. The only way to get an "unready" CMSampleBuffer is to call CMSampleBufferCreate with the dataReady parameter set to false. Example of usage: in a read completion routine.

      • CMSampleBufferDataIsReady

        public static byte CMSampleBufferDataIsReady​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferDataIsReady Returns whether or not a CMSampleBuffer's data is ready.
        Returns:
        Whether or not the CMSampleBuffer's data is ready. True is returned for special marker buffers, even though they have no data. False is returned if there is an error.

      • CMSampleBufferSetDataFailed

        public static int CMSampleBufferSetDataFailed​(CMSampleBufferRef sbuf,
                                              int status)
        [@function] CMSampleBufferSetDataFailed Marks a CMSampleBuffer's data as "failed", to indicate that the data will not become ready.

      • CMSampleBufferHasDataFailed

        public static byte CMSampleBufferHasDataFailed​(CMSampleBufferRef sbuf,
                                               org.moe.natj.general.ptr.IntPtr statusOut)
        [@function] CMSampleBufferHasDataFailed Returns whether or not a CMSampleBuffer's data loading request has failed.

      • CMSampleBufferMakeDataReady

        public static int CMSampleBufferMakeDataReady​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferMakeDataReady Makes a CMSampleBuffer's data ready, by calling the client's CMSampleBufferMakeDataReadyCallback. The CMSampleBufferMakeDataReadyCallback is passed in by the client during creation. It must return 0 if successful, and in that case, CMSampleBufferMakeDataReady will set the data readiness of the CMSampleBuffer to true. Example of usage: when it is time to actually use the data. Example of callback routine: a routine to force a scheduled read to complete. If the CMSampleBuffer is not ready, and there is no CMSampleBufferMakeDataReadyCallback to call, kCMSampleBufferError_BufferNotReady will be returned. Similarly, if the CMSampleBuffer is not ready, and the CMSampleBufferMakeDataReadyCallback fails and returns an error, kCMSampleBufferError_BufferNotReady will be returned.

      • CMSampleBufferTrackDataReadiness

        public static int CMSampleBufferTrackDataReadiness​(CMSampleBufferRef sbuf,
                                                   CMSampleBufferRef sampleBufferToTrack)
        [@function] CMSampleBufferTrackDataReadiness Associates a CMSampleBuffer's data readiness with another CMSampleBuffer's data readiness. After calling this API, if CMSampleBufferDataIsReady(sbuf) is called, it will return sbufToTrack's data readiness. If CMSampleBufferMakeDataReady(sbuf) is called, it will do it by making sbufToTrack ready. Example of use: This allows bursting a multi-sample CMSampleBuffer into single-sample CMSampleBuffers before the data is ready. The single-sample CMSampleBuffers will all track the multi-sample CMSampleBuffer's data readiness.

      • CMSampleBufferInvalidate

        public static int CMSampleBufferInvalidate​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferInvalidate Makes the sample buffer invalid, calling any installed invalidation callback. An invalid sample buffer cannot be used -- all accessors will return kCMSampleBufferError_Invalidated. It is not a good idea to do this to a sample buffer that another module may be accessing concurrently. Example of use: the invalidation callback could cancel pending I/O.

      • CMSampleBufferSetInvalidateCallback

        public static int CMSampleBufferSetInvalidateCallback​(CMSampleBufferRef sbuf,
                                                      CoreMedia.Function_CMSampleBufferSetInvalidateCallback invalidateCallback,
                                                      long invalidateRefCon)
        [@function] CMSampleBufferSetInvalidateCallback Sets the sample buffer's invalidation callback, which is called during CMSampleBufferInvalidate. A sample buffer can only have one invalidation callback. The invalidation callback is NOT called during ordinary sample buffer finalization.

      • CMSampleBufferSetInvalidateHandler

        public static int CMSampleBufferSetInvalidateHandler​(CMSampleBufferRef sbuf,
                                                     CoreMedia.Block_CMSampleBufferSetInvalidateHandler invalidateHandler)
        [@function] CMSampleBufferSetInvalidateHandler Sets the sample buffer's invalidation handler block, which is called during CMSampleBufferInvalidate. A sample buffer can only have one invalidation callback. The invalidation callback is NOT called during ordinary sample buffer finalization.

      • CMSampleBufferIsValid

        public static byte CMSampleBufferIsValid​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferIsValid Queries whether a sample buffer is still valid. Returns false if sbuf is NULL or CMSampleBufferInvalidate(sbuf) was called, true otherwise. Does not perform any kind of exhaustive validation of the sample buffer.

      • CMSampleBufferGetNumSamples

        public static long CMSampleBufferGetNumSamples​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferGetNumSamples Returns the number of media samples in a CMSampleBuffer.
        Returns:
        The number of media samples in the CMSampleBuffer. 0 is returned if there is an error.

      • CMSampleBufferGetDuration

        public static CMTime CMSampleBufferGetDuration​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferGetDuration Returns the total duration of a CMSampleBuffer. If the buffer contains out-of-presentation-order samples, any gaps in the presentation timeline are not represented in the returned duration. The returned duration is simply the sum of all the individual sample durations.
        Returns:
        The duration of the CMSampleBuffer. kCMTimeInvalid is returned if there is an error.

      • CMSampleBufferGetPresentationTimeStamp

        public static CMTime CMSampleBufferGetPresentationTimeStamp​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferGetPresentationTimeStamp Returns the numerically earliest presentation timestamp of all the samples in a CMSampleBuffer. For in-presentation-order samples, this is the presentation timestamp of the first sample. For out-of-presentation-order samples, this is the presentation timestamp of the sample that will be presented first, which is not necessarily the first sample in the buffer.
        Returns:
        Numerically earliest sample presentation timestamp in the CMSampleBuffer. kCMTimeInvalid is returned if there is an error.

      • CMSampleBufferGetDecodeTimeStamp

        public static CMTime CMSampleBufferGetDecodeTimeStamp​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferGetDecodeTimeStamp Returns the numerically earliest decode timestamp of all the samples in a CMSampleBuffer. The returned decode timestamp is always the decode timestamp of the first sample in the buffer, since even out-of-presentation-order samples are expected to be in decode order in the buffer.
        Returns:
        Numerically earliest sample decode timestamp in the CMSampleBuffer. kCMTimeInvalid is returned if there is an error.

      • CMSampleBufferGetOutputDuration

        public static CMTime CMSampleBufferGetOutputDuration​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferGetOutputDuration Returns the output duration of a CMSampleBuffer. The OutputDuration is the duration minus any trimmed duration, all divided by the SpeedMultiplier: (Duration - TrimDurationAtStart - TrimDurationAtEnd) / SpeedMultiplier
        Returns:
        The output duration of the CMSampleBuffer. kCMTimeInvalid is returned if there is an error.

      • CMSampleBufferGetOutputPresentationTimeStamp

        public static CMTime CMSampleBufferGetOutputPresentationTimeStamp​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferGetOutputPresentationTimeStamp Returns the output presentation timestamp of the CMSampleBuffer. The output presentation timestamp is the time at which the decoded, trimmed, stretched and possibly reversed samples should commence being presented. If CMSampleBufferSetOutputPresentationTimeStamp has been called to explicitly set the output PTS, CMSampleBufferGetOutputPresentationTimeStamp returns it. If not, CMSampleBufferGetOutputPresentationTimeStamp calculates its result as (PresentationTimeStamp + TrimDurationAtStart) unless kCMSampleBufferAttachmentKey_Reverse is kCFBooleanTrue, in which case it calculates the result as (PresentationTimeStamp + Duration - TrimDurationAtEnd). These are generally correct for un-stretched, un-shifted playback. For general forward playback in a scaled edit, the OutputPresentationTimeStamp should be set to: ((PresentationTimeStamp + TrimDurationAtStart - EditStartMediaTime) / EditSpeedMultiplier) + EditStartTrackTime. For general reversed playback: ((PresentationTimeStamp + Duration - TrimDurationAtEnd - EditStartMediaTime) / EditSpeedMultiplier) + EditStartTrackTime.
        Returns:
        kCMTimeInvalid is returned if there is an error.

      • CMSampleBufferSetOutputPresentationTimeStamp

        public static int CMSampleBufferSetOutputPresentationTimeStamp​(CMSampleBufferRef sbuf,
                                                               CMTime outputPresentationTimeStamp)
        [@function] CMSampleBufferSetOutputPresentationTimeStamp Sets an output presentation timestamp to be used in place of a calculated value. The output presentation timestamp is the time at which the decoded, trimmed, stretched and possibly reversed samples should commence being presented. By default, this is calculated by CMSampleBufferGetOutputPresentationTimeStamp. Call CMSampleBufferSetOutputPresentationTimeStamp to explicitly set the value for CMSampleBufferGetOutputPresentationTimeStamp to return. For general forward playback in a scaled edit, the OutputPresentationTimeStamp should be set to: ((PresentationTimeStamp + TrimDurationAtStart - EditStartMediaTime) / EditSpeedMultiplier) + EditStartTrackTime. For general reversed playback: ((PresentationTimeStamp + Duration - TrimDurationAtEnd - EditStartMediaTime) / EditSpeedMultiplier) + EditStartTrackTime.

      • CMSampleBufferGetOutputDecodeTimeStamp

        public static CMTime CMSampleBufferGetOutputDecodeTimeStamp​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferGetOutputDecodeTimeStamp Returns the output decode timestamp of the CMSampleBuffer. For consistency with CMSampleBufferGetOutputPresentationTimeStamp, this is calculated as: OutputPresentationTimeStamp + ((DecodeTimeStamp - PresentationTimeStamp) / SpeedMultiplier).
        Returns:
        CMInvalidTime is returned if there is an error.

      • CMSampleBufferGetSampleTimingInfoArray

        public static int CMSampleBufferGetSampleTimingInfoArray​(CMSampleBufferRef sbuf,
                                                         long numSampleTimingEntries,
                                                         CMSampleTimingInfo timingArrayOut,
                                                         org.moe.natj.general.ptr.NIntPtr timingArrayEntriesNeededOut)
        [@function] CMSampleBufferGetSampleTimingInfoArray Returns an array of CMSampleTimingInfo structs, one for each sample in a CMSampleBuffer. If only one CMSampleTimingInfo struct is returned, it applies to all samples in the buffer. See documentation of CMSampleTimingInfo for details of how a single CMSampleTimingInfo struct can apply to multiple samples. The timingArrayOut must be allocated by the caller, and the number of entries allocated must be passed in timingArrayEntries. If timingArrayOut is NULL, timingArrayEntriesNeededOut will return the required number of entries. Similarly, if timingArrayEntries is too small, kCMSampleBufferError_ArrayTooSmall will be returned, and timingArrayEntriesNeededOut will return the required number of entries. In either case, the caller can then make an appropriately-sized timingArrayOut and call again. For example, the caller might pass the address of a CMSampleTimingInfo struct on the stack (as timingArrayOut), and 1 (as timingArrayEntries). If all samples are describable with a single CMSampleTimingInfo struct (or there is only one sample in the CMSampleBuffer), this call will succeed. If not, it will fail, and will return the number of entries required in timingArrayEntriesNeededOut. Only in this case will the caller actually need to allocate an array. If there is no timingInfo in this CMSampleBuffer, kCMSampleBufferError_BufferHasNoSampleTimingInfo will be returned, and timingArrayEntriesNeededOut will be set to 0.

      • CMSampleBufferGetOutputSampleTimingInfoArray

        public static int CMSampleBufferGetOutputSampleTimingInfoArray​(CMSampleBufferRef sbuf,
                                                               long timingArrayEntries,
                                                               CMSampleTimingInfo timingArrayOut,
                                                               org.moe.natj.general.ptr.NIntPtr timingArrayEntriesNeededOut)
        [@function] CMSampleBufferGetOutputSampleTimingInfoArray Returns an array of output CMSampleTimingInfo structs, one for each sample in a CMSampleBuffer. If only one CMSampleTimingInfo struct is returned, it applies to all samples in the buffer. See documentation of CMSampleTimingInfo for details of how a single CMSampleTimingInfo struct can apply to multiple samples. The timingArrayOut must be allocated by the caller, and the number of entries allocated must be passed in timingArrayEntries. If timingArrayOut is NULL, timingArrayEntriesNeededOut will return the required number of entries. Similarly, if timingArrayEntries is too small, kCMSampleBufferError_ArrayTooSmall will be returned, and timingArrayEntriesNeededOut will return the required number of entries. In either case, the caller can then make an appropriately-sized timingArrayOut and call again. For example, the caller might pass the address of a CMSampleTimingInfo struct on the stack (as timingArrayOut), and 1 (as timingArrayEntries). If all samples are describable with a single CMSampleTimingInfo struct (or there is only one sample in the CMSampleBuffer), this call will succeed. If not, it will fail, and will return the number of entries required in timingArrayEntriesNeededOut. Only in this case will the caller actually need to allocate an array. If there is no timingInfo in this CMSampleBuffer, kCMSampleBufferError_BufferHasNoSampleTimingInfo will be returned, and *timingArrayEntriesNeededOut will be set to 0.

      • CMSampleBufferGetSampleTimingInfo

        public static int CMSampleBufferGetSampleTimingInfo​(CMSampleBufferRef sbuf,
                                                    long sampleIndex,
                                                    CMSampleTimingInfo timingInfoOut)
        [@function] CMSampleBufferGetSampleTimingInfo Returns a CMSampleTimingInfo struct describing a specified sample in a CMSampleBuffer. A sample-specific CMSampleTimingInfo struct will be returned (ie. with a sample-specific presentationTimeStamp and decodeTimeStamp), even if a single CMSampleTimingInfo struct was used during creation to describe all the samples in the buffer. The timingInfo struct must be allocated by the caller. If the sample index is not in the range 0 .. numSamples-1, kCMSampleBufferError_SampleIndexOutOfRange will be returned. If there is no timingInfo in this CMSampleBuffer, kCMSampleBufferError_BufferHasNoSampleTimingInfo will be returned.

      • CMSampleBufferGetSampleSizeArray

        public static int CMSampleBufferGetSampleSizeArray​(CMSampleBufferRef sbuf,
                                                   long sizeArrayEntries,
                                                   org.moe.natj.general.ptr.NUIntPtr sizeArrayOut,
                                                   org.moe.natj.general.ptr.NIntPtr sizeArrayEntriesNeededOut)
        [@function] CMSampleBufferGetSampleSizeArray Returns an array of sample sizes, one for each sample in a CMSampleBuffer. If only one size entry is returned, all samples in the buffer are of this size. The sizeArrayOut must be allocated by the caller, and the number of entries allocated must be passed in sizeArrayEntries. If sizeArrayOut is NULL, sizeArrayEntriesNeededOut will return the required number of entries. Similarly, if sizeArrayEntries is too small, kCMSampleBufferError_ArrayTooSmall will be returned, and sizeArrayEntriesNeededOut will return the required number of entries. The caller can then make an appropriately-sized sizeArrayOut and call again. For example, the caller might pass the address of a size_t variable on the stack (as sizeArrayOut), and 1 (as sizeArrayEntries). If all samples are the same size (or there is only one sample in the CMSampleBuffer), this call would succeed. If not, it will fail, and will return the number of entries required in sizeArrayEntriesNeededOut. Only in this case (multiple samples of different sizes) will the caller need to allocate an array. 0 entries will be returned if the samples in the buffer are non-contiguous (eg. non-interleaved audio, where the channel values for a single sample are scattered through the buffer). If there are no sample sizes in this CMSampleBuffer, kCMSampleBufferError_BufferHasNoSampleSizes will be returned, and *sizeArrayEntriesNeededOut will be set to 0. This will be true, for example, if the samples in the buffer are non-contiguous (eg. non-interleaved audio, where the channel values for a single sample are scattered through the buffer), or if this CMSampleBuffer contains a CVImageBuffer.

      • CMSampleBufferGetSampleSize

        public static long CMSampleBufferGetSampleSize​(CMSampleBufferRef sbuf,
                                               long sampleIndex)
        [@function] CMSampleBufferGetSampleSize Returns the size in bytes of a specified sample in a CMSampleBuffer.
        Returns:
        Size in bytes of the specified sample in the CMSampleBuffer. If the sample index is not in the range 0 .. numSamples-1, a size of 0 will be returned. If there are no sample sizes in this CMSampleBuffer, a size of 0 will be returned. This will be true, for example, if the samples in the buffer are non-contiguous (eg. non-interleaved audio, where the channel values for a single sample are scattered through the buffer), or if this CMSampleBuffer contains a CVImageBuffer.

      • CMSampleBufferGetTotalSampleSize

        public static long CMSampleBufferGetTotalSampleSize​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferGetTotalSampleSize Returns the total size in bytes of sample data in a CMSampleBuffer.
        Returns:
        Total size in bytes of sample data in the CMSampleBuffer. If there are no sample sizes in this CMSampleBuffer, a size of 0 will be returned.

      • CMSampleBufferGetFormatDescription

        public static CMFormatDescriptionRef CMSampleBufferGetFormatDescription​(CMSampleBufferRef sbuf)
        [@function] CMSampleBufferGetFormatDescription Returns the format description of the samples in a CMSampleBuffer. On return, the caller does not own the returned formatDesc, and must retain it explicitly if the caller needs to maintain a reference to it.
        Returns:
        The format description of the samples in the CMSampleBuffer. NULL is returned if there is an error.

      • CMSampleBufferGetSampleAttachmentsArray

        public static CFArrayRef CMSampleBufferGetSampleAttachmentsArray​(CMSampleBufferRef sbuf,
                                                                 byte createIfNecessary)
        [@function] CMSampleBufferGetSampleAttachmentsArray Returns a reference to a CMSampleBuffer's immutable array of mutable sample attachments dictionaries (one dictionary per sample in the CMSampleBuffer). Attachments can then be added/removed directly by the caller, using CF APIs. On return, the caller does not own the returned array of attachments dictionaries, and must retain it if the caller needs to maintain a reference to it. If there are no sample attachments yet, and createIfNecessary is true, a new CFArray containing N empty CFMutableDictionaries is returned (where N is the number of samples in the CMSampleBuffer), so that attachments can be added directly by the caller. If there are no sample attachments yet, and createIfNecessary is false, NULL is returned. Once the CFArray has been created, subsequent calls will return it, even if there are still no sample attachments in the array.
        Returns:
        A reference to the CMSampleBuffer's immutable array of mutable sample attachments dictionaries (one dictionary per sample in the CMSampleBuffer). NULL is returned if there is an error.

      • CMSampleBufferCallForEachSample

        public static int CMSampleBufferCallForEachSample​(CMSampleBufferRef sbuf,
                                                  CoreMedia.Function_CMSampleBufferCallForEachSample callback,
                                                  org.moe.natj.general.ptr.VoidPtr refcon)
        [@function] CMSampleBufferCallForEachSample Calls a function for every individual sample in a sample buffer. Temporary sample buffers will be created for individual samples, referring to the sample data and containing its timing, size and attachments. The callback function may retain these sample buffers if desired. If the callback function returns an error, iteration will stop immediately and the error will be returned. If there are no sample sizes in the provided sample buffer, kCMSampleBufferError_CannotSubdivide will be returned. This will happen, for example, if the samples in the buffer are non-contiguous (eg. non-interleaved audio, where the channel values for a single sample are scattered through the buffer).

      • CMSampleBufferCallBlockForEachSample

        public static int CMSampleBufferCallBlockForEachSample​(CMSampleBufferRef sbuf,
                                                       CoreMedia.Block_CMSampleBufferCallBlockForEachSample handler)
        [@function] CMSampleBufferCallBlockForEachSample Calls a block for every individual sample in a sample buffer. Temporary sample buffers will be created for individual samples, referring to the sample data and containing its timing, size and attachments. The block may retain these sample buffers if desired. If the block returns an error, iteration will stop immediately and the error will be returned. If there are no sample sizes in the provided sample buffer, kCMSampleBufferError_CannotSubdivide will be returned. This will happen, for example, if the samples in the buffer are non-contiguous (eg. non-interleaved audio, where the channel values for a single sample are scattered through the buffer).

      • CMClockGetTypeID

        public static long CMClockGetTypeID()
        [@function] CMClockGetTypeID Returns the CFTypeID for CMClock.

      • CMClockGetHostTimeClock

        public static CMClockRef CMClockGetHostTimeClock()
        [@function] CMClockGetHostTimeClock Returns a reference to the singleton clock logically identified with host time. On Mac OS X, the host time clock uses mach_absolute_time but returns a value with a large integer timescale (eg, nanoseconds).

      • CMClockConvertHostTimeToSystemUnits

        public static long CMClockConvertHostTimeToSystemUnits​(CMTime hostTime)
        [@function] CMClockConvertHostTimeToSystemUnits Converts a host time from CMTime to the host time's native units. This function performs a scale conversion, not a clock conversion. It can be more accurate than CMTimeConvertScale because the system units may have a non-integer timescale. On Mac OS X, this function converts to the units of mach_absolute_time.

      • CMClockMakeHostTimeFromSystemUnits

        public static CMTime CMClockMakeHostTimeFromSystemUnits​(long hostTime)
        [@function] CMClockMakeHostTimeFromSystemUnits Converts a host time from native units to CMTime. The returned value will have a large integer timescale (eg, nanoseconds). This function handles situations where host time's native units use a non-integer timescale. On Mac OS X, this function converts from the units of mach_absolute_time.

      • CMClockGetTime

        public static CMTime CMClockGetTime​(CMClockRef clock)
        [@function] CMClockGetTime Retrieves the current time from a clock.

      • CMClockGetAnchorTime

        public static int CMClockGetAnchorTime​(CMClockRef clock,
                                       CMTime clockTimeOut,
                                       CMTime referenceClockTimeOut)
        [@function] CMClockGetAnchorTime Retrieves the current time from a clock and also the matching time from the clock's reference clock. To make practical use of this, you may need to know what the clock's reference clock is.

      • CMClockMightDrift

        public static byte CMClockMightDrift​(CMClockRef clock,
                                     CMClockRef otherClock)
        [@function] CMClockMightDrift Indicates whether it is possible for two clocks to drift relative to each other.

      • CMClockInvalidate

        public static void CMClockInvalidate​(CMClockRef clock)
        [@function] CMClockInvalidate Makes the clock stop functioning. After invalidation, the clock will return errors from all APIs. This should only be called by the "owner" of the clock, who knows (for example) that some piece of hardware has gone away, and the clock will no longer work (and might even crash).

      • CMTimebaseGetTypeID

        public static long CMTimebaseGetTypeID()
        [@function] CMTimebaseGetTypeID Returns the CFTypeID for CMTimebase.

      • CMTimebaseCreateWithMasterClock

        public static int CMTimebaseCreateWithMasterClock​(CFAllocatorRef allocator,
                                                  CMClockRef masterClock,
                                                  org.moe.natj.general.ptr.Ptr<CMTimebaseRef> timebaseOut)
        [@function] CMTimebaseCreateWithMasterClock Creates a timebase driven by the given clock. The timebase will initially have rate zero and time zero. Pass CMClockGetHostTimeClock() for masterClock to have the host time clock drive this timebase.

      • CMTimebaseCreateWithMasterTimebase

        public static int CMTimebaseCreateWithMasterTimebase​(CFAllocatorRef allocator,
                                                     CMTimebaseRef masterTimebase,
                                                     org.moe.natj.general.ptr.Ptr<CMTimebaseRef> timebaseOut)
        [@function] CMTimebaseCreateWithMasterTimebase Creates a timebase driven by the given master timebase. The timebase will initially have rate zero and time zero.

      • CMTimebaseCopyMasterTimebase

        public static CMTimebaseRef CMTimebaseCopyMasterTimebase​(CMTimebaseRef timebase)
        [@function] CMTimebaseCopyMasterTimebase Returns the immediate master timebase of a timebase. Returns NULL if the timebase actually has a master clock instead of a master timebase.

      • CMTimebaseCopyMasterClock

        public static CMClockRef CMTimebaseCopyMasterClock​(CMTimebaseRef timebase)
        [@function] CMTimebaseCopyMasterClock Returns the immediate master clock of a timebase. Returns NULL if the timebase actually has a master timebase instead of a master clock.

      • CMTimebaseCopyMaster

        public static org.moe.natj.general.ptr.ConstVoidPtr CMTimebaseCopyMaster​(CMTimebaseRef timebase)
        [@function] CMTimebaseCopyMaster Returns the immediate master (either timebase or clock) of a timebase. Only returns NULL if there was an error (such as timebase == NULL).

      • CMTimebaseCopyUltimateMasterClock

        public static CMClockRef CMTimebaseCopyUltimateMasterClock​(CMTimebaseRef timebase)
        [@function] CMTimebaseCopyUltimateMasterClock Returns the master clock that is the master of all of a timebase's master timebases.

      • CMTimebaseGetMasterTimebase

        @Deprecated
public static CMTimebaseRef CMTimebaseGetMasterTimebase​(CMTimebaseRef timebase)
        Deprecated.
        [@function] CMTimebaseGetMasterTimebase Returns the immediate master timebase of a timebase. Returns NULL if the timebase actually has a master clock instead of a master timebase. Please use CMTimebaseCopyMasterTimebase instead.

      • CMTimebaseGetMasterClock

        @Deprecated
public static CMClockRef CMTimebaseGetMasterClock​(CMTimebaseRef timebase)
        Deprecated.
        [@function] CMTimebaseGetMasterClock Returns the immediate master clock of a timebase. Returns NULL if the timebase actually has a master timebase instead of a master clock. Please use CMTimebaseCopyMasterClock instead.

      • CMTimebaseGetMaster

        @Deprecated
public static org.moe.natj.general.ptr.ConstVoidPtr CMTimebaseGetMaster​(CMTimebaseRef timebase)
        Deprecated.
        [@function] CMTimebaseGetMaster Returns the immediate master (either timebase or clock) of a timebase. Only returns NULL if there was an error (such as timebase == NULL). Example of use: time = CMSyncGetTime(CMTimebaseGetMaster(timebase)); Please use CMTimebaseCopyMaster instead.

      • CMTimebaseGetUltimateMasterClock

        @Deprecated
public static CMClockRef CMTimebaseGetUltimateMasterClock​(CMTimebaseRef timebase)
        Deprecated.
        [@function] CMTimebaseGetUltimateMasterClock Returns the master clock that is the master of all of a timebase's master timebases. Please use CMTimebaseCopyUltimateMasterClock instead.

      • CMTimebaseGetTime

        public static CMTime CMTimebaseGetTime​(CMTimebaseRef timebase)
        [@function] CMTimebaseGetTime Retrieves the current time from a timebase.

      • CMTimebaseGetTimeWithTimeScale

        public static CMTime CMTimebaseGetTimeWithTimeScale​(CMTimebaseRef timebase,
                                                    int timescale,
                                                    int method)
        [@function] CMTimebaseGetTimeWithTimeScale Retrieves the current time from a timebase in the specified timescale.

      • CMTimebaseSetTime

        public static int CMTimebaseSetTime​(CMTimebaseRef timebase,
                                    CMTime time)
        [@function] CMTimebaseSetTime Sets the current time of a timebase.

      • CMTimebaseSetAnchorTime

        public static int CMTimebaseSetAnchorTime​(CMTimebaseRef timebase,
                                          CMTime timebaseTime,
                                          CMTime immediateMasterTime)
        [@function] CMTimebaseSetAnchorTime Sets the time of a timebase at a particular master time. CMTimebaseGetTime's results will be interpolated from that anchor time. CMTimebaseSetTime(timebase, time) is equivalent to calling CMClockOrTimebaseRef master = CMTimebaseCopyMaster(timebase); CMTimebaseSetAnchorTime(timebase, time, CMSyncGetTime(master)); CFRelease(master).

      • CMTimebaseGetRate

        public static double CMTimebaseGetRate​(CMTimebaseRef timebase)
        [@function] CMTimebaseGetRate Retrieves the current rate of a timebase. This is the rate relative to its immediate master clock or timebase. For example, if a timebase is running at twice the rate of its master, its rate is 2.0.

      • CMTimebaseGetTimeAndRate

        public static int CMTimebaseGetTimeAndRate​(CMTimebaseRef timebase,
                                           CMTime timeOut,
                                           org.moe.natj.general.ptr.DoublePtr rateOut)
        [@function] CMTimebaseGetTimeAndRate Retrieves the current time and rate of a timebase. You can use this function to take a consistent snapshot of the two values, avoiding possible inconsistencies due to external changes between retrieval of time and rate.

      • CMTimebaseSetRate

        public static int CMTimebaseSetRate​(CMTimebaseRef timebase,
                                    double rate)
        [@function] CMTimebaseSetRate Sets the rate of a timebase.

      • CMTimebaseSetRateAndAnchorTime

        public static int CMTimebaseSetRateAndAnchorTime​(CMTimebaseRef timebase,
                                                 double rate,
                                                 CMTime timebaseTime,
                                                 CMTime immediateMasterTime)
        [@function] CMTimebaseSetRateAndAnchorTime Sets the time of a timebase at a particular master time, and changes the rate at exactly that time. CMTimebaseGetTime's results will be interpolated from that anchor time as though the timebase has been running at the requested rate since that time. CMTimebaseSetRate(timebase, rate) is approximately equivalent to calling CMClockOrTimebaseRef master = CMTimebaseCopyMaster(timebase); CMTimebaseSetRateAndAnchorTime(timebase, rate, CMTimebaseGetTime(timebase), CMSyncGetTime(master)), CFRelease(master); except that CMTimebaseSetRate will not generate a TimeJumped notification, and CMTimebaseSetRateAndAnchorTime will.

      • CMTimebaseGetEffectiveRate

        public static double CMTimebaseGetEffectiveRate​(CMTimebaseRef timebase)
        [@function] CMTimebaseGetEffectiveRate Gets the effective rate of a timebase (which combines its rate with the rates of all its master timebases). Calling CMTimebaseGetEffectiveRate(timebase) is equivalent to calling CMClockRef clock = CMTimebaseCopyUltimateMasterClock(timebase); CMSyncGetRelativeRate(timebase, clock). CFRelease(clock);

      • CMTimebaseAddTimer

        public static int CMTimebaseAddTimer​(CMTimebaseRef timebase,
                                     CFRunLoopTimerRef timer,
                                     CFRunLoopRef runloop)
        [@function] CMTimebaseAddTimer Adds the timer to the list of timers managed by the timebase. The timer must be a repeating run loop timer (with a very long interval at least as long as kCMTimebaseVeryLongCFTimeInterval), attached to a runloop. The timebase will retain the timer, and will maintain its "NextFireDate" according to the CMTime set using CMTimebaseSetTimerNextFireTime. Until the first call to CMTimebaseSetTimerNextFireTime, the "NextFireDate" will be set far, far in the future. The runloop that timer is attached to must be passed in and the timebase will retain that runloop. The retained runloop will be used to call CFRunLoopWakeUp() any time the timebase modifies the timer's fire date.

      • CMTimebaseRemoveTimer

        public static int CMTimebaseRemoveTimer​(CMTimebaseRef timebase,
                                        CFRunLoopTimerRef timer)
        [@function] CMTimebaseRemoveTimer Removes the timer from the list of timers managed by the timebase. The timebase will no longer maintain the timer's "NextFireDate". If the timer is invalidated, the timebase will eventually remove it from its list and release it even if this function is not called.

      • CMTimebaseSetTimerNextFireTime

        public static int CMTimebaseSetTimerNextFireTime​(CMTimebaseRef timebase,
                                                 CFRunLoopTimerRef timer,
                                                 CMTime fireTime,
                                                 int flags)
        [@function] CMTimebaseSetTimerNextFireTime Sets the CMTime on the timebase's timeline at which the timer should next be fired. The timer must be on the list of timers managed by the timebase. The timebase will continue to update the timer's "NextFireDate" according to time jumps and effective rate changes. If fireTime is not numeric, or if the timebase is not moving, the "NextFireDate" will be set to a date far, far in the future.
        IMPORTANT NOTE: Due to the way that CFRunLoopTimers are implemented, if a timer passes through a state in which it is due to fire, it may fire even if its rescheduled before the runloop runs again. Clients should take care to avoid temporarily scheduling timers in the past. For example, set the timebase's rate or time before you set the timer's next fire time, if you are doing both at once. (If setting the timebase's rate or time might put the timer's fire time in the past, you may need to set the fire time to kCMTimeInvalid across the timebase change.)

      • CMTimebaseSetTimerToFireImmediately

        public static int CMTimebaseSetTimerToFireImmediately​(CMTimebaseRef timebase,
                                                      CFRunLoopTimerRef timer)
        [@function] CMTimebaseSetTimerToFireImmediately Sets the timer to fire immediately once, overriding any previous CMTimebaseSetTimerNextFireTime call. The timer must be on the list of timers managed by the timebase. This is equivalent to calling CFRunLoopTimerSetNextFireDate( timer, CFAbsoluteTimeGetCurrent() ); except that the timebase gets to know that it shouldn't interfere.

      • CMTimebaseAddTimerDispatchSource

        public static int CMTimebaseAddTimerDispatchSource​(CMTimebaseRef timebase,
                                                   NSObject timerSource)
        [@function] CMTimebaseAddTimerDispatchSource Adds the timer dispatch source to the list of timers managed by the timebase. The timer source must have been created by calling dispatch_source_create( DISPATCH_SOURCE_TYPE_TIMER, 0, 0, some_dispatch_queue ) and should have had an event handler associated with it via dispatch_source_set_event_handler( timerSource, some_handler_block ) or dispatch_source_set_event_handler_f( timerSource, some_handler_function ). Don't forget to call dispatch_resume( timerSource ) as dispatch sources are created suspended. The timebase will retain the timer source, and will maintain its start time according to the CMTime set using CMTimebaseSetTimerDispatchSourceNextFireTime. Until the first call to CMTimebaseSetTimerDispatchSourceNextFireTime, the start time will be set to DISPATCH_TIME_FOREVER.

      • CMTimebaseRemoveTimerDispatchSource

        public static int CMTimebaseRemoveTimerDispatchSource​(CMTimebaseRef timebase,
                                                      NSObject timerSource)
        [@function] CMTimebaseRemoveTimerDispatchSource Removes the timer dispatch source from the list of timers managed by the timebase. The timebase will no longer maintain the timer source's start time. If the timer source is cancelled, the timebase will eventually remove it from its list and release it even if this function is not called.

      • CMTimebaseSetTimerDispatchSourceNextFireTime

        public static int CMTimebaseSetTimerDispatchSourceNextFireTime​(CMTimebaseRef timebase,
                                                               NSObject timerSource,
                                                               CMTime fireTime,
                                                               int flags)
        [@function] CMTimebaseSetTimerDispatchSourceNextFireTime Sets the CMTime on the timebase's timeline at which the timer dispatch source should next be fired. The timer source must be on the list of timers managed by the timebase. The timebase will continue to update the timer dispatch source's start time according to time jumps and effective rate changes. If fireTime is not numeric, or if the timebase is not moving, the start time will be set to DISPATCH_TIME_FOREVER.
        IMPORTANT NOTE: Due to the way that timer dispatch sources are implemented, if a timer passes through a state in which it is due to fire, it may fire even if its rescheduled before the event handler is run. Clients should take care to avoid temporarily scheduling timers in the past. For example, set the timebase's rate or time before you set the timer's next fire time, if you are doing both at once. (If setting the timebase's rate or time might put the timer's fire time in the past, you may need to set the fire time to kCMTimeInvalid across the timebase change.)

      • CMTimebaseSetTimerDispatchSourceToFireImmediately

        public static int CMTimebaseSetTimerDispatchSourceToFireImmediately​(CMTimebaseRef timebase,
                                                                    NSObject timerSource)
        [@function] CMTimebaseSetTimerDispatchSourceToFireImmediately Sets the timer dispatch source to fire immediately once, overriding any previous CMTimebaseSetTimerDispatchSourceNextFireTime call. The timer source must be on the list of timers managed by the timebase. This is equivalent to calling dispatch_source_set_timer( timerSource, DISPATCH_TIME_NOW, 0, 0 ); except that the timebase gets to know that it shouldn't interfere.

      • CMSyncGetRelativeRate

        public static double CMSyncGetRelativeRate​(org.moe.natj.general.ptr.ConstVoidPtr ofClockOrTimebase,
                                           org.moe.natj.general.ptr.ConstVoidPtr relativeToClockOrTimebase)
        [@function] CMSyncGetRelativeRate Queries the relative rate of one timebase or clock relative to another timebase or clock. If both have a common master, this calculation is performed purely based on the rates in the common tree rooted in that master. If they have different master clocks (or are both clocks), this calculation takes into account the measured drift between the two clocks, using host time as a pivot. The rate of a moving timebase relative to a stopped timebase is a NaN. Calling CMTimebaseGetEffectiveRate(timebase) is equivalent to calling CMClockRef clock = CMTimebaseCopyUltimateMasterClock(timebase); CMSyncGetRelativeRate(timebase, clock). CFRelease(clock);

      • CMSyncGetRelativeRateAndAnchorTime

        public static int CMSyncGetRelativeRateAndAnchorTime​(org.moe.natj.general.ptr.ConstVoidPtr ofClockOrTimebase,
                                                     org.moe.natj.general.ptr.ConstVoidPtr relativeToClockOrTimebase,
                                                     org.moe.natj.general.ptr.DoublePtr outRelativeRate,
                                                     CMTime outOfClockOrTimebaseAnchorTime,
                                                     CMTime outRelativeToClockOrTimebaseAnchorTime)
        [@function] CMSyncGetRelativeRateAndAnchorTime Queries the relative rate of one timebase or clock relative to another timebase or clock and the times of each timebase or clock at which the relative rate went into effect. If both have a common master, this calculation is performed purely based on the rates in the common tree rooted in that master. If they have different master clocks (or are both clocks), this calculation takes into account the measured drift between the two clocks, using host time as a pivot. The rate of a moving timebase relative to a stopped timebase is a NaN.

      • CMSyncConvertTime

        public static CMTime CMSyncConvertTime​(CMTime time,
                                       org.moe.natj.general.ptr.ConstVoidPtr fromClockOrTimebase,
                                       org.moe.natj.general.ptr.ConstVoidPtr toClockOrTimebase)
        [@function] CMSyncConvertTime Converts a time from one timebase or clock to another timebase or clock. If both have a common master, this calculation is performed purely based on the mathematical rates and offsets in the common tree rooted in that master. If they have different master clocks (or are both clocks), this calculation also compensates for measured drift between the clocks. To convert to or from host time, pass CMClockGetHostTimeClock() as the appropriate argument.

      • CMSyncMightDrift

        public static byte CMSyncMightDrift​(org.moe.natj.general.ptr.ConstVoidPtr clockOrTimebase1,
                                    org.moe.natj.general.ptr.ConstVoidPtr clockOrTimebase2)
        [@function] CMSyncMightDrift Reports whether it is possible for one timebase/clock to drift relative to the other. A timebase can drift relative to another if they are ultimately mastered by clocks that can drift relative to each other.

      • CMSyncGetTime

        public static CMTime CMSyncGetTime​(org.moe.natj.general.ptr.ConstVoidPtr clockOrTimebase)
        [@function] CMSyncGetTime A helper function to get time from a clock or timebase. CMSyncGetTime simply calls either CMClockGetTime or CMTimebaseGetTime, as appropriate. It comes in handy for things like: CMClockOrTimebaseRef master = CMTimebaseCopyMaster(timebase); CMSyncGetTime(master); CFRelease(master);

      • CMTimebaseNotificationBarrier

        public static int CMTimebaseNotificationBarrier​(CMTimebaseRef timebase)
        [@function] CMTimebaseNotificationBarrier Requests that the timebase wait until it is not posting any notifications.

      • CMVideoFormatDescriptionCreateFromBigEndianImageDescriptionData

        public static int CMVideoFormatDescriptionCreateFromBigEndianImageDescriptionData​(CFAllocatorRef allocator,
                                                                                  java.lang.String imageDescriptionData,
                                                                                  long size,
                                                                                  int stringEncoding,
                                                                                  CFStringRef flavor,
                                                                                  org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMVideoFormatDescriptionCreateFromBigEndianImageDescriptionData Creates a CMVideoFormatDescription from a big-endian ImageDescription data structure.
        Parameters:
        allocator - Allocator to use for allocating the CMVideoFormatDescription object. May be NULL.
        imageDescriptionData - ImageDescription data structure in big-endian byte ordering.
        size - Size of ImageDescription data structure.
        stringEncoding - Pass CFStringGetSystemEncoding() or GetApplicationTextEncoding().
        flavor - kCMImageDescriptionFlavor constant or NULL for QuickTimeMovie flavor.
        formatDescriptionOut - Receives new CMVideoFormatDescription.

      • CMVideoFormatDescriptionCreateFromBigEndianImageDescriptionBlockBuffer

        public static int CMVideoFormatDescriptionCreateFromBigEndianImageDescriptionBlockBuffer​(CFAllocatorRef allocator,
                                                                                         CMBlockBufferRef imageDescriptionBlockBuffer,
                                                                                         int stringEncoding,
                                                                                         CFStringRef flavor,
                                                                                         org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMVideoFormatDescriptionCreateFromBigEndianImageDescriptionBlockBuffer Creates a CMVideoFormatDescription from a big-endian ImageDescription data structure in a CMBlockBuffer.
        Parameters:
        allocator - Allocator to use for allocating the CMVideoFormatDescription object. May be NULL.
        imageDescriptionBlockBuffer - CMBlockBuffer containing ImageDescription data structure in big-endian byte ordering.
        stringEncoding - Pass CFStringGetSystemEncoding() or GetApplicationTextEncoding().
        flavor - kCMImageDescriptionFlavor constant or NULL for QuickTimeMovie flavor.
        formatDescriptionOut - Receives new CMVideoFormatDescription.

      • CMVideoFormatDescriptionCopyAsBigEndianImageDescriptionBlockBuffer

        public static int CMVideoFormatDescriptionCopyAsBigEndianImageDescriptionBlockBuffer​(CFAllocatorRef allocator,
                                                                                     CMFormatDescriptionRef videoFormatDescription,
                                                                                     int stringEncoding,
                                                                                     CFStringRef flavor,
                                                                                     org.moe.natj.general.ptr.Ptr<CMBlockBufferRef> blockBufferOut)
        [@function] CMVideoFormatDescriptionCopyAsBigEndianImageDescriptionBlockBuffer Copies the contents of a CMVideoFormatDescription to a CMBlockBuffer in big-endian byte ordering. On return, the caller owns the returned CMBlockBuffer, and must release it when done with it. Note that the dataRefIndex field of the SampleDescription is intentionally filled with garbage values (0xFFFF). The caller must overwrite these values with a valid dataRefIndex if writing the SampleDescription to a QuickTime/ISO file.
        Parameters:
        allocator - Allocator to use for allocating the CMBlockBuffer object. May be NULL.
        videoFormatDescription - CMVideoFormatDescription to be copied.
        stringEncoding - Pass CFStringGetSystemEncoding() or GetApplicationTextEncoding().
        flavor - kCMImageDescriptionFlavor constant or NULL for QuickTimeMovie flavor.
        blockBufferOut - Receives new CMBlockBuffer containing ImageDescription data structure in big-endian byte ordering.

      • CMSwapBigEndianImageDescriptionToHost

        public static int CMSwapBigEndianImageDescriptionToHost​(org.moe.natj.general.ptr.BytePtr imageDescriptionData,
                                                        long imageDescriptionSize)
        [@function] CMSwapBigEndianImageDescriptionToHost Converts an ImageDescription data structure from big-endian to host-endian in place.
        Parameters:
        imageDescriptionData - ImageDescription data structure in big-endian byte ordering to be converted to host-endian byte ordering.
        imageDescriptionSize - Size of ImageDescription data structure.

      • CMSwapHostEndianImageDescriptionToBig

        public static int CMSwapHostEndianImageDescriptionToBig​(org.moe.natj.general.ptr.BytePtr imageDescriptionData,
                                                        long imageDescriptionSize)
        [@function] CMSwapHostEndianImageDescriptionToBig Converts an ImageDescription data structure from host-endian to big-endian in place.
        Parameters:
        imageDescriptionData - ImageDescription data structure in host-endian byte ordering to be converted to big-endian byte ordering.
        imageDescriptionSize - Size of ImageDescription data structure.

      • CMAudioFormatDescriptionCreateFromBigEndianSoundDescriptionData

        public static int CMAudioFormatDescriptionCreateFromBigEndianSoundDescriptionData​(CFAllocatorRef allocator,
                                                                                  java.lang.String soundDescriptionData,
                                                                                  long size,
                                                                                  CFStringRef flavor,
                                                                                  org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMAudioFormatDescriptionCreateFromBigEndianSoundDescriptionData Creates a CMAudioFormatDescription from a big-endian SoundDescription data structure.
        Parameters:
        allocator - Allocator to use for allocating the CMAudioFormatDescription object. May be NULL.
        soundDescriptionData - SoundDescription data structure in big-endian byte ordering.
        size - Size of SoundDescription data structure.
        flavor - kCMSoundDescriptionFlavor constant or NULL for QuickTimeMovie flavor.
        formatDescriptionOut - Receives new CMAudioFormatDescription.

      • CMAudioFormatDescriptionCreateFromBigEndianSoundDescriptionBlockBuffer

        public static int CMAudioFormatDescriptionCreateFromBigEndianSoundDescriptionBlockBuffer​(CFAllocatorRef allocator,
                                                                                         CMBlockBufferRef soundDescriptionBlockBuffer,
                                                                                         CFStringRef flavor,
                                                                                         org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMAudioFormatDescriptionCreateFromBigEndianSoundDescriptionBlockBuffer Creates a CMAudioFormatDescription from a big-endian SoundDescription data structure in a CMBlockBuffer.
        Parameters:
        allocator - Allocator to use for allocating the CMAudioFormatDescription object. May be NULL.
        soundDescriptionBlockBuffer - CMBlockBuffer containing SoundDescription data structure in big-endian byte ordering.
        flavor - kCMSoundDescriptionFlavor constant or NULL for QuickTimeMovie flavor.
        formatDescriptionOut - Receives new CMAudioFormatDescription.

      • CMAudioFormatDescriptionCopyAsBigEndianSoundDescriptionBlockBuffer

        public static int CMAudioFormatDescriptionCopyAsBigEndianSoundDescriptionBlockBuffer​(CFAllocatorRef allocator,
                                                                                     CMFormatDescriptionRef audioFormatDescription,
                                                                                     CFStringRef flavor,
                                                                                     org.moe.natj.general.ptr.Ptr<CMBlockBufferRef> blockBufferOut)
        [@function] CMAudioFormatDescriptionCopyAsBigEndianSoundDescriptionBlockBuffer Copies the contents of a CMAudioFormatDescription to a CMBlockBuffer in big-endian byte ordering. On return, the caller owns the returned CMBlockBuffer, and must release it when done with it. Note that the dataRefIndex field of the SampleDescription is intentionally filled with garbage values (0xFFFF). The caller must overwrite these values with a valid dataRefIndex if writing the SampleDescription to a QuickTime/ISO file.
        Parameters:
        allocator - Allocator to use for allocating the CMBlockBuffer object. May be NULL.
        audioFormatDescription - CMAudioFormatDescription to be copied.
        flavor - kCMSoundDescriptionFlavor constant or NULL for QuickTimeMovie flavor.
        blockBufferOut - Receives new CMBlockBuffer containing SoundDescription data structure in big-endian byte ordering.

      • CMDoesBigEndianSoundDescriptionRequireLegacyCBRSampleTableLayout

        public static byte CMDoesBigEndianSoundDescriptionRequireLegacyCBRSampleTableLayout​(CMBlockBufferRef soundDescriptionBlockBuffer,
                                                                                    CFStringRef flavor)
        [@function] CMDoesBigEndianSoundDescriptionRequireLegacyCBRSampleTableLayout Examine a big-endian SoundDescription data structure in a CMBlockBuffer, and report whether the sample tables will need to use the legacy CBR layout.
        Parameters:
        soundDescriptionBlockBuffer - CMBlockBuffer containing SoundDescription data structure in big-endian byte ordering.
        flavor - kCMSoundDescriptionFlavor constant or NULL for QuickTimeMovie flavor.

      • CMSwapBigEndianSoundDescriptionToHost

        public static int CMSwapBigEndianSoundDescriptionToHost​(org.moe.natj.general.ptr.BytePtr soundDescriptionData,
                                                        long soundDescriptionSize)
        [@function] CMSwapBigEndianSoundDescriptionToHost Converts a SoundDescription data structure from big-endian to host-endian in place.
        Parameters:
        soundDescriptionData - SoundDescription data structure in big-endian byte ordering to be converted to host-endian byte ordering.
        soundDescriptionSize - Size of SoundDescription data structure.

      • CMSwapHostEndianSoundDescriptionToBig

        public static int CMSwapHostEndianSoundDescriptionToBig​(org.moe.natj.general.ptr.BytePtr soundDescriptionData,
                                                        long soundDescriptionSize)
        [@function] CMSwapHostEndianSoundDescriptionToBig Converts a SoundDescription data structure from host-endian to big-endian in place.
        Parameters:
        soundDescriptionData - SoundDescription data structure in host-endian byte ordering to be converted to big-endian byte ordering.
        soundDescriptionSize - Size of SoundDescription data structure.

      • CMTextFormatDescriptionCreateFromBigEndianTextDescriptionData

        public static int CMTextFormatDescriptionCreateFromBigEndianTextDescriptionData​(CFAllocatorRef allocator,
                                                                                java.lang.String textDescriptionData,
                                                                                long size,
                                                                                CFStringRef flavor,
                                                                                int mediaType,
                                                                                org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMTextFormatDescriptionCreateFromBigEndianTextDescriptionData Creates a CMTextFormatDescription from a big-endian TextDescription data structure.
        Parameters:
        allocator - Allocator to use for allocating the CMTextFormatDescription object. May be NULL.
        textDescriptionData - TextDescription data structure in big-endian byte ordering.
        size - Size of TextDescription data structure.
        flavor - Reserved for future use. Pass NULL for QuickTime Movie or ISO flavor.
        mediaType - Pass kCMMediaType_Text or kCMMediaType_Subtitle.
        formatDescriptionOut - Receives new CMTextFormatDescription.

      • CMTextFormatDescriptionCreateFromBigEndianTextDescriptionBlockBuffer

        public static int CMTextFormatDescriptionCreateFromBigEndianTextDescriptionBlockBuffer​(CFAllocatorRef allocator,
                                                                                       CMBlockBufferRef textDescriptionBlockBuffer,
                                                                                       CFStringRef flavor,
                                                                                       int mediaType,
                                                                                       org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMTextFormatDescriptionCreateFromBigEndianTextDescriptionBlockBuffer Creates a CMTextFormatDescription from a big-endian TextDescription data structure in a CMBlockBuffer.
        Parameters:
        allocator - Allocator to use for allocating the CMTextFormatDescription object. May be NULL.
        textDescriptionBlockBuffer - CMBlockBuffer containing TextDescription data structure in big-endian byte ordering.
        flavor - Reserved for future use. Pass NULL for QuickTime Movie or ISO flavor.
        mediaType - Pass kCMMediaType_Text or kCMMediaType_Subtitle.
        formatDescriptionOut - Receives new CMTextFormatDescription.

      • CMTextFormatDescriptionCopyAsBigEndianTextDescriptionBlockBuffer

        public static int CMTextFormatDescriptionCopyAsBigEndianTextDescriptionBlockBuffer​(CFAllocatorRef allocator,
                                                                                   CMFormatDescriptionRef textFormatDescription,
                                                                                   CFStringRef flavor,
                                                                                   org.moe.natj.general.ptr.Ptr<CMBlockBufferRef> blockBufferOut)
        [@function] CMTextFormatDescriptionCopyAsBigEndianTextDescriptionBlockBuffer Copies the contents of a CMTextFormatDescription to a CMBlockBuffer in big-endian byte ordering. On return, the caller owns the returned CMBlockBuffer, and must release it when done with it. Note that the dataRefIndex field of the SampleDescription is intentionally filled with garbage values (0xFFFF). The caller must overwrite these values with a valid dataRefIndex if writing the SampleDescription to a QuickTime/ISO file.
        Parameters:
        allocator - Allocator to use for allocating the CMBlockBuffer object. May be NULL.
        textFormatDescription - CMTextFormatDescription to be copied.
        flavor - Reserved for future use. Pass NULL for QuickTime Movie or ISO flavor.
        blockBufferOut - Receives new CMBlockBuffer containing TextDescription data structure in big-endian byte ordering.

      • CMSwapBigEndianTextDescriptionToHost

        public static int CMSwapBigEndianTextDescriptionToHost​(org.moe.natj.general.ptr.BytePtr textDescriptionData,
                                                       long textDescriptionSize)
        [@function] CMSwapBigEndianTextDescriptionToHost Converts a TextDescription data structure from big-endian to host-endian in place.
        Parameters:
        textDescriptionData - TextDescription data structure in big-endian byte ordering to be converted to host-endian byte ordering.
        textDescriptionSize - Size of TextDescription data structure.

      • CMSwapHostEndianTextDescriptionToBig

        public static int CMSwapHostEndianTextDescriptionToBig​(org.moe.natj.general.ptr.BytePtr textDescriptionData,
                                                       long textDescriptionSize)
        [@function] CMSwapHostEndianTextDescriptionToBig Converts a TextDescription data structure from host-endian to big-endian in place.
        Parameters:
        textDescriptionData - TextDescription data structure in host-endian byte ordering to be converted to big-endian byte ordering.
        textDescriptionSize - Size of TextDescription data structure.

      • CMClosedCaptionFormatDescriptionCreateFromBigEndianClosedCaptionDescriptionData

        public static int CMClosedCaptionFormatDescriptionCreateFromBigEndianClosedCaptionDescriptionData​(CFAllocatorRef allocator,
                                                                                                  java.lang.String closedCaptionDescriptionData,
                                                                                                  long size,
                                                                                                  CFStringRef flavor,
                                                                                                  org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMClosedCaptionFormatDescriptionCreateFromBigEndianClosedCaptionDescriptionData Creates a CMClosedCaptionFormatDescription from a big-endian ClosedCaptionDescription data structure.
        Parameters:
        allocator - Allocator to use for allocating the CMClosedCaptionFormatDescription object. May be NULL.
        closedCaptionDescriptionData - ClosedCaptionDescription data structure in big-endian byte ordering.
        size - Size of ClosedCaptionDescription data structure.
        flavor - Reserved for future use. Pass NULL for QuickTime Movie or ISO flavor.
        formatDescriptionOut - Receives new CMClosedCaptionFormatDescription.

      • CMClosedCaptionFormatDescriptionCreateFromBigEndianClosedCaptionDescriptionBlockBuffer

        public static int CMClosedCaptionFormatDescriptionCreateFromBigEndianClosedCaptionDescriptionBlockBuffer​(CFAllocatorRef allocator,
                                                                                                         CMBlockBufferRef closedCaptionDescriptionBlockBuffer,
                                                                                                         CFStringRef flavor,
                                                                                                         org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMClosedCaptionFormatDescriptionCreateFromBigEndianClosedCaptionDescriptionBlockBuffer Creates a CMClosedCaptionFormatDescription from a big-endian ClosedCaptionDescription data structure in a CMBlockBuffer.
        Parameters:
        allocator - Allocator to use for allocating the CMClosedCaptionFormatDescription object. May be NULL.
        closedCaptionDescriptionBlockBuffer - CMBlockBuffer containing ClosedCaptionDescription data structure in big-endian byte ordering.
        flavor - Reserved for future use. Pass NULL for QuickTime Movie or ISO flavor.
        formatDescriptionOut - Receives new CMClosedCaptionFormatDescription.

      • CMClosedCaptionFormatDescriptionCopyAsBigEndianClosedCaptionDescriptionBlockBuffer

        public static int CMClosedCaptionFormatDescriptionCopyAsBigEndianClosedCaptionDescriptionBlockBuffer​(CFAllocatorRef allocator,
                                                                                                     CMFormatDescriptionRef closedCaptionFormatDescription,
                                                                                                     CFStringRef flavor,
                                                                                                     org.moe.natj.general.ptr.Ptr<CMBlockBufferRef> blockBufferOut)
        [@function] CMClosedCaptionFormatDescriptionCopyAsBigEndianClosedCaptionDescriptionBlockBuffer Copies the contents of a CMClosedCaptionFormatDescription to a CMBlockBuffer in big-endian byte ordering. On return, the caller owns the returned CMBlockBuffer, and must release it when done with it. Note that the dataRefIndex field of the SampleDescription is intentionally filled with garbage values (0xFFFF). The caller must overwrite these values with a valid dataRefIndex if writing the SampleDescription to a QuickTime/ISO file.
        Parameters:
        allocator - Allocator to use for allocating the CMBlockBuffer object. May be NULL.
        closedCaptionFormatDescription - CMClosedCaptionFormatDescription to be copied.
        flavor - Reserved for future use. Pass NULL for QuickTime Movie or ISO flavor.
        blockBufferOut - Receives new CMBlockBuffer containing ClosedCaptionDescription data structure in big-endian byte ordering.

      • CMSwapBigEndianClosedCaptionDescriptionToHost

        public static int CMSwapBigEndianClosedCaptionDescriptionToHost​(org.moe.natj.general.ptr.BytePtr closedCaptionDescriptionData,
                                                                long closedCaptionDescriptionSize)
        [@function] CMSwapBigEndianClosedCaptionDescriptionToHost Converts a ClosedCaptionDescription data structure from big-endian to host-endian in place.
        Parameters:
        closedCaptionDescriptionData - ClosedCaptionDescription data structure in big-endian byte ordering to be converted to host-endian byte ordering.
        closedCaptionDescriptionSize - Size of ClosedCaptionDescription data structure.

      • CMSwapHostEndianClosedCaptionDescriptionToBig

        public static int CMSwapHostEndianClosedCaptionDescriptionToBig​(org.moe.natj.general.ptr.BytePtr closedCaptionDescriptionData,
                                                                long closedCaptionDescriptionSize)
        [@function] CMSwapHostEndianClosedCaptionDescriptionToBig Converts a ClosedCaptionDescription data structure from host-endian to big-endian in place.
        Parameters:
        closedCaptionDescriptionData - ClosedCaptionDescription data structure in host-endian byte ordering to be converted to big-endian byte ordering.
        closedCaptionDescriptionSize - Size of ClosedCaptionDescription data structure.

      • CMTimeCodeFormatDescriptionCreateFromBigEndianTimeCodeDescriptionData

        public static int CMTimeCodeFormatDescriptionCreateFromBigEndianTimeCodeDescriptionData​(CFAllocatorRef allocator,
                                                                                        java.lang.String timeCodeDescriptionData,
                                                                                        long size,
                                                                                        CFStringRef flavor,
                                                                                        org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMTimeCodeFormatDescriptionCreateFromBigEndianTimeCodeDescriptionData Creates a CMTimeCodeFormatDescription from a big-endian TimeCodeDescription data structure.
        Parameters:
        allocator - Allocator to use for allocating the CMTimeCodeFormatDescription object. May be NULL.
        timeCodeDescriptionData - TimeCodeDescription data structure in big-endian byte ordering.
        size - Size of TimeCodeDescription data structure.
        flavor - Reserved for future use. Pass NULL for QuickTime Movie or ISO flavor.
        formatDescriptionOut - Receives new CMTimeCodeFormatDescription.

      • CMTimeCodeFormatDescriptionCreateFromBigEndianTimeCodeDescriptionBlockBuffer

        public static int CMTimeCodeFormatDescriptionCreateFromBigEndianTimeCodeDescriptionBlockBuffer​(CFAllocatorRef allocator,
                                                                                               CMBlockBufferRef timeCodeDescriptionBlockBuffer,
                                                                                               CFStringRef flavor,
                                                                                               org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMTimeCodeFormatDescriptionCreateFromBigEndianTimeCodeDescriptionBlockBuffer Creates a CMTimeCodeFormatDescription from a big-endian TimeCodeDescription data structure in a CMBlockBuffer.
        Parameters:
        allocator - Allocator to use for allocating the CMTimeCodeFormatDescription object. May be NULL.
        timeCodeDescriptionBlockBuffer - CMBlockBuffer containing TimeCodeDescription data structure in big-endian byte ordering.
        flavor - Reserved for future use. Pass NULL for QuickTime Movie or ISO flavor.
        formatDescriptionOut - Receives new CMTimeCodeFormatDescription.

      • CMTimeCodeFormatDescriptionCopyAsBigEndianTimeCodeDescriptionBlockBuffer

        public static int CMTimeCodeFormatDescriptionCopyAsBigEndianTimeCodeDescriptionBlockBuffer​(CFAllocatorRef allocator,
                                                                                           CMFormatDescriptionRef timeCodeFormatDescription,
                                                                                           CFStringRef flavor,
                                                                                           org.moe.natj.general.ptr.Ptr<CMBlockBufferRef> blockBufferOut)
        [@function] CMTimeCodeFormatDescriptionCopyAsBigEndianTimeCodeDescriptionBlockBuffer Copies the contents of a CMTimeCodeFormatDescription to a CMBlockBuffer in big-endian byte ordering. On return, the caller owns the returned CMBlockBuffer, and must release it when done with it. Note that the dataRefIndex field of the SampleDescription is intentionally filled with garbage values (0xFFFF). The caller must overwrite these values with a valid dataRefIndex if writing the SampleDescription to a QuickTime/ISO file.
        Parameters:
        allocator - Allocator to use for allocating the CMBlockBuffer object. May be NULL.
        timeCodeFormatDescription - CMTimeCodeFormatDescription to be copied.
        flavor - Reserved for future use. Pass NULL for QuickTime Movie or ISO flavor.
        blockBufferOut - Receives new CMBlockBuffer containing TimeCodeDescription data structure in big-endian byte ordering.

      • CMSwapBigEndianTimeCodeDescriptionToHost

        public static int CMSwapBigEndianTimeCodeDescriptionToHost​(org.moe.natj.general.ptr.BytePtr timeCodeDescriptionData,
                                                           long timeCodeDescriptionSize)
        [@function] CMSwapBigEndianTimeCodeDescriptionToHost Converts a TimeCodeDescription data structure from big-endian to host-endian in place.
        Parameters:
        timeCodeDescriptionData - TimeCodeDescription data structure in big-endian byte ordering to be converted to host-endian byte ordering.
        timeCodeDescriptionSize - Size of TimeCodeDescription data structure.

      • CMSwapHostEndianTimeCodeDescriptionToBig

        public static int CMSwapHostEndianTimeCodeDescriptionToBig​(org.moe.natj.general.ptr.BytePtr timeCodeDescriptionData,
                                                           long timeCodeDescriptionSize)
        [@function] CMSwapHostEndianTimeCodeDescriptionToBig Converts a TimeCodeDescription data structure from host-endian to big-endian in place.
        Parameters:
        timeCodeDescriptionData - TimeCodeDescription data structure in host-endian byte ordering to be converted to big-endian byte ordering.
        timeCodeDescriptionSize - Size of TimeCodeDescription data structure.

      • CMMetadataFormatDescriptionCreateFromBigEndianMetadataDescriptionData

        public static int CMMetadataFormatDescriptionCreateFromBigEndianMetadataDescriptionData​(CFAllocatorRef allocator,
                                                                                        java.lang.String metadataDescriptionData,
                                                                                        long size,
                                                                                        CFStringRef flavor,
                                                                                        org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMMetadataFormatDescriptionCreateFromBigEndianMetadataDescriptionData Creates a CMMetadataFormatDescription from a big-endian MetadataDescription data structure.
        Parameters:
        allocator - Allocator to use for allocating the CMMetadataFormatDescription object. May be NULL.
        metadataDescriptionData - MetadataDescription data structure in big-endian byte ordering.
        size - Size of MetadataDescription data structure.
        flavor - Reserved for future use. Pass NULL for QuickTime Movie or ISO flavor.
        formatDescriptionOut - Receives new CMMetadataFormatDescriptionRef.

      • CMMetadataFormatDescriptionCreateFromBigEndianMetadataDescriptionBlockBuffer

        public static int CMMetadataFormatDescriptionCreateFromBigEndianMetadataDescriptionBlockBuffer​(CFAllocatorRef allocator,
                                                                                               CMBlockBufferRef metadataDescriptionBlockBuffer,
                                                                                               CFStringRef flavor,
                                                                                               org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMMetadataFormatDescriptionCreateFromBigEndianMetadataDescriptionBlockBuffer Creates a CMMetadataFormatDescription from a big-endian MetadataDescription data structure in a CMBlockBuffer.
        Parameters:
        allocator - Allocator to use for allocating the CMMetadataFormatDescription object. May be NULL.
        metadataDescriptionBlockBuffer - CMBlockBuffer containing MetadataDescription data structure in big-endian byte ordering.
        flavor - Reserved for future use. Pass NULL for QuickTime Movie or ISO flavor.
        formatDescriptionOut - Receives new CMMetadataFormatDescriptionRef.

      • CMMetadataFormatDescriptionCopyAsBigEndianMetadataDescriptionBlockBuffer

        public static int CMMetadataFormatDescriptionCopyAsBigEndianMetadataDescriptionBlockBuffer​(CFAllocatorRef allocator,
                                                                                           CMFormatDescriptionRef metadataFormatDescription,
                                                                                           CFStringRef flavor,
                                                                                           org.moe.natj.general.ptr.Ptr<CMBlockBufferRef> blockBufferOut)
        [@function] CMMetadataFormatDescriptionCopyAsBigEndianMetadataDescriptionBlockBuffer Copies the contents of a CMMetadataFormatDescription to a CMBlockBuffer in big-endian byte ordering. On return, the caller owns the returned CMBlockBuffer, and must release it when done with it. Note that the dataRefIndex field of the SampleDescription is intentionally filled with garbage values (0xFFFF). The caller must overwrite these values with a valid dataRefIndex if writing the SampleDescription to a QuickTime/ISO file.
        Parameters:
        allocator - Allocator to use for allocating the CMBlockBuffer object. May be NULL.
        metadataFormatDescription - CMMetadataFormatDescriptionRef to be copied.
        flavor - Reserved for future use. Pass NULL for QuickTime Movie or ISO flavor.
        blockBufferOut - Receives new CMBlockBuffer containing MetadataDescription data structure in big-endian byte ordering.

      • CMSwapBigEndianMetadataDescriptionToHost

        public static int CMSwapBigEndianMetadataDescriptionToHost​(org.moe.natj.general.ptr.BytePtr metadataDescriptionData,
                                                           long metadataDescriptionSize)
        [@function] CMSwapBigEndianMetadataDescriptionToHost Converts a MetadataDescription data structure from big-endian to host-endian in place.
        Parameters:
        metadataDescriptionData - MetadataDescription data structure in big-endian byte ordering to be converted to host-endian byte ordering.
        metadataDescriptionSize - Size of MetadataDescription data structure.

      • CMSwapHostEndianMetadataDescriptionToBig

        public static int CMSwapHostEndianMetadataDescriptionToBig​(org.moe.natj.general.ptr.BytePtr metadataDescriptionData,
                                                           long metadataDescriptionSize)
        [@function] CMSwapHostEndianMetadataDescriptionToBig Converts a MetadataDescription data structure from host-endian to big-endian in place.
        Parameters:
        metadataDescriptionData - MetadataDescription data structure in host-endian byte ordering to be converted to big-endian byte ordering.
        metadataDescriptionSize - Size of MetadataDescription data structure.

      • CMBufferQueueGetCallbacksForUnsortedSampleBuffers

        public static CMBufferCallbacks CMBufferQueueGetCallbacksForUnsortedSampleBuffers()
        [@function] CMBufferQueueGetCallbacksForUnsortedSampleBuffers Returns a pointer to a callback struct for unsorted CMSampleBuffers, provided as a convenience.

      • CMBufferQueueGetCallbacksForSampleBuffersSortedByOutputPTS

        public static CMBufferCallbacks CMBufferQueueGetCallbacksForSampleBuffersSortedByOutputPTS()
        [@function] CMBufferQueueGetCallbacksForOutputPTSSortedSampleBuffers Returns a pointer to a callback struct for CMSampleBuffers sorted by output presentation timestamp, provided as a convenience.

      • CMBufferQueueCreate

        public static int CMBufferQueueCreate​(CFAllocatorRef allocator,
                                      long capacity,
                                      CMBufferCallbacks callbacks,
                                      org.moe.natj.general.ptr.Ptr<CMBufferQueueRef> queueOut)
        [@function] CMBufferQueueCreate Creates a CMBufferQueue object. On return, the caller owns the returned CMBufferQueue, and must release it when done with it.

      • CMBufferQueueGetTypeID

        public static long CMBufferQueueGetTypeID()
        [@function] CMBufferQueueGetTypeID Returns the CFTypeID of CMBufferQueue objects. You can check if a CFTypeRef object is actually a CMBufferQueue by comparing CFGetTypeID(object) with CMBufferQueueGetTypeID().
        Returns:
        CFTypeID of CMBufferQueue objects.

      • CMBufferQueueEnqueue

        public static int CMBufferQueueEnqueue​(CMBufferQueueRef queue,
                                       org.moe.natj.general.ptr.ConstVoidPtr buf)
        [@function] CMBufferQueueEnqueue Enqueues a buffer onto a CMBufferQueue. The buffer is retained by the queue, so the client can safely release the buffer if it has no further use for it. If the compare callback is non-NULL, this API performs an insertion sort using that compare operation. If the validation callback is non-NULL, this API calls it; if it returns a nonzero OSStatus, the buffer will not be enqueued and this API will return the same error OSStatus.

      • CMBufferQueueDequeueAndRetain

        public static org.moe.natj.general.ptr.ConstVoidPtr CMBufferQueueDequeueAndRetain​(CMBufferQueueRef queue)
        [@function] CMBufferQueueDequeueAndRetain Dequeues a buffer from a CMBufferQueue. The buffer is released by the queue, but it is also retained for the client. Buffer ownership is thereby transferred from queue to client. The client need not retain the buffer, but is responsible to release it when done with it.
        Returns:
        The dequeued buffer. Will be NULL if the queue is empty.

      • CMBufferQueueDequeueIfDataReadyAndRetain

        public static org.moe.natj.general.ptr.ConstVoidPtr CMBufferQueueDequeueIfDataReadyAndRetain​(CMBufferQueueRef queue)
        [@function] CMBufferQueueDequeueIfDataReadyAndRetain Dequeues a buffer from a CMBufferQueue if it is ready. The buffer is released by the queue, but it is also retained for the client. Buffer ownership is thereby transferred from queue to client. The client need not retain the buffer, but is responsible to release it when done with it.
        Returns:
        The dequeued buffer. Will be NULL if the queue is empty, or if the buffer to be dequeued is not yet ready.

      • CMBufferQueueGetHead

        public static org.moe.natj.general.ptr.ConstVoidPtr CMBufferQueueGetHead​(CMBufferQueueRef queue)
        [@function] CMBufferQueueGetHead Retrieves the next-to-dequeue buffer from a CMBufferQueue but leaves it in the queue. This follows CF "Get" semantics -- it does not retain the returned buffer. Note that with non-FIFO queues it's not guaranteed that the next dequeue will return this particular buffer (if an intervening Enqueue adds a buffer that will dequeue next).
        Returns:
        The buffer. Will be NULL if the queue is empty.

      • CMBufferQueueIsEmpty

        public static byte CMBufferQueueIsEmpty​(CMBufferQueueRef queue)
        [@function] CMBufferQueueIsEmpty Returns whether or not a CMBufferQueue is empty.
        Returns:
        Whether or not the CMBufferQueue is empty. If queue is NULL, true is returned.

      • CMBufferQueueMarkEndOfData

        public static int CMBufferQueueMarkEndOfData​(CMBufferQueueRef queue)
        [@function] CMBufferQueueMarkEndOfData Marks a CMBufferQueue with EOD. All subsequent Enqueues will be rejected until CMBufferQueueReset is called. Subsequent Dequeues will succeed as long as the queue is not empty.

      • CMBufferQueueContainsEndOfData

        public static byte CMBufferQueueContainsEndOfData​(CMBufferQueueRef queue)
        [@function] CMBufferQueueContainsEndOfData Returns whether or not a CMBufferQueue has been marked with EOD.
        Returns:
        Whether or not the CMBufferQueue has been marked with EOD. If queue is NULL, true is returned (a NULL queue is considered to be empty, and permanently at EOD).

      • CMBufferQueueIsAtEndOfData

        public static byte CMBufferQueueIsAtEndOfData​(CMBufferQueueRef queue)
        [@function] CMBufferQueueIsAtEndOfData Returns whether or not a CMBufferQueue has been marked with EOD, and is now empty.
        Returns:
        Whether or not the CMBufferQueue has been marked with EOD, and is now empty. If queue is NULL, true is returned (a NULL queue is considered to be empty, and permanently at EOD).

      • CMBufferQueueReset

        public static int CMBufferQueueReset​(CMBufferQueueRef queue)
        [@function] CMBufferQueueReset Resets a CMBufferQueue. Empties the queue, and clears any EOD mark. All buffers in the queue are released. Triggers are not removed, however, and will be called appropriately as the queue duration goes to zero.

      • CMBufferQueueResetWithCallback

        public static int CMBufferQueueResetWithCallback​(CMBufferQueueRef queue,
                                                 CoreMedia.Function_CMBufferQueueResetWithCallback callback,
                                                 org.moe.natj.general.ptr.VoidPtr refcon)
        [@function] CMBufferQueueResetWithCallback Calls a function for every buffer in a queue, then resets the queue.

      • CMBufferQueueGetBufferCount

        public static long CMBufferQueueGetBufferCount​(CMBufferQueueRef queue)
        [@function] CMBufferQueueGetBufferCount Gets the number of buffers in the queue.

      • CMBufferQueueGetDuration

        public static CMTime CMBufferQueueGetDuration​(CMBufferQueueRef queue)
        [@function] CMBufferQueueGetDuration Gets the duration of a CMBufferQueue. The duration of the CMBufferQueue is the sum of all the individual buffer durations, as reported by the getDuration callback (provided to CMBufferQueueCreate). If there are no buffers in the queue, kCMTimeZero will be returned.

      • CMBufferQueueGetMinDecodeTimeStamp

        public static CMTime CMBufferQueueGetMinDecodeTimeStamp​(CMBufferQueueRef queue)
        [@function] CMBufferQueueGetMinDecodeTimeStamp Gets the earliest decode timestamp of a CMBufferQueue. The search for earliest decode timstamp is performed in this API. If you know your queue is in decode order, GetFirstDecodeTimeStamp is a faster alternative. If the getDecodeTimeStamp callback is NULL, kCMTimeInvalid will be returned.

      • CMBufferQueueGetFirstDecodeTimeStamp

        public static CMTime CMBufferQueueGetFirstDecodeTimeStamp​(CMBufferQueueRef queue)
        [@function] CMBufferQueueGetFirstDecodeTimeStamp Gets the decode timestamp of the first buffer in a CMBufferQueue. This API is is a faster alternative to GetMinDecodeTimeStamp, but only gives the same answer if your queue is in decode order. If the getDecodeTimeStamp callback is NULL, kCMTimeInvalid will be returned.

      • CMBufferQueueGetMinPresentationTimeStamp

        public static CMTime CMBufferQueueGetMinPresentationTimeStamp​(CMBufferQueueRef queue)
        [@function] CMBufferQueueGetMinPresentationTimeStamp Gets the earliest presentation timestamp of a CMBufferQueue. The search for earliest presentation timstamp is performed in this API. If you know your queue is sorted by presentation time, GetFirstPresentationTimeStamp is a faster alternative. If the getPresentationTimeStamp callback is NULL, kCMTimeInvalid will be returned.

      • CMBufferQueueGetFirstPresentationTimeStamp

        public static CMTime CMBufferQueueGetFirstPresentationTimeStamp​(CMBufferQueueRef queue)
        [@function] CMBufferQueueGetFirstPresentationTimeStamp Gets the presentation timestamp of the first buffer in a CMBufferQueue. This API is is a faster alternative to GetMinPresentationTimeStamp, but only works if you know your queue is sorted by presentation timestamp. If the getPresentationTimeStamp callback is NULL, kCMTimeInvalid will be returned.

      • CMBufferQueueGetMaxPresentationTimeStamp

        public static CMTime CMBufferQueueGetMaxPresentationTimeStamp​(CMBufferQueueRef queue)
        [@function] CMBufferQueueGetMaxPresentationTimeStamp Gets the greatest presentation timestamp of a CMBufferQueue. If the getPresentationTimeStamp callback is NULL, kCMTimeInvalid will be returned.

      • CMBufferQueueGetEndPresentationTimeStamp

        public static CMTime CMBufferQueueGetEndPresentationTimeStamp​(CMBufferQueueRef queue)
        [@function] CMBufferQueueGetEndPresentationTimeStamp Gets the greatest end presentation timestamp of a CMBufferQueue. This is the maximum end time (PTS + duration) of buffers in the queue. If the getPresentationTimeStamp callback is NULL, kCMTimeInvalid will be returned.

      • CMBufferQueueGetTotalSize

        public static long CMBufferQueueGetTotalSize​(CMBufferQueueRef queue)
        [@function] CMBufferQueueGetTotalSize Gets the total size of all sample buffers of a CMBufferQueue. The total size of the CMBufferQueue is the sum of all the individual buffer sizes, as reported by the getTotalSize callback (provided to CMBufferQueueCreate). If there are no buffers in the queue, 0 will be returned.

      • CMBufferQueueInstallTrigger

        public static int CMBufferQueueInstallTrigger​(CMBufferQueueRef queue,
                                              CoreMedia.Function_CMBufferQueueInstallTrigger callback,
                                              org.moe.natj.general.ptr.VoidPtr refcon,
                                              int condition,
                                              CMTime time,
                                              org.moe.natj.general.ptr.Ptr<CMBufferQueueTriggerToken> triggerTokenOut)
        [@function] CMBufferQueueInstallTrigger Installs a trigger on a CMBufferQueue. The returned trigger token can be passed to CMBufferQueueTestTrigger and CMBufferQueueRemoveTrigger. The triggerTokenOut parameter can be NULL (client doesn't need to test or remove trigger), and the callback parameter can be NULL (client doesn't need callbacks, but rather will explicitly test the trigger). One of these two parameters must be non-NULL, however, since an untestable trigger that does not perform a callback is meaningless. If the trigger condition is already true, CMBufferQueueInstallTrigger will call the callback. If it does this, it will first write the trigger token to *triggerTokenOut.

      • CMBufferQueueInstallTriggerWithIntegerThreshold

        public static int CMBufferQueueInstallTriggerWithIntegerThreshold​(CMBufferQueueRef queue,
                                                                  CoreMedia.Function_CMBufferQueueInstallTriggerWithIntegerThreshold callback,
                                                                  org.moe.natj.general.ptr.VoidPtr refcon,
                                                                  int condition,
                                                                  long threshold,
                                                                  org.moe.natj.general.ptr.Ptr<CMBufferQueueTriggerToken> triggerTokenOut)
        [@function] CMBufferQueueInstallTriggerWithIntegerThreshold Installs a trigger on a CMBufferQueue. This function behaves the same way as CMBufferQueueInstallTrigger() except the trigger is evaluated against the integer value rather than the time value.

      • CMBufferQueueRemoveTrigger

        public static int CMBufferQueueRemoveTrigger​(CMBufferQueueRef queue,
                                             CMBufferQueueTriggerToken triggerToken)
        [@function] CMBufferQueueRemoveTrigger Removes a previously installed trigger from a CMBufferQueue. Triggers will automatically be removed when a queue is finalized. However, if more than one module has access to a queue, it may be hard for an individual module to know when the queue is finalized since other modules may retain it. To address this concern, modules should remove their triggers before they themselves are finalized.

      • CMBufferQueueTestTrigger

        public static byte CMBufferQueueTestTrigger​(CMBufferQueueRef queue,
                                            CMBufferQueueTriggerToken triggerToken)
        [@function] CMBufferQueueTestTrigger Tests whether the trigger condition is true. Whereas the trigger callback will only be called when the condition goes from false to true, CMBufferQueueTestTrigger always returns the condition's current status. The triggerToken must be one that has been installed on this queue.

      • CMBufferQueueCallForEachBuffer

        public static int CMBufferQueueCallForEachBuffer​(CMBufferQueueRef queue,
                                                 CoreMedia.Function_CMBufferQueueCallForEachBuffer callback,
                                                 org.moe.natj.general.ptr.VoidPtr refcon)
        [@function] CMBufferQueueCallForEachBuffer Calls a function for every buffer in a queue. If the callback function returns an error, iteration will stop immediately and the error will be returned.

      • CMBufferQueueSetValidationCallback

        public static int CMBufferQueueSetValidationCallback​(CMBufferQueueRef queue,
                                                     CoreMedia.Function_CMBufferQueueSetValidationCallback callback,
                                                     org.moe.natj.general.ptr.VoidPtr refcon)
        [@function] CMBufferQueueSetValidationCallback Sets a function that CMBufferQueueEnqueue will call to validate buffers before adding them to the queue.

      • CMSimpleQueueGetTypeID

        public static long CMSimpleQueueGetTypeID()
        [@function] CMSimpleQueueGetTypeID Returns the CFTypeID of CMSimpleQueue objects. You can check if a CFTypeRef object is actually a CMSimpleQueue by comparing CFGetTypeID(object) with CMSimpleQueueGetTypeID().
        Returns:
        CFTypeID of CMSimpleQueue objects.

      • CMSimpleQueueCreate

        public static int CMSimpleQueueCreate​(CFAllocatorRef allocator,
                                      int capacity,
                                      org.moe.natj.general.ptr.Ptr<CMSimpleQueueRef> queueOut)
        [@function] CMSimpleQueueCreate Creates a CMSimpleQueue. On return, the caller owns the returned CMSimpleQueue, and must release it when done with it.
        Returns:
        Returns noErr if the call succeeds. Returns kCMSimpleQueueError_ParameterOutOfRange if capacity is negative.

      • CMSimpleQueueEnqueue

        public static int CMSimpleQueueEnqueue​(CMSimpleQueueRef queue,
                                       org.moe.natj.general.ptr.ConstVoidPtr element)
        [@function] CMSimpleQueueEnqueue Enqueues an element on the queue. If the queue is full, this operation will fail.
        Returns:
        Returns noErr if the call succeeds, kCMSimpleQueueError_QueueIsFull if the queue is full.

      • CMSimpleQueueDequeue

        public static org.moe.natj.general.ptr.ConstVoidPtr CMSimpleQueueDequeue​(CMSimpleQueueRef queue)
        [@function] CMSimpleQueueDequeue Dequeues an element from the queue. If the queue is empty, NULL will be returned.
        Returns:
        The dequeued element. NULL if the queue was empty, or if there was some other error.

      • CMSimpleQueueGetHead

        public static org.moe.natj.general.ptr.ConstVoidPtr CMSimpleQueueGetHead​(CMSimpleQueueRef queue)
        [@function] CMSimpleQueueGetHead Returns the element at the head of the queue. If the queue is empty, NULL will be returned.
        Returns:
        The head element. NULL if the queue was empty, or if there was some other error.

      • CMSimpleQueueReset

        public static int CMSimpleQueueReset​(CMSimpleQueueRef queue)
        [@function] CMSimpleQueueReset Resets the queue. This function resets the queue to its empty state; all values in the queue prior to reset are lost. Note that CMSimpleQueueReset is not synchronized in any way, so the reader thread and writer thread must be held off by the client during this operation.
        Returns:
        Returns noErr if the call succeeds.

      • CMSimpleQueueGetCapacity

        public static int CMSimpleQueueGetCapacity​(CMSimpleQueueRef queue)
        [@function] CMSimpleQueueGetCapacity Returns the number of elements that can be held in the queue.
        Returns:
        The number of elements that can be held in the queue. Returns 0 if there is an error.

      • CMSimpleQueueGetCount

        public static int CMSimpleQueueGetCount​(CMSimpleQueueRef queue)
        [@function] CMSimpleQueueGetCount Returns the number of elements currently on the queue.
        Returns:
        The number of elements currently in the queue. Returns 0 if there is an error.

      • CMMemoryPoolGetTypeID

        public static long CMMemoryPoolGetTypeID()

      • CMMemoryPoolCreate

        public static CMMemoryPoolRef CMMemoryPoolCreate​(CFDictionaryRef options)
        [@function] CMMemoryPoolCreate Creates a new CMMemoryPool.

      • CMMemoryPoolGetAllocator

        public static CFAllocatorRef CMMemoryPoolGetAllocator​(CMMemoryPoolRef pool)
        [@function] CMMemoryPoolGetAllocator Returns the pool's CFAllocator.

      • CMMemoryPoolFlush

        public static void CMMemoryPoolFlush​(CMMemoryPoolRef pool)
        [@function] CMMemoryPoolFlush Deallocates all memory the pool was holding for recycling.

      • CMMemoryPoolInvalidate

        public static void CMMemoryPoolInvalidate​(CMMemoryPoolRef pool)
        [@function] CMMemoryPoolInvalidate Stops the pool from recycling. When CMMemoryPoolInvalidate is called the pool's allocator stops recycling memory. The pool deallocates any memory it was holding for recycling. This also happens when the retain count of the CMMemoryPool drops to zero, except that under GC it may be delayed.

      • CMMetadataCreateIdentifierForKeyAndKeySpace

        public static int CMMetadataCreateIdentifierForKeyAndKeySpace​(CFAllocatorRef allocator,
                                                              org.moe.natj.general.ptr.ConstVoidPtr key,
                                                              CFStringRef keySpace,
                                                              org.moe.natj.general.ptr.Ptr<CFStringRef> identifierOut)
        [@function] CMMetadataCreateIdentifierForKeyAndKeySpace Creates a URL-like string identifier that represents a key/keyspace tuple. Metadata entities are identified by a key whose interpretation is defined by its keyspace. When writing metadata to a QuickTime Movie, this tuple is part of the track's format description. The following constants make up the current list of supported keyspaces, which are documented elsewhere in this file:
          kCMMetadataKeySpace_QuickTimeUserData
        • kCMMetadataKeySpace_ISOUserData
        • kCMMetadataKeySpace_iTunes
        • kCMMetadataKeySpace_ID3
        • kCMMetadataKeySpace_QuickTimeMetadata
        • kCMMetadataKeySpace_Icy
        Some keyspaces use OSTypes (a.k.a. FourCharCodes) to define their keys, and as such their keys are four bytes in length. The keyspaces that fall into this category are: kCMMetadataKeySpace_QuickTimeUserData, kCMMetadataKeySpace_ISOUserData, kCMMetadataKeySpace_iTunes, and kCMMetadataKeySpace_ID3. The keyspace kCMMetadataKeySpace_QuickTimeMetadata defines its key values to be expressed as reverse-DNS strings, which allows third parties to define their own keys in a well established way that avoids collisions. As a matter of convenience, known keyspaces allow for a key to be passed in using a variety of CFTypes. Note that what is returned by CMMetadataCreateKeyFromIdentifier depends upon the keyspace, and may be a different CFType than what is passed to this routine (see the discussion below for what CFTypes are returned for known keyspaces). To get a key represented as CFData, call CMMetadataCreateKeyFromIdentifierAsCFData. For OSType keyspaces, a key may be passed as a CFNumber, a CFString, or a CFData. A key passed as a CFNumber will have its value retrieved as kCFNumberSInt32Type comprising the four bytes of the key’s numeric value in big-endian byte order. A key passed as a CFString must be a valid ASCII string of four characters. A key passed as a CFData must be comprised of the four bytes of the key’s numeric value in big-endian byte order. All other keyspaces allow the key to be passed as a CFString or CFData. In both cases, the key will be interpreted as an ASCII string for the purposes of identifier encoding.

      • CMMetadataCreateKeyFromIdentifier

        public static int CMMetadataCreateKeyFromIdentifier​(CFAllocatorRef allocator,
                                                    CFStringRef identifier,
                                                    org.moe.natj.general.ptr.Ptr<org.moe.natj.general.ptr.ConstVoidPtr> keyOut)
        [@function] CMMetadataCreateKeyFromIdentifier Creates a copy of the key encoded in the identifier as a CFType. The returned CFType is based on the keyspace encoded in the identifier. For OSType keyspaces, the key will be returned as a CFNumber, where a big endian interpretation of its kCFNumberSInt32Type value represents the four bytes of the key's numeric value. For the keyspaces kCMMetadataKeySpace_QuickTimeMetadata and kCMMetadataKeySpace_Icy, the key will be returned as a CFString. All other keyspaces will have the function return the key as a CFData.

      • CMMetadataCreateKeyFromIdentifierAsCFData

        public static int CMMetadataCreateKeyFromIdentifierAsCFData​(CFAllocatorRef allocator,
                                                            CFStringRef identifier,
                                                            org.moe.natj.general.ptr.Ptr<CFDataRef> keyOut)
        [@function] CMMetadataCreateKeyFromIdentifierAsCFData Creates a copy of the key value that was encoded in the identifier as CFData. The bytes in the CFData correpsond to how they are serialized in the file.

      • CMMetadataCreateKeySpaceFromIdentifier

        public static int CMMetadataCreateKeySpaceFromIdentifier​(CFAllocatorRef allocator,
                                                         CFStringRef identifier,
                                                         org.moe.natj.general.ptr.Ptr<CFStringRef> keySpaceOut)
        [@function] CMMetadataCreateKeySpaceFromIdentifier Creates a copy of the key value that was encoded in the identifier as CFData.

      • CMMetadataDataTypeRegistryRegisterDataType

        public static int CMMetadataDataTypeRegistryRegisterDataType​(CFStringRef dataType,
                                                             CFStringRef description,
                                                             CFArrayRef conformingDataTypes)
        [@function] CMMetadataDataTypeRegistryRegisterDataType Register a data type with the data type registry. This routine is called by clients to register a data type with the data type registry. The list of conforming data type identifiers must include a base data type. If the data type has already been registered, then it is not considered an error to re-register it as long as the list of conforming data type identifiers has the same entries as the original; otherwise an error will be returned.

      • CMMetadataDataTypeRegistryDataTypeIsRegistered

        public static byte CMMetadataDataTypeRegistryDataTypeIsRegistered​(CFStringRef dataType)
        [@function] CMMetadataDataTypeRegistryDataTypeIsRegistered Tests a data type identifier to see if it has been registered.

      • CMMetadataDataTypeRegistryGetDataTypeDescription

        public static CFStringRef CMMetadataDataTypeRegistryGetDataTypeDescription​(CFStringRef dataType)
        [@function] CMMetadataDataTypeRegistryGetDataTypeDescription Returns the data type's description (if any was provided when it was registered).

      • CMMetadataDataTypeRegistryGetConformingDataTypes

        public static CFArrayRef CMMetadataDataTypeRegistryGetConformingDataTypes​(CFStringRef dataType)
        [@function] CMMetadataDataTypeRegistryGetConformingDataTypes Returns the data type's conforming data types (if any were provided when it was registered). [@returns] List of conforming data types registered for the given data type. NULL is returned if the data type has not been registered.

      • CMMetadataDataTypeRegistryDataTypeConformsToDataType

        public static byte CMMetadataDataTypeRegistryDataTypeConformsToDataType​(CFStringRef dataType,
                                                                        CFStringRef conformsToDataType)
        [@function] CMMetadataDataTypeRegistryDataTypeConformsToDataType Checks to see if a data type conforms to another data type. A given data type will conform to a second data type if any of the following are true:
          1. The data type identifiers are the same.
        • 2. The first data type identifier's conformance list contains the second data type identifier.
        • 3. A recursive search of the conforming data types for each element in the first
        • data type's conformance list yields the second data type identifer.
        [@returns] True if the first data type conforms to the second data type.

      • CMMetadataDataTypeRegistryGetBaseDataTypes

        public static CFArrayRef CMMetadataDataTypeRegistryGetBaseDataTypes()
        [@function] CMMetadataDataTypeRegistryGetBaseDataTypes Returns an array of base data type identifiers. There are a set of base data types that seed the data type registry. All valid data types will have their conformance search end with a base data type.

      • CMMetadataDataTypeRegistryDataTypeIsBaseDataType

        public static byte CMMetadataDataTypeRegistryDataTypeIsBaseDataType​(CFStringRef dataType)
        [@function] CMMetadataDataTypeRegistryDataTypeIsBaseDataType Tests a data type identifier to see if it represents a base data type. This is simply a convenience method to test to see if a given data type identifier is in the array returned by CMMetadataDataTypeRegistryGetBaseDataTypes.

      • CMMetadataDataTypeRegistryGetBaseDataTypeForConformingDataType

        public static CFStringRef CMMetadataDataTypeRegistryGetBaseDataTypeForConformingDataType​(CFStringRef dataType)
        [@function] CMMetadataDataTypeRegistryGetBaseDataTypeForConformingDataType Returns the base data type identifier that the given data type conforms to. There are a set of base data types that seed the data type registry. All valid data types will have their conformance search end with a base data type.

      • CMAudioClockCreate

        public static int CMAudioClockCreate​(CFAllocatorRef allocator,
                                     org.moe.natj.general.ptr.Ptr<CMClockRef> clockOut)
        [@function] CMAudioClockCreate Creates a clock that advances at the same rate as audio output. This clock will not drift from audio output, but may drift from CMClockGetHostTimeClock(). When audio output is completely stopped, the clock continues to advance, tracking CMClockGetHostTimeClock() until audio output starts up again. This clock is suitable for use as AVPlayer.masterClock when synchronizing video-only playback with audio played through other APIs or objects.
        Parameters:
        allocator - A CFAllocator to use to allocate the clock. Pass kCFAllocatorDefault or NULL to use the default allocator.
        clockOut - Points to a CMClockRef to receive the newly created clock. The caller is responsible for calling CFRelease to release this clock.

      • kCMTimeInvalid

        public static CMTime kCMTimeInvalid()

      • kCMTimeIndefinite

        public static CMTime kCMTimeIndefinite()

      • kCMTimePositiveInfinity

        public static CMTime kCMTimePositiveInfinity()

      • kCMTimeNegativeInfinity

        public static CMTime kCMTimeNegativeInfinity()

      • kCMTimeZero

        public static CMTime kCMTimeZero()

      • kCMTimeValueKey

        public static CFStringRef kCMTimeValueKey()
        [@constant] kCMTimeValueKey CFDictionary key for value field of CMTime (CFNumber containing int64_t)

      • kCMTimeScaleKey

        public static CFStringRef kCMTimeScaleKey()
        [@constant] kCMTimeScaleKey CFDictionary key for timescale field of CMTime (CFNumber containing int32_t)

      • kCMTimeEpochKey

        public static CFStringRef kCMTimeEpochKey()
        [@constant] kCMTimeEpochKey CFDictionary key for epoch field of CMTime (CFNumber containing int64_t)

      • kCMTimeFlagsKey

        public static CFStringRef kCMTimeFlagsKey()
        [@constant] kCMTimeFlagsKey CFDictionary key for flags field of CMTime (CFNumber containing uint32_t)

      • kCMTimeRangeZero

        public static CMTimeRange kCMTimeRangeZero()

      • kCMTimeRangeInvalid

        public static CMTimeRange kCMTimeRangeInvalid()

      • kCMTimeRangeStartKey

        public static CFStringRef kCMTimeRangeStartKey()
        [@constant] kCMTimeRangeStartKey CFDictionary key for start field of a CMTimeRange (CMTime)

      • kCMTimeRangeDurationKey

        public static CFStringRef kCMTimeRangeDurationKey()
        [@constant] kCMTimeRangeDurationKey CFDictionary key for timescale field of a CMTimeRange (CMTime)

      • kCMTimeMappingInvalid

        public static CMTimeMapping kCMTimeMappingInvalid()

      • kCMTimeMappingSourceKey

        public static CFStringRef kCMTimeMappingSourceKey()
        [@constant] kCMTimeMappingSourceKey CFDictionary key for source field of a CMTimeMapping (CMTimeRange)

      • kCMTimeMappingTargetKey

        public static CFStringRef kCMTimeMappingTargetKey()
        [@constant] kCMTimeMappingTargetKey CFDictionary key for target field of a CMTimeMapping (CMTimeRange)

      • kCMFormatDescriptionExtension_OriginalCompressionSettings

        public static CFStringRef kCMFormatDescriptionExtension_OriginalCompressionSettings()
        CFDictionary

      • kCMFormatDescriptionExtension_SampleDescriptionExtensionAtoms

        public static CFStringRef kCMFormatDescriptionExtension_SampleDescriptionExtensionAtoms()
        CFDictionary of CFString (four-char-code, atom type) -> ( CFData (atom payload) or CFArray of CFData (atom payload) )

      • kCMFormatDescriptionExtension_VerbatimSampleDescription

        public static CFStringRef kCMFormatDescriptionExtension_VerbatimSampleDescription()
        CFData

      • kCMFormatDescriptionExtension_VerbatimISOSampleEntry

        public static CFStringRef kCMFormatDescriptionExtension_VerbatimISOSampleEntry()
        CFData

      • kCMFormatDescriptionExtension_FormatName

        public static CFStringRef kCMFormatDescriptionExtension_FormatName()
        CFString

      • kCMFormatDescriptionExtension_Depth

        public static CFStringRef kCMFormatDescriptionExtension_Depth()
        CFNumber with depth value as directed by http://developer.apple.com/qa/qa2001/qa1183.html

      • kCMFormatDescriptionExtension_CleanAperture

        public static CFStringRef kCMFormatDescriptionExtension_CleanAperture()
        Many of the following extension keys and values are the same as the corresponding CVImageBuffer attachment keys and values

      • kCMFormatDescriptionKey_CleanApertureWidth

        public static CFStringRef kCMFormatDescriptionKey_CleanApertureWidth()

      • kCMFormatDescriptionKey_CleanApertureHeight

        public static CFStringRef kCMFormatDescriptionKey_CleanApertureHeight()

      • kCMFormatDescriptionKey_CleanApertureHorizontalOffset

        public static CFStringRef kCMFormatDescriptionKey_CleanApertureHorizontalOffset()

      • kCMFormatDescriptionKey_CleanApertureVerticalOffset

        public static CFStringRef kCMFormatDescriptionKey_CleanApertureVerticalOffset()

      • kCMFormatDescriptionKey_CleanApertureWidthRational

        public static CFStringRef kCMFormatDescriptionKey_CleanApertureWidthRational()
        CFArray of 2 CFNumbers: numerator, denominator

      • kCMFormatDescriptionKey_CleanApertureHeightRational

        public static CFStringRef kCMFormatDescriptionKey_CleanApertureHeightRational()
        CFArray of 2 CFNumbers: numerator, denominator

      • kCMFormatDescriptionKey_CleanApertureHorizontalOffsetRational

        public static CFStringRef kCMFormatDescriptionKey_CleanApertureHorizontalOffsetRational()
        CFArray of 2 CFNumbers: numerator, denominator

      • kCMFormatDescriptionKey_CleanApertureVerticalOffsetRational

        public static CFStringRef kCMFormatDescriptionKey_CleanApertureVerticalOffsetRational()
        CFArray of 2 CFNumbers: numerator, denominator

      • kCMFormatDescriptionExtension_FieldCount

        public static CFStringRef kCMFormatDescriptionExtension_FieldCount()

      • kCMFormatDescriptionExtension_FieldDetail

        public static CFStringRef kCMFormatDescriptionExtension_FieldDetail()

      • kCMFormatDescriptionFieldDetail_TemporalTopFirst

        public static CFStringRef kCMFormatDescriptionFieldDetail_TemporalTopFirst()

      • kCMFormatDescriptionFieldDetail_TemporalBottomFirst

        public static CFStringRef kCMFormatDescriptionFieldDetail_TemporalBottomFirst()

      • kCMFormatDescriptionFieldDetail_SpatialFirstLineEarly

        public static CFStringRef kCMFormatDescriptionFieldDetail_SpatialFirstLineEarly()

      • kCMFormatDescriptionFieldDetail_SpatialFirstLineLate

        public static CFStringRef kCMFormatDescriptionFieldDetail_SpatialFirstLineLate()

      • kCMFormatDescriptionExtension_PixelAspectRatio

        public static CFStringRef kCMFormatDescriptionExtension_PixelAspectRatio()

      • kCMFormatDescriptionKey_PixelAspectRatioHorizontalSpacing

        public static CFStringRef kCMFormatDescriptionKey_PixelAspectRatioHorizontalSpacing()

      • kCMFormatDescriptionKey_PixelAspectRatioVerticalSpacing

        public static CFStringRef kCMFormatDescriptionKey_PixelAspectRatioVerticalSpacing()

      • kCMFormatDescriptionExtension_ColorPrimaries

        public static CFStringRef kCMFormatDescriptionExtension_ColorPrimaries()

      • kCMFormatDescriptionColorPrimaries_ITU_R_709_2

        public static CFStringRef kCMFormatDescriptionColorPrimaries_ITU_R_709_2()

      • kCMFormatDescriptionColorPrimaries_EBU_3213

        public static CFStringRef kCMFormatDescriptionColorPrimaries_EBU_3213()

      • kCMFormatDescriptionColorPrimaries_SMPTE_C

        public static CFStringRef kCMFormatDescriptionColorPrimaries_SMPTE_C()

      • kCMFormatDescriptionColorPrimaries_DCI_P3

        public static CFStringRef kCMFormatDescriptionColorPrimaries_DCI_P3()
        same as kCVImageBufferColorPrimaries_DCI_P3

      • kCMFormatDescriptionColorPrimaries_P3_D65

        public static CFStringRef kCMFormatDescriptionColorPrimaries_P3_D65()
        same as kCVImageBufferColorPrimaries_P3_D65

      • kCMFormatDescriptionColorPrimaries_ITU_R_2020

        public static CFStringRef kCMFormatDescriptionColorPrimaries_ITU_R_2020()
        same as kCVImageBufferColorPrimaries_ITU_R_2020

      • kCMFormatDescriptionColorPrimaries_P22

        public static CFStringRef kCMFormatDescriptionColorPrimaries_P22()
        same as kCVImageBufferColorPrimaries_P22

      • kCMFormatDescriptionExtension_TransferFunction

        public static CFStringRef kCMFormatDescriptionExtension_TransferFunction()

      • kCMFormatDescriptionTransferFunction_ITU_R_709_2

        public static CFStringRef kCMFormatDescriptionTransferFunction_ITU_R_709_2()

      • kCMFormatDescriptionTransferFunction_SMPTE_240M_1995

        public static CFStringRef kCMFormatDescriptionTransferFunction_SMPTE_240M_1995()

      • kCMFormatDescriptionTransferFunction_UseGamma

        public static CFStringRef kCMFormatDescriptionTransferFunction_UseGamma()

      • kCMFormatDescriptionTransferFunction_ITU_R_2020

        public static CFStringRef kCMFormatDescriptionTransferFunction_ITU_R_2020()
        same as kCVImageBufferTransferFunction_ITU_R_2020. note: semantically equivalent to kCMFormatDescriptionTransferFunction_ITU_R_709_2, which is preferred.

      • kCMFormatDescriptionTransferFunction_SMPTE_ST_428_1

        public static CFStringRef kCMFormatDescriptionTransferFunction_SMPTE_ST_428_1()
        same as kCVImageBufferTransferFunction_SMPTE_ST_428_1

      • kCMFormatDescriptionExtension_GammaLevel

        public static CFStringRef kCMFormatDescriptionExtension_GammaLevel()

      • kCMFormatDescriptionExtension_YCbCrMatrix

        public static CFStringRef kCMFormatDescriptionExtension_YCbCrMatrix()

      • kCMFormatDescriptionYCbCrMatrix_ITU_R_709_2

        public static CFStringRef kCMFormatDescriptionYCbCrMatrix_ITU_R_709_2()

      • kCMFormatDescriptionYCbCrMatrix_ITU_R_601_4

        public static CFStringRef kCMFormatDescriptionYCbCrMatrix_ITU_R_601_4()

      • kCMFormatDescriptionYCbCrMatrix_SMPTE_240M_1995

        public static CFStringRef kCMFormatDescriptionYCbCrMatrix_SMPTE_240M_1995()

      • kCMFormatDescriptionYCbCrMatrix_ITU_R_2020

        public static CFStringRef kCMFormatDescriptionYCbCrMatrix_ITU_R_2020()
        same as kCVImageBufferYCbCrMatrix_ITU_R_2020

      • kCMFormatDescriptionExtension_FullRangeVideo

        public static CFStringRef kCMFormatDescriptionExtension_FullRangeVideo()
        CFBoolean; by default, false for YCbCr-based compressed formats, indicating that pixel values are video-range rather than full-range

      • kCMFormatDescriptionExtension_ICCProfile

        public static CFStringRef kCMFormatDescriptionExtension_ICCProfile()
        CFData

      • kCMFormatDescriptionExtension_BytesPerRow

        public static CFStringRef kCMFormatDescriptionExtension_BytesPerRow()
        CFNumber describing the bytes per row of raster pixel data (not used for compressed, planar, tiled or downsampled formats)

      • kCMFormatDescriptionExtension_ChromaLocationTopField

        public static CFStringRef kCMFormatDescriptionExtension_ChromaLocationTopField()
        Chroma siting information. For progressive images, only the TopField value is used.

      • kCMFormatDescriptionExtension_ChromaLocationBottomField

        public static CFStringRef kCMFormatDescriptionExtension_ChromaLocationBottomField()

      • kCMFormatDescriptionChromaLocation_Left

        public static CFStringRef kCMFormatDescriptionChromaLocation_Left()

      • kCMFormatDescriptionChromaLocation_Center

        public static CFStringRef kCMFormatDescriptionChromaLocation_Center()

      • kCMFormatDescriptionChromaLocation_TopLeft

        public static CFStringRef kCMFormatDescriptionChromaLocation_TopLeft()

      • kCMFormatDescriptionChromaLocation_Top

        public static CFStringRef kCMFormatDescriptionChromaLocation_Top()

      • kCMFormatDescriptionChromaLocation_BottomLeft

        public static CFStringRef kCMFormatDescriptionChromaLocation_BottomLeft()

      • kCMFormatDescriptionChromaLocation_Bottom

        public static CFStringRef kCMFormatDescriptionChromaLocation_Bottom()

      • kCMFormatDescriptionChromaLocation_DV420

        public static CFStringRef kCMFormatDescriptionChromaLocation_DV420()

      • kCMFormatDescriptionConformsToMPEG2VideoProfile

        public static CFStringRef kCMFormatDescriptionConformsToMPEG2VideoProfile()
        CFNumber specifying a kCMMPEG2VideoProfile_*

      • kCMFormatDescriptionExtension_TemporalQuality

        public static CFStringRef kCMFormatDescriptionExtension_TemporalQuality()
        CFNumber

      • kCMFormatDescriptionExtension_SpatialQuality

        public static CFStringRef kCMFormatDescriptionExtension_SpatialQuality()
        CFNumber

      • kCMFormatDescriptionExtension_VerbatimImageDescription

        public static CFStringRef kCMFormatDescriptionExtension_VerbatimImageDescription()

      • kCMFormatDescriptionExtension_Version

        public static CFStringRef kCMFormatDescriptionExtension_Version()
        CFNumber

      • kCMFormatDescriptionExtension_RevisionLevel

        public static CFStringRef kCMFormatDescriptionExtension_RevisionLevel()
        CFNumber

      • kCMFormatDescriptionExtension_Vendor

        public static CFStringRef kCMFormatDescriptionExtension_Vendor()
        CFString of fourCC

      • kCMFormatDescriptionVendor_Apple

        public static CFStringRef kCMFormatDescriptionVendor_Apple()

      • kCMTextFormatDescriptionExtension_DisplayFlags

        public static CFStringRef kCMTextFormatDescriptionExtension_DisplayFlags()
        CFNumber (SInt32 holding CMTextDisplayFlags)

      • kCMTextFormatDescriptionExtension_BackgroundColor

        public static CFStringRef kCMTextFormatDescriptionExtension_BackgroundColor()
        CFDictionary

      • kCMTextFormatDescriptionColor_Red

        public static CFStringRef kCMTextFormatDescriptionColor_Red()
        CFNumber (SInt8 for 3G), (SInt16 for QT)

      • kCMTextFormatDescriptionColor_Green

        public static CFStringRef kCMTextFormatDescriptionColor_Green()
        CFNumber (SInt8 for 3G), (SInt16 for QT)

      • kCMTextFormatDescriptionColor_Blue

        public static CFStringRef kCMTextFormatDescriptionColor_Blue()
        CFNumber (SInt8 for 3G), (SInt16 for QT)

      • kCMTextFormatDescriptionColor_Alpha

        public static CFStringRef kCMTextFormatDescriptionColor_Alpha()
        CFNumber (SInt8 for 3G), not applicable for QT text.

      • kCMTextFormatDescriptionExtension_DefaultTextBox

        public static CFStringRef kCMTextFormatDescriptionExtension_DefaultTextBox()
        CFDictionary

      • kCMTextFormatDescriptionRect_Top

        public static CFStringRef kCMTextFormatDescriptionRect_Top()
        CFNumber (SInt16)

      • kCMTextFormatDescriptionRect_Left

        public static CFStringRef kCMTextFormatDescriptionRect_Left()
        CFNumber (SInt16)

      • kCMTextFormatDescriptionRect_Bottom

        public static CFStringRef kCMTextFormatDescriptionRect_Bottom()
        CFNumber (SInt16)

      • kCMTextFormatDescriptionRect_Right

        public static CFStringRef kCMTextFormatDescriptionRect_Right()
        CFNumber (SInt16)

      • kCMTextFormatDescriptionExtension_DefaultStyle

        public static CFStringRef kCMTextFormatDescriptionExtension_DefaultStyle()
        CFDictionary

      • kCMTextFormatDescriptionStyle_StartChar

        public static CFStringRef kCMTextFormatDescriptionStyle_StartChar()
        CFNumber (SInt16 for 3G), (SInt32 for QT)

      • kCMTextFormatDescriptionStyle_Font

        public static CFStringRef kCMTextFormatDescriptionStyle_Font()
        CFNumber (SInt16)

      • kCMTextFormatDescriptionStyle_FontFace

        public static CFStringRef kCMTextFormatDescriptionStyle_FontFace()
        CFNumber (SInt8)

      • kCMTextFormatDescriptionStyle_ForegroundColor

        public static CFStringRef kCMTextFormatDescriptionStyle_ForegroundColor()
        CFDictionary (kCMTextFormatDescriptionColor_Red, kCMTextFormatDescriptionColor_Green, etc)

      • kCMTextFormatDescriptionStyle_FontSize

        public static CFStringRef kCMTextFormatDescriptionStyle_FontSize()
        CFNumber (SInt8 for 3G), (SInt16 for QT)

      • kCMTextFormatDescriptionExtension_HorizontalJustification

        public static CFStringRef kCMTextFormatDescriptionExtension_HorizontalJustification()
        CFNumber (SInt8 holding a CMTextJustificationValue)

      • kCMTextFormatDescriptionExtension_VerticalJustification

        public static CFStringRef kCMTextFormatDescriptionExtension_VerticalJustification()
        CFNumber (SInt8 holding a CMTextJustificationValue)

      • kCMTextFormatDescriptionStyle_EndChar

        public static CFStringRef kCMTextFormatDescriptionStyle_EndChar()
        CFNumber (SInt16)

      • kCMTextFormatDescriptionExtension_FontTable

        public static CFStringRef kCMTextFormatDescriptionExtension_FontTable()
        CFDictionary (Keys are FontIDs as CFStrings, vals are font names as CFStrings)

      • kCMTextFormatDescriptionExtension_TextJustification

        public static CFStringRef kCMTextFormatDescriptionExtension_TextJustification()
        CFNumber (SInt32 holding a CMTextJustificationValue)

      • kCMTextFormatDescriptionStyle_Height

        public static CFStringRef kCMTextFormatDescriptionStyle_Height()
        CFNumber (SInt16)

      • kCMTextFormatDescriptionStyle_Ascent

        public static CFStringRef kCMTextFormatDescriptionStyle_Ascent()
        CFNumber (SInt16)

      • kCMTextFormatDescriptionExtension_DefaultFontName

        public static CFStringRef kCMTextFormatDescriptionExtension_DefaultFontName()
        CFString

      • kCMTimeCodeFormatDescriptionExtension_SourceReferenceName

        public static CFStringRef kCMTimeCodeFormatDescriptionExtension_SourceReferenceName()
        CFDictionary containing the following two keys

      • kCMTimeCodeFormatDescriptionKey_Value

        public static CFStringRef kCMTimeCodeFormatDescriptionKey_Value()
        CFString

      • kCMTimeCodeFormatDescriptionKey_LangCode

        public static CFStringRef kCMTimeCodeFormatDescriptionKey_LangCode()
        CFNumber

      • kCMFormatDescriptionExtensionKey_MetadataKeyTable

        public static CFStringRef kCMFormatDescriptionExtensionKey_MetadataKeyTable()

      • kCMMetadataFormatDescriptionKey_Namespace

        public static CFStringRef kCMMetadataFormatDescriptionKey_Namespace()
        CFNumber(OSType) native endian

      • kCMMetadataFormatDescriptionKey_Value

        public static CFStringRef kCMMetadataFormatDescriptionKey_Value()
        CFData

      • kCMMetadataFormatDescriptionKey_LocalID

        public static CFStringRef kCMMetadataFormatDescriptionKey_LocalID()
        CFNumber(OSType) native endian

      • kCMMetadataFormatDescriptionKey_DataType

        public static CFStringRef kCMMetadataFormatDescriptionKey_DataType()
        CFData

      • kCMMetadataFormatDescriptionKey_DataTypeNamespace

        public static CFStringRef kCMMetadataFormatDescriptionKey_DataTypeNamespace()
        CFNumber(SInt32) native endian

      • kCMMetadataFormatDescriptionKey_ConformingDataTypes

        public static CFStringRef kCMMetadataFormatDescriptionKey_ConformingDataTypes()
        CFArray(CFDictionary) of DataType and DataTypeNamespace

      • kCMMetadataFormatDescriptionKey_LanguageTag

        public static CFStringRef kCMMetadataFormatDescriptionKey_LanguageTag()
        CFString

      • kCMMetadataFormatDescriptionKey_StructuralDependency

        public static CFStringRef kCMMetadataFormatDescriptionKey_StructuralDependency()
        CFDictionary

      • kCMMetadataFormatDescriptionKey_SetupData

        public static CFStringRef kCMMetadataFormatDescriptionKey_SetupData()
        CFData

      • kCMMetadataFormatDescription_StructuralDependencyKey_DependencyIsInvalidFlag

        public static CFStringRef kCMMetadataFormatDescription_StructuralDependencyKey_DependencyIsInvalidFlag()
        CFBoolean

      • kCMMetadataFormatDescriptionMetadataSpecificationKey_Identifier

        public static CFStringRef kCMMetadataFormatDescriptionMetadataSpecificationKey_Identifier()
        CFString

      • kCMMetadataFormatDescriptionMetadataSpecificationKey_DataType

        public static CFStringRef kCMMetadataFormatDescriptionMetadataSpecificationKey_DataType()
        CFString

      • kCMMetadataFormatDescriptionMetadataSpecificationKey_ExtendedLanguageTag

        public static CFStringRef kCMMetadataFormatDescriptionMetadataSpecificationKey_ExtendedLanguageTag()
        CFString in BCP 47 format

      • kCMMetadataFormatDescriptionMetadataSpecificationKey_StructuralDependency

        public static CFStringRef kCMMetadataFormatDescriptionMetadataSpecificationKey_StructuralDependency()
        CFDictionary

      • kCMMetadataFormatDescriptionMetadataSpecificationKey_SetupData

        public static CFStringRef kCMMetadataFormatDescriptionMetadataSpecificationKey_SetupData()
        CFData

      • kCMSampleBufferNotification_DataBecameReady

        public static CFStringRef kCMSampleBufferNotification_DataBecameReady()
        [@constant] kCMSampleBufferNotification_DataBecameReady Posted on a CMSampleBuffer by CMSampleBufferSetDataReady when the buffer becomes ready.

      • kCMSampleBufferNotification_DataFailed

        public static CFStringRef kCMSampleBufferNotification_DataFailed()
        [@constant] kCMSampleBufferNotification_DataFailed Posted on a CMSampleBuffer by CMSampleBufferSetDataFailed to report that the buffer will never become ready.

      • kCMSampleBufferNotificationParameter_OSStatus

        public static CFStringRef kCMSampleBufferNotificationParameter_OSStatus()

      • kCMSampleBufferConduitNotification_InhibitOutputUntil

        public static CFStringRef kCMSampleBufferConduitNotification_InhibitOutputUntil()
        payload: CFDictionary containing:

      • kCMSampleBufferConduitNotificationParameter_ResumeTag

        public static CFStringRef kCMSampleBufferConduitNotificationParameter_ResumeTag()
        payload: CFNumber

      • kCMSampleBufferConduitNotification_ResetOutput

        public static CFStringRef kCMSampleBufferConduitNotification_ResetOutput()
        [@constant] kCMSampleBufferConduitNotification_ResetOutput Posted on a conduit of CMSampleBuffers (eg, a CMBufferQueue) to request invalidation of pending output data.

      • kCMSampleBufferConduitNotification_UpcomingOutputPTSRangeChanged

        public static CFStringRef kCMSampleBufferConduitNotification_UpcomingOutputPTSRangeChanged()
        payload: CFDictionary containing:

      • kCMSampleBufferConduitNotificationParameter_UpcomingOutputPTSRangeMayOverlapQueuedOutputPTSRange

        public static CFStringRef kCMSampleBufferConduitNotificationParameter_UpcomingOutputPTSRangeMayOverlapQueuedOutputPTSRange()
        payload: CFBoolean

      • kCMSampleBufferConduitNotificationParameter_MinUpcomingOutputPTS

        public static CFStringRef kCMSampleBufferConduitNotificationParameter_MinUpcomingOutputPTS()
        payload: CFDictionary(CMTime)

      • kCMSampleBufferConduitNotificationParameter_MaxUpcomingOutputPTS

        public static CFStringRef kCMSampleBufferConduitNotificationParameter_MaxUpcomingOutputPTS()
        payload: CFDictionary(CMTime)

      • kCMSampleBufferConsumerNotification_BufferConsumed

        public static CFStringRef kCMSampleBufferConsumerNotification_BufferConsumed()
        payload: CFDictionary

      • kCMSampleAttachmentKey_NotSync

        public static CFStringRef kCMSampleAttachmentKey_NotSync()
        CFBoolean (absence of this key implies Sync)

      • kCMSampleAttachmentKey_PartialSync

        public static CFStringRef kCMSampleAttachmentKey_PartialSync()
        CFBoolean (absence of this key implies not Partial Sync. If NotSync is false, PartialSync should be ignored.)

      • kCMSampleAttachmentKey_HasRedundantCoding

        public static CFStringRef kCMSampleAttachmentKey_HasRedundantCoding()
        kCFBooleanTrue, kCFBooleanFalse, or absent if unknown

      • kCMSampleAttachmentKey_IsDependedOnByOthers

        public static CFStringRef kCMSampleAttachmentKey_IsDependedOnByOthers()
        kCFBooleanTrue, kCFBooleanFalse, or absent if unknown

      • kCMSampleAttachmentKey_DependsOnOthers

        public static CFStringRef kCMSampleAttachmentKey_DependsOnOthers()
        kCFBooleanTrue (e.g., non-I-frame), kCFBooleanFalse (e.g. I-frame), or absent if unknown

      • kCMSampleAttachmentKey_EarlierDisplayTimesAllowed

        public static CFStringRef kCMSampleAttachmentKey_EarlierDisplayTimesAllowed()
        CFBoolean

      • kCMSampleAttachmentKey_DisplayImmediately

        public static CFStringRef kCMSampleAttachmentKey_DisplayImmediately()
        CFBoolean

      • kCMSampleAttachmentKey_DoNotDisplay

        public static CFStringRef kCMSampleAttachmentKey_DoNotDisplay()
        CFBoolean

      • kCMSampleBufferAttachmentKey_ResetDecoderBeforeDecoding

        public static CFStringRef kCMSampleBufferAttachmentKey_ResetDecoderBeforeDecoding()
        CFBoolean

      • kCMSampleBufferAttachmentKey_DrainAfterDecoding

        public static CFStringRef kCMSampleBufferAttachmentKey_DrainAfterDecoding()
        CFBoolean

      • kCMSampleBufferAttachmentKey_PostNotificationWhenConsumed

        public static CFStringRef kCMSampleBufferAttachmentKey_PostNotificationWhenConsumed()
        CFDictionary (client-defined)

      • kCMSampleBufferAttachmentKey_ResumeOutput

        public static CFStringRef kCMSampleBufferAttachmentKey_ResumeOutput()
        CFNumber (ResumeTag)

      • kCMSampleBufferAttachmentKey_TransitionID

        public static CFStringRef kCMSampleBufferAttachmentKey_TransitionID()
        [@constant] kCMSampleBufferAttachmentKey_TransitionID Marks a transition from one source of buffers (eg. song) to another For example, during gapless playback of a list of songs, this attachment marks the first buffer from the next song. If this attachment is on a buffer containing no samples, the first following buffer that contains samples is the buffer that contains the first samples from the next song. The value of this attachment is a CFTypeRef. This transition identifier should be unique within a playlist, so each transition in a playlist is uniquely identifiable. A CFNumberRef counter that increments with each transition is a simple example.

      • kCMSampleBufferAttachmentKey_TrimDurationAtStart

        public static CFStringRef kCMSampleBufferAttachmentKey_TrimDurationAtStart()
        CFDictionary/CMTime, default 0

      • kCMSampleBufferAttachmentKey_TrimDurationAtEnd

        public static CFStringRef kCMSampleBufferAttachmentKey_TrimDurationAtEnd()
        CFDictionary/CMTime, default 0

      • kCMSampleBufferAttachmentKey_SpeedMultiplier

        public static CFStringRef kCMSampleBufferAttachmentKey_SpeedMultiplier()
        CFNumber, positive, default 1

      • kCMSampleBufferAttachmentKey_Reverse

        public static CFStringRef kCMSampleBufferAttachmentKey_Reverse()
        CFBoolean, default false

      • kCMSampleBufferAttachmentKey_FillDiscontinuitiesWithSilence

        public static CFStringRef kCMSampleBufferAttachmentKey_FillDiscontinuitiesWithSilence()
        CFBoolean, default false

      • kCMSampleBufferAttachmentKey_EmptyMedia

        public static CFStringRef kCMSampleBufferAttachmentKey_EmptyMedia()
        CFBoolean, default false

      • kCMSampleBufferAttachmentKey_PermanentEmptyMedia

        public static CFStringRef kCMSampleBufferAttachmentKey_PermanentEmptyMedia()
        CFBoolean, default false

      • kCMSampleBufferAttachmentKey_DisplayEmptyMediaImmediately

        public static CFStringRef kCMSampleBufferAttachmentKey_DisplayEmptyMediaImmediately()
        [@constant] kCMSampleBufferAttachmentKey_DisplayEmptyMediaImmediately Tells that the empty marker should be dequeued immediately regardless of its timestamp. Marker sample buffers with this attachment in addition to kCMSampleBufferAttachmentKey_EmptyMedia are used to tell that the empty sample buffer should be dequeued immediately regardless of its timestamp. This attachment should only be used with sample buffers with the kCMSampleBufferAttachmentKey_EmptyMedia attachment.

      • kCMSampleBufferAttachmentKey_EndsPreviousSampleDuration

        public static CFStringRef kCMSampleBufferAttachmentKey_EndsPreviousSampleDuration()
        CFBoolean, default false

      • kCMSampleBufferAttachmentKey_SampleReferenceURL

        public static CFStringRef kCMSampleBufferAttachmentKey_SampleReferenceURL()
        CFURL

      • kCMSampleBufferAttachmentKey_SampleReferenceByteOffset

        public static CFStringRef kCMSampleBufferAttachmentKey_SampleReferenceByteOffset()
        CFNumber, byte offset from beginning of URL to contiguous data

      • kCMSampleBufferAttachmentKey_GradualDecoderRefresh

        public static CFStringRef kCMSampleBufferAttachmentKey_GradualDecoderRefresh()
        CFNumber, audio decoder refresh count

      • kCMSampleBufferAttachmentKey_DroppedFrameReason

        public static CFStringRef kCMSampleBufferAttachmentKey_DroppedFrameReason()
        CFString, frame drop reason

      • kCMSampleBufferDroppedFrameReason_FrameWasLate

        public static CFStringRef kCMSampleBufferDroppedFrameReason_FrameWasLate()
        [@constant] kCMSampleBufferDroppedFrameReason_FrameWasLate The frame was dropped because it was late The value of kCMSampleBufferAttachmentKey_DroppedFrameReason if a video capture client has indicated that late video frames should be dropped and the current frame is late. This condition is typically caused by the client's processing taking too long.

      • kCMSampleBufferDroppedFrameReason_OutOfBuffers

        public static CFStringRef kCMSampleBufferDroppedFrameReason_OutOfBuffers()
        [@constant] kCMSampleBufferDroppedFrameReason_OutOfBuffers The frame was dropped because the module providing frames is out of buffers The value of kCMSampleBufferAttachmentKey_DroppedFrameReason if the module providing sample buffers has run out of source buffers. This condition is typically caused by the client holding onto buffers for too long and can be alleviated by returning buffers to the provider.

      • kCMSampleBufferDroppedFrameReason_Discontinuity

        public static CFStringRef kCMSampleBufferDroppedFrameReason_Discontinuity()
        [@constant] kCMSampleBufferDroppedFrameReason_Discontinuity An unknown number of frames were dropped The value of kCMSampleBufferAttachmentKey_DroppedFrameReason if the module providing sample buffers has experienced a discontinuity, and an unknown number of frames have been lost. This condition is typically caused by the system being too busy.

      • kCMSampleBufferAttachmentKey_DroppedFrameReasonInfo

        public static CFStringRef kCMSampleBufferAttachmentKey_DroppedFrameReasonInfo()
        [@constant] kCMSampleBufferAttachmentKey_DroppedFrameReasonInfo Indicates additional information regarding the dropped video frame. Sample buffers with this attachment contain no image or data buffer. They mark a dropped video frame. If present, this attachment provides additional information about the kCMSampleBufferAttachmentKey_DroppedFrameReason.

      • kCMSampleBufferDroppedFrameReasonInfo_CameraModeSwitch

        public static CFStringRef kCMSampleBufferDroppedFrameReasonInfo_CameraModeSwitch()
        [@constant] kCMSampleBufferDroppedFrameReasonInfo_CameraModeSwitch A discontinuity was caused by a camera mode switch. The value of kCMSampleBufferAttachmentKey_DroppedFrameReasonInfo if the module providing sample buffers has experienced a discontinuity due to a camera mode switch. Short discontinuities of this type can occur when the session is configured for still image capture on some devices.

      • kCMSampleBufferAttachmentKey_StillImageLensStabilizationInfo

        public static CFStringRef kCMSampleBufferAttachmentKey_StillImageLensStabilizationInfo()
        CFString, one of kCMSampleBufferLensStabilizationInfo_*

      • kCMSampleBufferLensStabilizationInfo_Active

        public static CFStringRef kCMSampleBufferLensStabilizationInfo_Active()
        CFString

      • kCMSampleBufferLensStabilizationInfo_OutOfRange

        public static CFStringRef kCMSampleBufferLensStabilizationInfo_OutOfRange()
        CFString

      • kCMSampleBufferLensStabilizationInfo_Unavailable

        public static CFStringRef kCMSampleBufferLensStabilizationInfo_Unavailable()
        CFString

      • kCMSampleBufferLensStabilizationInfo_Off

        public static CFStringRef kCMSampleBufferLensStabilizationInfo_Off()
        CFString

      • kCMSampleBufferAttachmentKey_ForceKeyFrame

        public static CFStringRef kCMSampleBufferAttachmentKey_ForceKeyFrame()
        [@constant] kCMSampleBufferAttachmentKey_ForceKeyFrame Indicates that the current or next video sample buffer should be forced to be encoded as a key frame. A value of kCFBooleanTrue for kCMSampleBufferAttachmentKey_ForceKeyFrame indicates that the current or next video sample buffer processed in the stream should be forced to be encoded as a key frame. If this attachment is present and kCFBooleanTrue on a sample buffer with a video frame, that video frame will be forced to become a key frame. If the sample buffer for which this is present and kCFBooleanTrue does not have a valid video frame, the next sample buffer processed that contains a valid video frame will be encoded as a key frame. Usual care should be taken when setting attachments on sample buffers whose orgins and destinations are ambiguous. For example, CMSetAttachment() is not thread-safe, and CMSampleBuffers may be used in multiple sample buffer streams in a given system. This can lead to crashes during concurrent access and/or unexpected behavior on alternate sample buffer streams. Therefore, unless the orgin and destination of a sample buffer is known, the general recommended practice is to synthesize an empty sample buffer with this attachment alone and insert it into the sample buffer stream ahead of the concrete sample buffer rather than setting this attachment on the concrete sample buffer itself.

      • kCMTimebaseNotification_EffectiveRateChanged

        public static CFStringRef kCMTimebaseNotification_EffectiveRateChanged()
        Posted by a timebase after a change in effective rate.

      • kCMTimebaseNotification_TimeJumped

        public static CFStringRef kCMTimebaseNotification_TimeJumped()
        Posted by a timebase after a discontinuous time jump.

      • kCMTimebaseNotificationKey_EventTime

        public static CFStringRef kCMTimebaseNotificationKey_EventTime()
        Payload key for the time at which a change in effective rate or a discontinuous time jump occurred.

      • kCMImageDescriptionFlavor_QuickTimeMovie

        public static CFStringRef kCMImageDescriptionFlavor_QuickTimeMovie()
        equivalent to NULL

      • kCMImageDescriptionFlavor_ISOFamily

        public static CFStringRef kCMImageDescriptionFlavor_ISOFamily()
        MP4, etc

      • kCMImageDescriptionFlavor_3GPFamily

        public static CFStringRef kCMImageDescriptionFlavor_3GPFamily()
        3GPP (implies ISO)

      • kCMSoundDescriptionFlavor_QuickTimeMovie

        public static CFStringRef kCMSoundDescriptionFlavor_QuickTimeMovie()
        equivalent to NULL

      • kCMSoundDescriptionFlavor_QuickTimeMovieV2

        public static CFStringRef kCMSoundDescriptionFlavor_QuickTimeMovieV2()
        [@constant] kCMSoundDescriptionFlavor_QuickTimeMovieV2 Chooses the QuickTime Movie Sound Description V2 format. A V2 sound description will be written. V2 Sound Descriptions contain no legacy CBR layout, and use 'lpcm' for all flavors of PCM.

      • kCMSoundDescriptionFlavor_ISOFamily

        public static CFStringRef kCMSoundDescriptionFlavor_ISOFamily()
        MP4, etc

      • kCMSoundDescriptionFlavor_3GPFamily

        public static CFStringRef kCMSoundDescriptionFlavor_3GPFamily()
        3GPP (implies ISO)

      • kCMMemoryPoolOption_AgeOutPeriod

        public static CFStringRef kCMMemoryPoolOption_AgeOutPeriod()
        CFNumber (seconds)

      • kCMTextMarkupAttribute_ForegroundColorARGB

        public static CFStringRef kCMTextMarkupAttribute_ForegroundColorARGB()
        [@const] kCMTextMarkupAttribute_ForegroundColorARGB The foreground color for text. Value must be a CFArray of 4 CFNumbers representing alpha, red, green, and blue fields with values between 0.0 and 1.0. The red, green and blue components are interpreted in the sRGB color space. The alpha indicates the opacity from 0.0 for transparent to 1.0 for 100% opaque.

      • kCMTextMarkupAttribute_BackgroundColorARGB

        public static CFStringRef kCMTextMarkupAttribute_BackgroundColorARGB()
        [@const] kCMTextMarkupAttribute_BackgroundColorARGB The background color for the shape holding the text. Value must be a CFArray of 4 CFNumbers representing alpha, red, green, and blue fields with values between 0.0 and 1.0. The red, green and blue components are interpreted in the sRGB color space. The alpha indicates the opacity from 0.0 for transparent to 1.0 for 100% opaque. The color applies to the geometry (e.g., a box) containing the text. The container's background color may have an alpha of 0 so it is not displayed even though the text is displayed. The color behind individual characters is optionally controllable with the kCMTextMarkupAttribute_CharacterBackgroundColorARGB attribute. If used, this attribute must be applied to the entire attributed string (i.e., CFRangeMake(0, CFAttributedStringGetLength(...))).

      • kCMTextMarkupAttribute_CharacterBackgroundColorARGB

        public static CFStringRef kCMTextMarkupAttribute_CharacterBackgroundColorARGB()
        [@const] kCMTextMarkupAttribute_CharacterBackgroundColorARGB The background color behind individual text characters. Value must be a CFArray of 4 CFNumbers representing alpha, red, green, and blue fields with values between 0.0 and 1.0. The red, green and blue components are interpreted in the sRGB color space. The alpha indicates the opacity from 0.0 for transparent to 1.0 for 100% opaque.

      • kCMTextMarkupAttribute_BoldStyle

        public static CFStringRef kCMTextMarkupAttribute_BoldStyle()
        [@const] kCMTextMarkupAttribute_BoldStyle Allows the setting of a bold style to be applied. Value must be a CFBoolean. The default is kCFBooleanFalse. If this attribute is kCFBooleanTrue, the text will be drawn with a bold style. Other styles such as italic may or may not be used as well.

      • kCMTextMarkupAttribute_ItalicStyle

        public static CFStringRef kCMTextMarkupAttribute_ItalicStyle()
        [@const] kCMTextMarkupAttribute_ItalicStyle Allows the setting of an italic style to be applied. Value must be a CFBoolean. The default is kCFBooleanFalse. If this attribute is kCFBooleanTrue, the text will be rendered with an italic style. Other styles such as bold may or may not be used as well.

      • kCMTextMarkupAttribute_UnderlineStyle

        public static CFStringRef kCMTextMarkupAttribute_UnderlineStyle()
        [@const] kCMTextMarkupAttribute_UnderlineStyle Allows the setting of an underline to be applied at render time. Value must be a CFBoolean. The default is kCFBooleanFalse. If this attribute is kCFBooleanTrue, the text will be rendered with an underline. Other styles such as bold may or may not be used as well.

      • kCMTextMarkupAttribute_FontFamilyName

        public static CFStringRef kCMTextMarkupAttribute_FontFamilyName()
        [@const] kCMTextMarkupAttribute_FontFamilyName The name of the font. Value must be a CFString holding the family name of an installed font (e.g., "Helvetica") that is used to render and/or measure text. When vended by legible output, an attributed string will have at most one of kCMTextMarkupAttribute_FontFamilyName or kCMTextMarkupAttribute_GenericFontFamilyName associated with each character.

      • kCMTextMarkupAttribute_GenericFontFamilyName

        public static CFStringRef kCMTextMarkupAttribute_GenericFontFamilyName()
        [@const] kCMTextMarkupAttribute_GenericFontFamilyName The attribute holding a generic font family identifier. Value must be a CFString holding a generic font family name that is one of the kCMTextMarkupGenericFontName_* constants. Generic fonts must be mapped to the family name of an installed font (e.g., kCMTextMarkupGenericFontName_SansSerif -> "Helvetica") before rendering and/or measuring text. When vended by legible output, an attributed string will have at most one of kCMTextMarkupAttribute_FontFamilyName or kCMTextMarkupAttribute_GenericFontFamilyName associated with each character. Overview of Generic Font Family Names ===================================== Some media formats allow the specification of font family names to be used to style text they carry. Sometimes, an external specification (e.g., CSS) may be used to style the text carried by the media format. In either case, the specification may be concrete, indicating an installed platform font (e.g., "Times New Roman", Helvetica). It may be abstract, indicating a category of font to use (e.g., serif, sans-serif). This abstract designation is often termed a "generic font family". CSS for example allows a 'font-family' property specification such as this: font-family: Helvetica, sans-serif; This uses both the concrete family name "Helvetica" and the generic family name "sans-serif". Generic font families may be common across media formats (e.g., both CSS and 3GPP timed text allow "sans-serif" and "serif"). Other formats may have generic font identifiers that do not align exactly (e.g., TTML allows "monospaceSerif and "monospaceSansSerif" in addition to "monospace"). Some formats might not carry names but have numeric values mapping to a generic font identifier. Simply put, different formats use different ways to express their generic fonts. The use of generic font families is also important for media accessibility. The Media Accessibility framework can map eight categories of abstract fonts to an installed font. Users may choose to override each of these categories to a different installed font. This remapping should work if the content or external styling indicates a generic font. It should not however try to remap a concrete font like "Helvetica". Consequently, it is important to distinguish between the generic and concrete fonts expressed by the author. To accommodate what is expressible in media formats and to support media accessibility overrides, generic font families can be specified with the kCMTextMarkupAttribute_GenericFontFamilyName attribute which carries the identifier for one of the various generic font specification forms supported across media formats. These generic font identifiers are the kCMTextMarkupGenericFontName_* prefixed constants also defined here. New identifers may be added in the future. Concrete fonts are specified using the kCMTextMarkupAttribute_FontFamilyName attribute also defined in this header.

      • kCMTextMarkupGenericFontName_Default

        public static CFStringRef kCMTextMarkupGenericFontName_Default()
        Values for kCMTextMarkupAttribute_GenericFontFamilyName. [@const] kCMTextMarkupGenericFontName_Default The generic font name indicating the default font. The default font may also be chosen if no font family is specified (i.e., no kCMTextMarkupAttribute_FontFamilyName or kCMTextMarkupAttribute_GenericFontFamilyName is specified). [@const] kCMTextMarkupGenericFontName_Serif The generic font name indicating a font with serifs. The font may be proportional or monospaced. E.g., Times New Roman [@const] kCMTextMarkupGenericFontName_SansSerif The generic font name indicating a font without serifs. The font may be proportional or monospaced. E.g., Helvetica [@const] kCMTextMarkupGenericFontName_Monospace The generic font name indicating a monospaced font, with or without serifs. E.g., Courier [@const] kCMTextMarkupGenericFontName_ProportionalSerif The generic font name indicating a proportional font with serifs. [@const] kCMTextMarkupGenericFontName_ProportionalSansSerif The generic font name indicating a proportional font without serifs. [@const] kCMTextMarkupGenericFontName_MonospaceSerif The generic font name indicating a monospaced font with serifs. [@const] kCMTextMarkupGenericFontName_MonospaceSansSerif The generic font name indicating a monospaced font without serifs. [@const] kCMTextMarkupGenericFontName_Casual The generic font name indicating a "casual" font. E.g., Dom or Impress [@const] kCMTextMarkupGenericFontName_Cursive The generic font name indicating a cursive font. E.g., Coronet or Marigold [@const] kCMTextMarkupGenericFontName_Fantasy The generic font name indicating a "fantasy" font. [@const] kCMTextMarkupGenericFontName_SmallCapital The generic font name indicating a font with lowercase letters set as small capitals. E.g., Engravers Gothic

      • kCMTextMarkupGenericFontName_Serif

        public static CFStringRef kCMTextMarkupGenericFontName_Serif()

      • kCMTextMarkupGenericFontName_SansSerif

        public static CFStringRef kCMTextMarkupGenericFontName_SansSerif()

      • kCMTextMarkupGenericFontName_Monospace

        public static CFStringRef kCMTextMarkupGenericFontName_Monospace()

      • kCMTextMarkupGenericFontName_ProportionalSerif

        public static CFStringRef kCMTextMarkupGenericFontName_ProportionalSerif()

      • kCMTextMarkupGenericFontName_ProportionalSansSerif

        public static CFStringRef kCMTextMarkupGenericFontName_ProportionalSansSerif()

      • kCMTextMarkupGenericFontName_MonospaceSerif

        public static CFStringRef kCMTextMarkupGenericFontName_MonospaceSerif()

      • kCMTextMarkupGenericFontName_MonospaceSansSerif

        public static CFStringRef kCMTextMarkupGenericFontName_MonospaceSansSerif()

      • kCMTextMarkupGenericFontName_Casual

        public static CFStringRef kCMTextMarkupGenericFontName_Casual()

      • kCMTextMarkupGenericFontName_Cursive

        public static CFStringRef kCMTextMarkupGenericFontName_Cursive()

      • kCMTextMarkupGenericFontName_Fantasy

        public static CFStringRef kCMTextMarkupGenericFontName_Fantasy()

      • kCMTextMarkupGenericFontName_SmallCapital

        public static CFStringRef kCMTextMarkupGenericFontName_SmallCapital()

      • kCMTextMarkupAttribute_BaseFontSizePercentageRelativeToVideoHeight

        public static CFStringRef kCMTextMarkupAttribute_BaseFontSizePercentageRelativeToVideoHeight()
        [@const] kCMTextMarkupAttribute_BaseFontSizePercentageRelativeToVideoHeight The base font size expressed as a percentage of the video height. Value must be a non-negative CFNumber. This is a number holding a percentage of the height of the video frame. For example, a value of 5 indicates that the base font size should be 5% of the height of the video.

      • kCMTextMarkupAttribute_RelativeFontSize

        public static CFStringRef kCMTextMarkupAttribute_RelativeFontSize()
        [@const] kCMTextMarkupAttribute_RelativeFontSize The font size expressed as a percentage of the current default font size. Value must be a non-negative CFNumber. This is a number holding a percentage of the size of the calculated default font size. A value of 120 indicates 20% larger than the default font size. A value of 80 indicates 80% of the default font size. The value 100 indicates no size difference and is the default.

      • kCMTextMarkupAttribute_VerticalLayout

        public static CFStringRef kCMTextMarkupAttribute_VerticalLayout()
        [@const] kCMTextMarkupAttribute_VerticalLayout The kind of vertical layout of the text block. Value must be a CFString. A CFString holding one of several values indicating the progression direction for new vertical lines of text. If this attribute is present, it indicates the writing direction is vertical. The attribute value indicates whether new vertical text lines are added from left to right or from right to left. If this attribute is missing, the writing direction is horizontal. If used, this attribute must be applied to the entire attributed string (i.e., CFRangeMake(0, CFAttributedStringGetLength(...))).

      • kCMTextVerticalLayout_LeftToRight

        public static CFStringRef kCMTextVerticalLayout_LeftToRight()
        Values for kCMTextMarkupAttribute_VerticalLayout. [@const] kCMTextVerticalLayout_LeftToRight Newly added vertical lines are added from the left toward the right. [@const] kCMTextVerticalLayout_RightToLeft Newly added vertical lines are added from the right toward the left.

      • kCMTextVerticalLayout_RightToLeft

        public static CFStringRef kCMTextVerticalLayout_RightToLeft()

      • kCMTextMarkupAttribute_Alignment

        public static CFStringRef kCMTextMarkupAttribute_Alignment()
        [@const] kCMTextMarkupAttribute_Alignment The alignment of text in the writing direction of the first line of text. Value must be a CFString. A CFString holding one of several values indicating the alignment in the writing direction of the first line of text of the cue. The writing direction is indicated by the value (or absence) of the kCMTextMarkupAttribute_VerticalLayout. If this attribute is missing, the kCMTextMarkupAlignmentType_Middle value should be used as the default. If used, this attribute must be applied to the entire attributed string (i.e., CFRangeMake(0, CFAttributedStringGetLength(...))).

      • kCMTextMarkupAlignmentType_Start

        public static CFStringRef kCMTextMarkupAlignmentType_Start()
        Values for kCMTextMarkupAttribute_Alignment. [@const] kCMTextMarkupAlignmentType_Start The text is visually aligned at its starting side. For horizontally written text, the alignment is left for left-to-right text and right for right-to-left text. For vertical text, alignment is always at the top. [@const] kCMTextMarkupAlignmentType_Middle The text is visually center-aligned (i.e., aligned between its starting and ending sides). [@const] kCMTextMarkupAlignmentType_End The text is visually aligned at its ending side. For horizontally written text, the alignment is right for left-to-right text and left for right-to-left text. For vertical text, alignment is always at the bottom. [@const] kCMTextMarkupAlignmentType_Left For horizontally written text, the text alignment is always visually left-aligned (i.e., left-to-right and right-to-left are treated uniformly). For vertical text, this is equivalent to kCMTextMarkupAlignmentType_Start. While readers should be prepared to account for kCMTextMarkupAlignmentType_Left being equivalent to kCMTextMarkupAlignmentType_Start for vertical text, authors are discouraged from using kCMTextMarkupAlignmentType_Left for vertical text. [@const] kCMTextMarkupAlignmentType_Right For horizontally written text, the text alignment is always visually right-aligned (i.e., left-to-right and right-to-left are treated uniformly). For vertical text, this is equivalent to kCMTextMarkupAlignmentType_End. While readers should be prepared to account for kCMTextMarkupAlignmentType_Right being equivalent to kCMTextMarkupAlignmentType_End for vertical text, authors are discouraged from using kCMTextMarkupAlignmentType_Right for vertical text.

      • kCMTextMarkupAlignmentType_Middle

        public static CFStringRef kCMTextMarkupAlignmentType_Middle()

      • kCMTextMarkupAlignmentType_End

        public static CFStringRef kCMTextMarkupAlignmentType_End()

      • kCMTextMarkupAlignmentType_Left

        public static CFStringRef kCMTextMarkupAlignmentType_Left()

      • kCMTextMarkupAlignmentType_Right

        public static CFStringRef kCMTextMarkupAlignmentType_Right()

      • kCMTextMarkupAttribute_TextPositionPercentageRelativeToWritingDirection

        public static CFStringRef kCMTextMarkupAttribute_TextPositionPercentageRelativeToWritingDirection()
        [@const] kCMTextMarkupAttribute_TextPositionPercentageRelativeToWritingDirection The placement of the block of text specified as a percentage in the writing direction. Value must be a non-negative CFNumber. A CFNumber expressing the position of the center of the text in the writing direction as a percentage of the video dimensions in the writing direction. For horizontal cues, this is the horizontal position. For vertical, it is the vertical position. The percentage is calculated from the edge of the frame where the text begins (so for left-to-right English, it is the left edge). If used, this attribute must be applied to the entire attributed string (i.e., CFRangeMake(0, CFAttributedStringGetLength(...))).

      • kCMTextMarkupAttribute_OrthogonalLinePositionPercentageRelativeToWritingDirection

        public static CFStringRef kCMTextMarkupAttribute_OrthogonalLinePositionPercentageRelativeToWritingDirection()
        [@const] kCMTextMarkupAttribute_OrthogonalLinePositionPercentageRelativeToWritingDirection The placement of the block of text's first line specified as a percentage in the direction orthogonal to the writing direction. Value must be a non-negative CFNumber. A CFNumber expressing the position of the center of the cue relative to the writing direction. The line position is orthogonal (or perpendicular) to the writing direction (i.e., for a horizontal writing direction, it is vertical and for a vertical writing direction, is is horizontal). This attribute expresses the line position as a percentage of the dimensions of the video frame in the relevant direction. For example, 0% is the top of the video frame and 100% is the bottom of the video frame for horizontal writing layout. If used, this attribute must be applied to the entire attributed string (i.e., CFRangeMake(0, CFAttributedStringGetLength(...))).

      • kCMTextMarkupAttribute_WritingDirectionSizePercentage

        public static CFStringRef kCMTextMarkupAttribute_WritingDirectionSizePercentage()
        [@const] kCMTextMarkupAttribute_WritingDirectionSizePercentage The dimension (e.g., width) of the bounding box containing the text expressed as a percentage. Value must be a non-negative CFNumber. A CFNumber expressing the width of the bounding box for text layout as a percentage of the video frame's dimension in the writing direction. For a horizontal writing direction, it is the width. For a vertical writing direction, it is the horizontal writing direction. If used, this attribute must be applied to the entire attributed string (i.e., CFRangeMake(0, CFAttributedStringGetLength(...))).

      • kCMTextMarkupAttribute_CharacterEdgeStyle

        public static CFStringRef kCMTextMarkupAttribute_CharacterEdgeStyle()
        [@const] kCMTextMarkupAttribute_CharacterEdgeStyle Allows the setting of the style of character edges at render time. Value must be a CFString. This controls the shape of the edges of drawn characters. Set a value of something other than kCMTextMarkupEdgeStyle_None to draw using an alternative shape for edges of characters from the set of constants prefixed with "kCMTextMarkupEdgeStyle_". These correspond to text edge styles available with Media Accessibility preferences (see ) although the values are not enumerated integers here. The absence of this attribute should be treated as though kCMTextMarkupCharacterEdgeStyle_None is specified.

      • kCMTextMarkupCharacterEdgeStyle_None

        public static CFStringRef kCMTextMarkupCharacterEdgeStyle_None()
        Values for kCMTextMarkupAttribute_CharacterEdgeStyle. [@const] kCMTextMarkupCharacterEdgeStyle_None The character edge style indicating no edge style. [@const] kCMTextMarkupCharacterEdgeStyle_Raised The character edge style indicating a raised edge style should be drawn. [@const] kCMTextMarkupCharacterEdgeStyle_Depressed The character edge style indicating a depressed edge style should be drawn. [@const] kCMTextMarkupCharacterEdgeStyle_Uniform The character edge style indicating a uniform border around the character should be drawn. [@const] kCMTextMarkupCharacterEdgeStyle_DropShadow The character edge style indicating a drop shadow should be drawn.

      • kCMTextMarkupCharacterEdgeStyle_Raised

        public static CFStringRef kCMTextMarkupCharacterEdgeStyle_Raised()

      • kCMTextMarkupCharacterEdgeStyle_Depressed

        public static CFStringRef kCMTextMarkupCharacterEdgeStyle_Depressed()

      • kCMTextMarkupCharacterEdgeStyle_Uniform

        public static CFStringRef kCMTextMarkupCharacterEdgeStyle_Uniform()

      • kCMTextMarkupCharacterEdgeStyle_DropShadow

        public static CFStringRef kCMTextMarkupCharacterEdgeStyle_DropShadow()

      • kCMMetadataKeySpace_QuickTimeUserData

        public static CFStringRef kCMMetadataKeySpace_QuickTimeUserData()
        [@const] kCMMetadataKeySpace_QuickTimeUserData Metadata keyspace for QuickTime User Data keys. [@const] kCMMetadataKeySpace_ISOUserData Metadata keyspace for MPEG-4 User Data keys. [@const] kCMMetadataKeySpace_QuickTimeMetadata Metadata keyspace for QuickTime Metadata keys. [@const] kCMMetadataKeySpace_iTunes Metadata keyspace for iTunes keys. [@const] kCMMetadataKeySpace_ID3 Metadata keyspace for ID3 keys. [@const] kCMMetadataKeySpace_Icy Metadata keyspace for ShoutCast keys. [@const] kCMMetadataKeySpace_HLSDateRange Metadata keyspace for HLS DateRange tags.

      • kCMMetadataKeySpace_ISOUserData

        public static CFStringRef kCMMetadataKeySpace_ISOUserData()

      • kCMMetadataKeySpace_QuickTimeMetadata

        public static CFStringRef kCMMetadataKeySpace_QuickTimeMetadata()

      • kCMMetadataKeySpace_iTunes

        public static CFStringRef kCMMetadataKeySpace_iTunes()

      • kCMMetadataKeySpace_ID3

        public static CFStringRef kCMMetadataKeySpace_ID3()

      • kCMMetadataKeySpace_Icy

        public static CFStringRef kCMMetadataKeySpace_Icy()

      • kCMMetadataKeySpace_HLSDateRange

        public static CFStringRef kCMMetadataKeySpace_HLSDateRange()

      • kCMMetadataIdentifier_QuickTimeMetadataLocation_ISO6709

        public static CFStringRef kCMMetadataIdentifier_QuickTimeMetadataLocation_ISO6709()
        [@const] kCMMetadataIdentifier_QuickTimeMetadataLocation_ISO6709 Location information in ISO-6709 format. [@const] kCMMetadataIdentifier_QuickTimeMetadataDirection_Facing Direction the observer is facing.

      • kCMMetadataIdentifier_QuickTimeMetadataDirection_Facing

        public static CFStringRef kCMMetadataIdentifier_QuickTimeMetadataDirection_Facing()

      • kCMMetadataIdentifier_QuickTimeMetadataPreferredAffineTransform

        public static CFStringRef kCMMetadataIdentifier_QuickTimeMetadataPreferredAffineTransform()
        [@const] kCMMetadataIdentifier_QuickTimeMetadataPreferredAffineTransform An affine transform that can be used in place of a track matrix for displaying a video track, to better reflect the current orientation of a video camera with respect to a scene. For example, if the camera is rotated after a recording has started, the presence of this metadata will allow a player to adjust its rendering at the time the rotation occurred.

      • kCMMetadataIdentifier_QuickTimeMetadataVideoOrientation

        public static CFStringRef kCMMetadataIdentifier_QuickTimeMetadataVideoOrientation()
        [@const] kCMMetadataIdentifier_QuickTimeMetadataVideoOrientation Video orientation as defined by TIFF/EXIF, which is enumerated by CGImagePropertyOrientation (see ).

      • kCMMetadataBaseDataType_RawData

        public static CFStringRef kCMMetadataBaseDataType_RawData()
        [@const] kCMMetadataBaseDataType_RawData A sequence of bytes whose interpretation based upon an agreement between the reader and the writer. [@const] kCMMetadataBaseDataType_UTF8 UTF-8 string. [@const] kCMMetadataBaseDataType_UTF16 UTF-16 string. [@const] kCMMetadataBaseDataType_GIF GIF image. [@const] kCMMetadataBaseDataType_JPEG JPEG image. [@const] kCMMetadataBaseDataType_PNG PNG image. [@const] kCMMetadataBaseDataType_BMP BMP image. [@const] kCMMetadataBaseDataType_Float32 32-bit big endian floating point number. [@const] kCMMetadataBaseDataType_Float64 64-bit big endian floating point number. [@const] kCMMetadataBaseDataType_SInt8 8-bit signed integer. [@const] kCMMetadataBaseDataType_SInt16 16-bit big endian signed integer. [@const] kCMMetadataBaseDataType_SInt32 32-bit big endian signed integer. [@const] kCMMetadataBaseDataType_SInt64 64-bit big endian signed integer. [@const] kCMMetadataBaseDataType_UInt8 8-bit unsigned integer. [@const] kCMMetadataBaseDataType_UInt16 16-bit big endian unsigned integer. [@const] kCMMetadataBaseDataType_UInt32 32-bit big endian unsigned integer. [@const] kCMMetadataBaseDataType_UInt64 64-bit big endian unsigned integer. [@const] kCMMetadataBaseDataType_PointF32 Consists of two 32-bit big endian floating point values, the x and y values, respectively. [@const] kCMMetadataBaseDataType_DimensionsF32 Consists of a 32-bit big endian floating point x value followed by a 32-bit floating point y value. [@const] kCMMetadataBaseDataType_RectF32 Consists of four 32-bit big endian floating point values, the origin's x, origin's y, width and height values, respectively. May also be interpreted as a 32-bit floating point origin followed by a 32-bit floating point dimension. [@const] kCMMetadataDataType_AffineTransformF64 A 3x3 matrix of 64-bit big endian floating point numbers stored in row-major order that specify an affine transform. [@const] kCMMetadataBaseDataType_PolygonF32 Three or more pairs of 32-bit floating point numbers (x and y values) that define the verticies of a polygon. [@const] kCMMetadataBaseDataType_PolylineF32 Two or more pairs of 32-bit floating point numbers (x and y values) that define a multi-segmented line. [@const] kCMMetadataBaseDataType_JSON UTF-8 encoded JSON data. [@const] kCMMetadataBaseDataType_PerspectiveTransformF64 A 3x3 matrix of 64-bit big endian floating point numbers stored in row-major order that specify a perspective transform.

      • kCMMetadataBaseDataType_UTF8

        public static CFStringRef kCMMetadataBaseDataType_UTF8()

      • kCMMetadataBaseDataType_UTF16

        public static CFStringRef kCMMetadataBaseDataType_UTF16()

      • kCMMetadataBaseDataType_GIF

        public static CFStringRef kCMMetadataBaseDataType_GIF()

      • kCMMetadataBaseDataType_JPEG

        public static CFStringRef kCMMetadataBaseDataType_JPEG()

      • kCMMetadataBaseDataType_PNG

        public static CFStringRef kCMMetadataBaseDataType_PNG()

      • kCMMetadataBaseDataType_BMP

        public static CFStringRef kCMMetadataBaseDataType_BMP()

      • kCMMetadataBaseDataType_Float32

        public static CFStringRef kCMMetadataBaseDataType_Float32()

      • kCMMetadataBaseDataType_Float64

        public static CFStringRef kCMMetadataBaseDataType_Float64()

      • kCMMetadataBaseDataType_SInt8

        public static CFStringRef kCMMetadataBaseDataType_SInt8()

      • kCMMetadataBaseDataType_SInt16

        public static CFStringRef kCMMetadataBaseDataType_SInt16()

      • kCMMetadataBaseDataType_SInt32

        public static CFStringRef kCMMetadataBaseDataType_SInt32()

      • kCMMetadataBaseDataType_SInt64

        public static CFStringRef kCMMetadataBaseDataType_SInt64()

      • kCMMetadataBaseDataType_UInt8

        public static CFStringRef kCMMetadataBaseDataType_UInt8()

      • kCMMetadataBaseDataType_UInt16

        public static CFStringRef kCMMetadataBaseDataType_UInt16()

      • kCMMetadataBaseDataType_UInt32

        public static CFStringRef kCMMetadataBaseDataType_UInt32()

      • kCMMetadataBaseDataType_UInt64

        public static CFStringRef kCMMetadataBaseDataType_UInt64()

      • kCMMetadataBaseDataType_PointF32

        public static CFStringRef kCMMetadataBaseDataType_PointF32()

      • kCMMetadataBaseDataType_DimensionsF32

        public static CFStringRef kCMMetadataBaseDataType_DimensionsF32()

      • kCMMetadataBaseDataType_RectF32

        public static CFStringRef kCMMetadataBaseDataType_RectF32()

      • kCMMetadataBaseDataType_AffineTransformF64

        public static CFStringRef kCMMetadataBaseDataType_AffineTransformF64()

      • kCMMetadataBaseDataType_PolygonF32

        public static CFStringRef kCMMetadataBaseDataType_PolygonF32()

      • kCMMetadataBaseDataType_PolylineF32

        public static CFStringRef kCMMetadataBaseDataType_PolylineF32()

      • kCMMetadataBaseDataType_JSON

        public static CFStringRef kCMMetadataBaseDataType_JSON()

      • kCMMetadataDataType_QuickTimeMetadataLocation_ISO6709

        public static CFStringRef kCMMetadataDataType_QuickTimeMetadataLocation_ISO6709()
        [@const] kCMMetadataDataType_Location_ISO6709 A string supplying location information in ISO-6709 format. Conforms to kCMMetadataBaseDataType_UTF8. [@const] kCMMetadataDataType_Direction A string supplying degrees offset from magnetic North. Conforms to kCMMetadataBaseDataType_UTF8.

      • kCMMetadataDataType_QuickTimeMetadataDirection

        public static CFStringRef kCMMetadataDataType_QuickTimeMetadataDirection()

      • CMVideoFormatDescriptionCreateFromHEVCParameterSets

        public static int CMVideoFormatDescriptionCreateFromHEVCParameterSets​(CFAllocatorRef allocator,
                                                                      long parameterSetCount,
                                                                      java.lang.String[] parameterSetPointers,
                                                                      org.moe.natj.general.ptr.ConstNUIntPtr parameterSetSizes,
                                                                      int NALUnitHeaderLength,
                                                                      CFDictionaryRef extensions,
                                                                      org.moe.natj.general.ptr.Ptr<CMFormatDescriptionRef> formatDescriptionOut)
        [@function] CMVideoFormatDescriptionCreateFromHEVCParameterSets Creates a format description for a video media stream described by HEVC (H.265) parameter set NAL units. This function parses the dimensions provided by the parameter sets and creates a format description suitable for a raw H.265 stream. The parameter sets' data can come from raw NAL units and must have any emulation prevention bytes needed. The supported NAL unit types to be included in the format description are 32 (video parameter set), 33 (sequence parameter set), 34 (picture parameter set), 39 (prefix SEI) and 40 (suffix SEI). At least one of each parameter set must be provided.

      • CMVideoFormatDescriptionGetHEVCParameterSetAtIndex

        public static int CMVideoFormatDescriptionGetHEVCParameterSetAtIndex​(CMFormatDescriptionRef videoDesc,
                                                                     long parameterSetIndex,
                                                                     java.lang.String[] parameterSetPointerOut,
                                                                     org.moe.natj.general.ptr.NUIntPtr parameterSetSizeOut,
                                                                     org.moe.natj.general.ptr.NUIntPtr parameterSetCountOut,
                                                                     org.moe.natj.general.ptr.IntPtr NALUnitHeaderLengthOut)
        [@function] CMVideoFormatDescriptionGetHEVCParameterSetAtIndex Returns a parameter set contained in a HEVC (H.265) format description. This function parses the HEVC decoder configuration record contained in a H.265 video format description and returns the NAL unit at the given index from it. These NAL units are typically parameter sets (e.g. VPS, SPS, PPS), but may contain others as specified by ISO/IEC 14496-15 (e.g. user-data SEI). Both parameterSetPointerOut and parameterSetSizeOut may be NULL, parameterSetCountOut will return the total number of parameter set NAL units contained in the HEVC decoder configuration record. The parameter set NAL units returned will already have any emulation prevention bytes needed. The pointer returned in parameterSetPointerOut points to internal memory of videoDesc, and may only be accessed as long as a retain on videoDesc is held.

      • kCMFormatDescriptionTransferFunction_SMPTE_ST_2084_PQ

        public static CFStringRef kCMFormatDescriptionTransferFunction_SMPTE_ST_2084_PQ()
        same as kCVImageBufferTransferFunction_SMPTE_ST_2084_PQ

      • kCMFormatDescriptionTransferFunction_ITU_R_2100_HLG

        public static CFStringRef kCMFormatDescriptionTransferFunction_ITU_R_2100_HLG()
        same as kCVImageBufferTransferFunction_ITU_R_2100_HLG

      • kCMFormatDescriptionExtension_MasteringDisplayColorVolume

        public static CFStringRef kCMFormatDescriptionExtension_MasteringDisplayColorVolume()
        CFData(24 bytes); big-endian structure; same as kCVImageBufferMasteringDisplayColorVolumeKey; matches payload of ISO/IEC 23008-2:2015(E), D.2.28 Mastering display colour volume SEI message

      • kCMFormatDescriptionExtension_ContentLightLevelInfo

        public static CFStringRef kCMFormatDescriptionExtension_ContentLightLevelInfo()
        CFData(4 bytes); big-endian structure; same as kCVImageBufferContentLightLevelInfoKey

      • kCMSampleAttachmentKey_HEVCTemporalLevelInfo

        public static CFStringRef kCMSampleAttachmentKey_HEVCTemporalLevelInfo()
        CFDictionary(kCMHEVCTemporalLevelInfoKey_*), optional. Corresponds to 'tscl' sample group.

      • kCMHEVCTemporalLevelInfoKey_TemporalLevel

        public static CFStringRef kCMHEVCTemporalLevelInfoKey_TemporalLevel()
        CFNumber(Int)

      • kCMHEVCTemporalLevelInfoKey_ProfileSpace

        public static CFStringRef kCMHEVCTemporalLevelInfoKey_ProfileSpace()
        CFNumber(Int)

      • kCMHEVCTemporalLevelInfoKey_TierFlag

        public static CFStringRef kCMHEVCTemporalLevelInfoKey_TierFlag()
        CFNumber(Int)

      • kCMHEVCTemporalLevelInfoKey_ProfileIndex

        public static CFStringRef kCMHEVCTemporalLevelInfoKey_ProfileIndex()
        CFNumber(Int)

      • kCMHEVCTemporalLevelInfoKey_ProfileCompatibilityFlags

        public static CFStringRef kCMHEVCTemporalLevelInfoKey_ProfileCompatibilityFlags()
        CFData(4 bytes)

      • kCMHEVCTemporalLevelInfoKey_ConstraintIndicatorFlags

        public static CFStringRef kCMHEVCTemporalLevelInfoKey_ConstraintIndicatorFlags()
        CFData(6 bytes)

      • kCMHEVCTemporalLevelInfoKey_LevelIndex

        public static CFStringRef kCMHEVCTemporalLevelInfoKey_LevelIndex()
        CFNumber(Int)

      • kCMSampleAttachmentKey_HEVCTemporalSubLayerAccess

        public static CFStringRef kCMSampleAttachmentKey_HEVCTemporalSubLayerAccess()
        CFBoolean, optional. Corresponds to 'tsas' sample group.

      • kCMSampleAttachmentKey_HEVCStepwiseTemporalSubLayerAccess

        public static CFStringRef kCMSampleAttachmentKey_HEVCStepwiseTemporalSubLayerAccess()
        CFBoolean, optional. Corresponds to 'stsa' sample group.

      • kCMSampleAttachmentKey_HEVCSyncSampleNALUnitType

        public static CFStringRef kCMSampleAttachmentKey_HEVCSyncSampleNALUnitType()
        CFNumber(Int), optional. Corresponds to 'sync' sample group.

      • kCMSampleBufferAttachmentKey_CameraIntrinsicMatrix

        public static CFStringRef kCMSampleBufferAttachmentKey_CameraIntrinsicMatrix()
        CFData (matrix_float3x3)

      • CMTimeFoldIntoRange

        public static CMTime CMTimeFoldIntoRange​(CMTime time,
                                         CMTimeRange foldRange)
        [@function] CMTimeFoldIntoRange Folds a time into the given range. This can be used in looping time calculations. Note that for certain types of looping, you may want to NOT fold times that are prior to the loop range. That's up to the client.
        Returns:
        A CMTime structure representing the translated duration.

      • CMTimebaseSetMasterClock

        public static int CMTimebaseSetMasterClock​(CMTimebaseRef timebase,
                                           CMClockRef newMasterClock)
        [@function] 0 Sets the master clock of a timebase. The timebase will stop being mastered by its current master clock or master timebase, and will change to be mastered by the new master clock. Prior to the change a kCMTimebaseNotification_MasterWillChange will be posted. When the change has completed, a kCMTimebaseNotification_MasterDidChange notification will be posted. The current master clock or master timebase of the timebase being modified will be released.

      • CMTimebaseSetMasterTimebase

        public static int CMTimebaseSetMasterTimebase​(CMTimebaseRef timebase,
                                              CMTimebaseRef newMasterTimebase)
        [@function] CMTimebaseSetMasterTimebase Sets the master timebase of a timebase. The timebase will stop being mastered by its current master clock or master timebase, and will change to be mastered by the new master timebase. Prior to the change a kCMTimebaseNotification_MasterWillChange will be posted. When the change has completed, a kCMTimebaseNotification_MasterDidChange notification will be posted. The current master clock or master timebase of the timebase being modified will be released.

      • CMBufferQueueCreateWithHandlers

        public static int CMBufferQueueCreateWithHandlers​(CFAllocatorRef allocator,
                                                  long capacity,
                                                  org.moe.natj.general.ptr.VoidPtr handlers,
                                                  org.moe.natj.general.ptr.Ptr<CMBufferQueueRef> queueOut)
        [@function] CMBufferQueueCreateWithHandlers Creates a CMBufferQueue object. On return, the caller owns the returned CMBufferQueue, and must release it when done with it.

      • CMBufferQueueInstallTriggerHandler

        public static int CMBufferQueueInstallTriggerHandler​(CMBufferQueueRef queue,
                                                     int condition,
                                                     CMTime time,
                                                     org.moe.natj.general.ptr.Ptr<CMBufferQueueTriggerToken> triggerTokenOut,
                                                     CoreMedia.Block_CMBufferQueueInstallTriggerHandler handler)
        [@function] CMBufferQueueInstallTriggerHandler Installs a trigger on a CMBufferQueue. The returned trigger token can be passed to CMBufferQueueTestTrigger and CMBufferQueueRemoveTrigger. The triggerTokenOut parameter can be NULL (client doesn't need to test or remove trigger), and the handler parameter can be NULL (client doesn't need callbacks, but rather will explicitly test the trigger). One of these two parameters must be non-NULL, however, since an untestable trigger that does not perform a callback is meaningless. If the trigger condition is already true, CMBufferQueueInstallTrigger will call the handler. If it does this, it will first write the trigger token to *triggerTokenOut.

      • CMBufferQueueInstallTriggerHandlerWithIntegerThreshold

        public static int CMBufferQueueInstallTriggerHandlerWithIntegerThreshold​(CMBufferQueueRef queue,
                                                                         int condition,
                                                                         long threshold,
                                                                         org.moe.natj.general.ptr.Ptr<CMBufferQueueTriggerToken> triggerTokenOut,
                                                                         CoreMedia.Block_CMBufferQueueInstallTriggerHandlerWithIntegerThreshold handler)
        [@function] CMBufferQueueInstallTriggerHandlerWithIntegerThreshold Installs a trigger on a CMBufferQueue. This function behaves the same way as CMBufferQueueInstallTriggerHandler() except the trigger is evaluated against the integer value rather than the time value.

      • CMBufferQueueSetValidationHandler

        public static int CMBufferQueueSetValidationHandler​(CMBufferQueueRef queue,
                                                    CoreMedia.Block_CMBufferQueueSetValidationHandler handler)
        [@function] CMBufferQueueSetValidationHandler Sets a block that CMBufferQueueEnqueue will call to validate buffers before adding them to the queue. Both a validation callback and a validation handler can be set at the same time, in which case they will both be called when enqueueing buffers. They both need to return noErr for the buffer to be enqueued.

      • kCMFormatDescriptionTransferFunction_Linear

        public static CFStringRef kCMFormatDescriptionTransferFunction_Linear()
        same as kCVImageBufferTransferFunction_Linear

      • kCMFormatDescriptionTransferFunction_sRGB

        public static CFStringRef kCMFormatDescriptionTransferFunction_sRGB()
        same as kCVImageBufferTransferFunction_sRGB

      • kCMFormatDescriptionExtension_AlternativeTransferCharacteristics

        public static CFStringRef kCMFormatDescriptionExtension_AlternativeTransferCharacteristics()
        CFString (usually kCMFormatDescriptionTransferFunction_ITU_R_2100_HLG when used); corresponds to D.2.38 Alternative Transfer Characteristics SEI message

      • kCMFormatDescriptionExtension_AuxiliaryTypeInfo

        public static CFStringRef kCMFormatDescriptionExtension_AuxiliaryTypeInfo()

      • kCMFormatDescriptionExtension_AlphaChannelMode

        public static CFStringRef kCMFormatDescriptionExtension_AlphaChannelMode()
        one of:

      • kCMFormatDescriptionAlphaChannelMode_StraightAlpha

        public static CFStringRef kCMFormatDescriptionAlphaChannelMode_StraightAlpha()

      • kCMFormatDescriptionAlphaChannelMode_PremultipliedAlpha

        public static CFStringRef kCMFormatDescriptionAlphaChannelMode_PremultipliedAlpha()

      • kCMFormatDescriptionExtension_ContainsAlphaChannel

        public static CFStringRef kCMFormatDescriptionExtension_ContainsAlphaChannel()
        CFBoolean; used to signal the presence of alpha channel in the bitstream.

      • kCMSampleAttachmentKey_AudioIndependentSampleDecoderRefreshCount

        public static CFStringRef kCMSampleAttachmentKey_AudioIndependentSampleDecoderRefreshCount()
        CFNumber(Int), optional.

      • kCMMetadataIdentifier_QuickTimeMetadataLivePhotoStillImageTransform

        public static CFStringRef kCMMetadataIdentifier_QuickTimeMetadataLivePhotoStillImageTransform()
        [@const] kCMMetadataIdentifier_QuickTimeMetadataLivePhotoStillImageTransform A perspective transform that can be used to adjust a Live Photo still image to match the Live Photo movie. Expected data type is kCMMetadataBaseDataType_PerspectiveTransformF64.

      • kCMMetadataIdentifier_QuickTimeMetadataLivePhotoStillImageTransformReferenceDimensions

        public static CFStringRef kCMMetadataIdentifier_QuickTimeMetadataLivePhotoStillImageTransformReferenceDimensions()
        [@const] kCMMetadataIdentifier_QuickTimeMetadataLivePhotoStillImageTransformReferenceDimensions The dimensions of the image used to generate kCMMetadataIdentifier_QuickTimeMetadataLivePhotoStillImageTransform. Expected data type is kCMMetadataBaseDataType_DimensionsF32.

      • kCMMetadataBaseDataType_PerspectiveTransformF64

        public static CFStringRef kCMMetadataBaseDataType_PerspectiveTransformF64()

      • kCMFormatDescriptionExtension_ProtectedContentOriginalFormat

        public static CFStringRef kCMFormatDescriptionExtension_ProtectedContentOriginalFormat()
        CNNumberRef as FourCharCode