objc2_video_toolbox/generated/

VTCompressionProperties.rs

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2_core_foundation::*;

use crate::*;

extern "C" {
    /// The number of pending frames in the compression session.
    ///
    /// This number may decrease asynchronously.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_numberofpendingframes?language=objc)
    pub static kVTCompressionPropertyKey_NumberOfPendingFrames: &'static CFString;
}

extern "C" {
    /// Indicates whether the a common pixel buffer pool is shared between
    /// the video encoder and the session client.
    ///
    /// This is false if separate pools are used because the video encoder's
    /// and the client's pixel buffer attributes were incompatible.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_pixelbufferpoolisshared?language=objc)
    pub static kVTCompressionPropertyKey_PixelBufferPoolIsShared: &'static CFString;
}

extern "C" {
    /// The video encoder's pixel buffer attributes for the compression session.
    ///
    /// You can use these to create a pixel buffer pool for source pixel buffers.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_videoencoderpixelbufferattributes?language=objc)
    pub static kVTCompressionPropertyKey_VideoEncoderPixelBufferAttributes: &'static CFString;
}

extern "C" {
    /// The maximum interval between key frames, also known as the key frame rate.
    ///
    /// Key frames, also known as sync frames, reset inter-frame
    /// dependencies; decoding a key frame is sufficient to prepare a
    /// decoder for correctly decoding the difference frames that
    /// follow.
    /// Video encoders are allowed to generate key frames more frequently if
    /// this would result in more efficient compression.
    /// The default key frame interval is 0, which indicates that the
    /// video encoder should choose where to place all key frames. A key
    /// frame interval of 1 indicates that every frame must be a key
    /// frame, 2 indicates that at least every other frame must be a key
    /// frame, etc.
    /// See also kVTCompressionPropertyKey_AllowTemporalCompression.
    ///
    /// This key can be set in conjunction with
    /// kVTCompressionPropertyKey_MaxKeyFrameIntervalDuration,
    /// and both limits will be enforced - requiring a keyframe every X
    /// frames or every Y seconds, whichever comes first.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_maxkeyframeinterval?language=objc)
    pub static kVTCompressionPropertyKey_MaxKeyFrameInterval: &'static CFString;
}

extern "C" {
    /// The maximum duration from one key frame to the next in seconds.
    ///
    /// Zero by default, which means no limit.
    /// This property is particularly useful when the frame rate is variable.
    /// See kVTCompressionPropertyKey_MaxKeyFrameInterval for more discussion
    /// of key frames.
    ///
    /// This key can be set in conjunction with
    /// kVTCompressionPropertyKey_MaxKeyFrameInterval,
    /// and both limits will be enforced - requiring a keyframe every X
    /// frames or every Y seconds, whichever comes first.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_maxkeyframeintervalduration?language=objc)
    pub static kVTCompressionPropertyKey_MaxKeyFrameIntervalDuration: &'static CFString;
}

extern "C" {
    /// Enables temporal compression.
    ///
    /// True by default.  Set this to false to require key-frame-only compression.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_allowtemporalcompression?language=objc)
    pub static kVTCompressionPropertyKey_AllowTemporalCompression: &'static CFString;
}

extern "C" {
    /// Enables frame reordering.
    ///
    /// In order to encode B frames, a video encoder must reorder frames,
    /// which means that the order in which they will be emitted and
    /// stored (the decode order) is different from the order in which
    /// they were presented to the video encoder (the display order).
    /// True by default.  Set this to false to prevent frame reordering.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_allowframereordering?language=objc)
    pub static kVTCompressionPropertyKey_AllowFrameReordering: &'static CFString;
}

extern "C" {
    /// Enables Open GOP (Group Of Pictures) encoding.
    ///
    /// Only applicable to certain video encoders.  For HEVC encoding the property value is kCFBooleanTrue by default - which means
    /// that the encoder may use Open GOP structures, but it is not guaranteed to.
    /// Set this to kCFBooleanFalse to prevent the encoder from using any form of Open GOP during encoding.
    /// If set to kCFBooleanFalse, this will mean that the encoder will generate groups of pictures that are independently decodable; there
    /// will be no frame dependencies across sync samples (frames where kCMSampleAttachmentKey_NotSync is absent or kCFBooleanFalse)
    /// When the value is kCFBooleanTrue, the encoder may use Open GOP frame dependency structures to increase compression efficiency or quality.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_allowopengop?language=objc)
    pub static kVTCompressionPropertyKey_AllowOpenGOP: &'static CFString;
}

extern "C" {
    /// The long-term desired average bit rate in bits per second.
    ///
    /// This is not a hard limit; the bit rate may peak above this.
    /// The default bit rate is zero, which indicates that the video encoder
    /// should determine the size of compressed data.
    /// Note that bit rate settings only have an effect when timing
    /// information is provided for source frames, and that some codecs do
    /// not support limiting to specified bit rates.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_averagebitrate?language=objc)
    pub static kVTCompressionPropertyKey_AverageBitRate: &'static CFString;
}

extern "C" {
    /// Zero, one or two hard limits on data rate.
    ///
    /// Each hard limit is described by a data size in bytes and a
    /// duration in seconds, and requires that the total size of
    /// compressed data for any contiguous segment of that duration (in
    /// decode time) must not exceed the data size.
    /// By default, no data rate limits are set.
    /// The property is a CFArray of an even number of CFNumbers,
    /// alternating between bytes and seconds.
    /// Note that data rate settings only have an effect when timing
    /// information is provided for source frames, and that some codecs do
    /// not support limiting to specified data rates.
    ///
    /// When both kVTCompressionPropertyKey_DataRateLimits and
    /// kVTCompressionPropertyKey_AverageBitRate are supported,
    /// it is recommended that kVTCompressionPropertyKey_AverageBitRate
    /// be set when kVTCompressionPropertyKey_DataRateLimits is set.
    /// If kVTCompressionPropertyKey_AverageBitRate is not specified,
    /// an overall average bit rate target will be selected at a safe margin below
    /// the kVTCompressionPropertyKey_DataRateLimits target, so that regional
    /// overshoot in the encoding will not exceed the
    /// kVTCompressionPropertyKey_DataRateLimits.
    /// The overall average bitrate target generated from
    /// kVTCompressionPropertyKey_DataRateLimits in the absence of
    /// kVTCompressionPropertyKey_AverageBitRate may not be ideal for all
    /// scenarios.
    /// Encoding is more likely to undershoot a requested
    /// kVTCompressionPropertyKey_AverageBitRate if the specified target is too
    /// close to a hard limit specified by kVTCompressionPropertyKey_DataRateLimits.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_dataratelimits?language=objc)
    pub static kVTCompressionPropertyKey_DataRateLimits: &'static CFString;
}

extern "C" {
    /// The desired compression quality.
    ///
    /// Some encoders, such as JPEG, describe the compression level of each
    /// image with a quality value.  This value should be specified as a
    /// number in the range of 0.0 to 1.0, where low = 0.25, normal = 0.50,
    /// high = 0.75, and 1.0 implies lossless compression for encoders that
    /// support it.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_quality?language=objc)
    pub static kVTCompressionPropertyKey_Quality: &'static CFString;
}

extern "C" {
    /// The target quality to use for encoding the alpha channel.
    ///
    /// The desired compression level to use for encoding the alpha channel.
    /// This value should be specified as a number in the range of 0.0 to 1.0.
    /// 0.0 is lowest quality and 1.0 implies nearly lossless.  Alpha plane
    /// bit rates will tend to increase with increasing values.  When encoding
    /// the alpha channel, quality is given priority over bitrate.  Note this
    /// parameter is currently only applicable to HEVC with Alpha encoders.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_targetqualityforalpha?language=objc)
    pub static kVTCompressionPropertyKey_TargetQualityForAlpha: &'static CFString;
}

extern "C" {
    /// Indicates whether and how a compression session's frames will be
    /// concatenated with other compressed frames to form a longer series.
    ///
    /// True if frames compressed in a separate session will be
    /// concatenated before the beginning of this one.  False if this is a
    /// stand-alone session, or if this session will encode the first
    /// segment of a multi-segment compression. By default, false.
    ///
    /// This information enables video encoders to ensure that compressed
    /// segments can be concatenated smoothly -- for example, avoiding
    /// data rate spikes where segments are joined.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_moreframesbeforestart?language=objc)
    pub static kVTCompressionPropertyKey_MoreFramesBeforeStart: &'static CFString;
}

extern "C" {
    /// Indicates whether and how a compression session's frames will be
    /// concatenated with other compressed frames to form a longer series.
    ///
    /// True if frames compressed in a separate session will be
    /// concatenated following the end of this one. False if this is a
    /// stand-alone session, or if this session will encode the last
    /// segment of a multi-segment compression. By default, false.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_moreframesafterend?language=objc)
    pub static kVTCompressionPropertyKey_MoreFramesAfterEnd: &'static CFString;
}

extern "C" {
    /// Hint for the video encoder that it should maximize its speed during encode, sacrificing quality if needed
    ///
    /// Video encoders sometimes have a tradeoff available between encoding speed and quality at a given bitrate.
    /// For example, by spending more time refining encoding decisions, it may be possible to make marginal improvements on quality.
    /// This property lets a client indicate its preference for any such tradeoff.
    /// Clients may set this property to kCFBooleanTrue to indicate that
    /// the encoder can take steps to maximize its speed by reducing quality,
    /// or to kCFBooleanFalse to indicate that the priority should be maximizing quality (at a given bitrate).
    /// When the property value is NULL, the video encoder will choose its default behavior.
    /// H.264 and HEVC hardware video encoders prioritize quality over speed by default.
    /// ProRes hardware encoders currently prioritize speed over quality by default.
    /// Not all video encoders support this property.
    /// By default, this property is NULL.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_prioritizeencodingspeedoverquality?language=objc)
    pub static kVTCompressionPropertyKey_PrioritizeEncodingSpeedOverQuality: &'static CFString;
}

extern "C" {
    /// Requires that the encoder use a Constant Bit Rate algorithm.
    ///
    /// The property kVTCompressionPropertyKey_ExpectedFrameRate should be set along with kVTCompressionPropertyKey_ConstantBitRate
    /// to ensure effective CBR rate control.
    ///
    /// This property is not compatible with kVTCompressionPropertyKey_DataRateLimits and
    /// kVTCompressionPropertyKey_AverageBitRate.
    ///
    /// The encoder will pad the frame if they are smaller than they need to be based on the Constant BitRate. This
    /// property is not recommended for general streaming or export scenarios. It is intended for interoperability with
    /// certain streaming CDNs which specifically require that data rates not drop even during low motion and activity scenes.
    ///
    /// This is not supported in all encoders or in all encoder operating modes. kVTPropertyNotSupportedErr will be
    /// returned when this option is not supported.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_constantbitrate?language=objc)
    pub static kVTCompressionPropertyKey_ConstantBitRate: &'static CFString;
}

extern "C" {
    /// Returns the encoder's estimate of the expected size of a single encoded frame in bytes, based on current configuration.
    ///
    /// When supported, this option is intended to allow clients to estimate the output file size for an encoded video stream.
    /// This property is not implemented by all video encoders.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_estimatedaveragebytesperframe?language=objc)
    pub static kVTCompressionPropertyKey_EstimatedAverageBytesPerFrame: &'static CFString;
}

extern "C" {
    /// Specifies the profile and level for the encoded bitstream.
    ///
    /// Available profiles and levels vary across formats and between video encoders.
    /// Video encoders should use standard keys where available, and follow standard patterns where not.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_profilelevel?language=objc)
    pub static kVTCompressionPropertyKey_ProfileLevel: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_hevc_main_autolevel?language=objc)
    pub static kVTProfileLevel_HEVC_Main_AutoLevel: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_hevc_main10_autolevel?language=objc)
    pub static kVTProfileLevel_HEVC_Main10_AutoLevel: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_hevc_main42210_autolevel?language=objc)
    pub static kVTProfileLevel_HEVC_Main42210_AutoLevel: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_hevc_monochrome_autolevel?language=objc)
    pub static kVTProfileLevel_HEVC_Monochrome_AutoLevel: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_hevc_monochrome10_autolevel?language=objc)
    pub static kVTProfileLevel_HEVC_Monochrome10_AutoLevel: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_baseline_1_3?language=objc)
    pub static kVTProfileLevel_H264_Baseline_1_3: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_baseline_3_0?language=objc)
    pub static kVTProfileLevel_H264_Baseline_3_0: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_baseline_3_1?language=objc)
    pub static kVTProfileLevel_H264_Baseline_3_1: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_baseline_3_2?language=objc)
    pub static kVTProfileLevel_H264_Baseline_3_2: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_baseline_4_0?language=objc)
    pub static kVTProfileLevel_H264_Baseline_4_0: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_baseline_4_1?language=objc)
    pub static kVTProfileLevel_H264_Baseline_4_1: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_baseline_4_2?language=objc)
    pub static kVTProfileLevel_H264_Baseline_4_2: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_baseline_5_0?language=objc)
    pub static kVTProfileLevel_H264_Baseline_5_0: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_baseline_5_1?language=objc)
    pub static kVTProfileLevel_H264_Baseline_5_1: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_baseline_5_2?language=objc)
    pub static kVTProfileLevel_H264_Baseline_5_2: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_baseline_autolevel?language=objc)
    pub static kVTProfileLevel_H264_Baseline_AutoLevel: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_constrainedbaseline_autolevel?language=objc)
    pub static kVTProfileLevel_H264_ConstrainedBaseline_AutoLevel: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_main_3_0?language=objc)
    pub static kVTProfileLevel_H264_Main_3_0: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_main_3_1?language=objc)
    pub static kVTProfileLevel_H264_Main_3_1: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_main_3_2?language=objc)
    pub static kVTProfileLevel_H264_Main_3_2: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_main_4_0?language=objc)
    pub static kVTProfileLevel_H264_Main_4_0: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_main_4_1?language=objc)
    pub static kVTProfileLevel_H264_Main_4_1: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_main_4_2?language=objc)
    pub static kVTProfileLevel_H264_Main_4_2: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_main_5_0?language=objc)
    pub static kVTProfileLevel_H264_Main_5_0: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_main_5_1?language=objc)
    pub static kVTProfileLevel_H264_Main_5_1: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_main_5_2?language=objc)
    pub static kVTProfileLevel_H264_Main_5_2: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_main_autolevel?language=objc)
    pub static kVTProfileLevel_H264_Main_AutoLevel: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_extended_5_0?language=objc)
    pub static kVTProfileLevel_H264_Extended_5_0: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_extended_autolevel?language=objc)
    pub static kVTProfileLevel_H264_Extended_AutoLevel: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_high_3_0?language=objc)
    pub static kVTProfileLevel_H264_High_3_0: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_high_3_1?language=objc)
    pub static kVTProfileLevel_H264_High_3_1: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_high_3_2?language=objc)
    pub static kVTProfileLevel_H264_High_3_2: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_high_4_0?language=objc)
    pub static kVTProfileLevel_H264_High_4_0: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_high_4_1?language=objc)
    pub static kVTProfileLevel_H264_High_4_1: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_high_4_2?language=objc)
    pub static kVTProfileLevel_H264_High_4_2: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_high_5_0?language=objc)
    pub static kVTProfileLevel_H264_High_5_0: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_high_5_1?language=objc)
    pub static kVTProfileLevel_H264_High_5_1: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_high_5_2?language=objc)
    pub static kVTProfileLevel_H264_High_5_2: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_high_autolevel?language=objc)
    pub static kVTProfileLevel_H264_High_AutoLevel: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h264_constrainedhigh_autolevel?language=objc)
    pub static kVTProfileLevel_H264_ConstrainedHigh_AutoLevel: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_mp4v_simple_l0?language=objc)
    pub static kVTProfileLevel_MP4V_Simple_L0: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_mp4v_simple_l1?language=objc)
    pub static kVTProfileLevel_MP4V_Simple_L1: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_mp4v_simple_l2?language=objc)
    pub static kVTProfileLevel_MP4V_Simple_L2: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_mp4v_simple_l3?language=objc)
    pub static kVTProfileLevel_MP4V_Simple_L3: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_mp4v_main_l2?language=objc)
    pub static kVTProfileLevel_MP4V_Main_L2: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_mp4v_main_l3?language=objc)
    pub static kVTProfileLevel_MP4V_Main_L3: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_mp4v_main_l4?language=objc)
    pub static kVTProfileLevel_MP4V_Main_L4: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_mp4v_advancedsimple_l0?language=objc)
    pub static kVTProfileLevel_MP4V_AdvancedSimple_L0: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_mp4v_advancedsimple_l1?language=objc)
    pub static kVTProfileLevel_MP4V_AdvancedSimple_L1: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_mp4v_advancedsimple_l2?language=objc)
    pub static kVTProfileLevel_MP4V_AdvancedSimple_L2: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_mp4v_advancedsimple_l3?language=objc)
    pub static kVTProfileLevel_MP4V_AdvancedSimple_L3: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_mp4v_advancedsimple_l4?language=objc)
    pub static kVTProfileLevel_MP4V_AdvancedSimple_L4: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h263_profile0_level10?language=objc)
    pub static kVTProfileLevel_H263_Profile0_Level10: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h263_profile0_level45?language=objc)
    pub static kVTProfileLevel_H263_Profile0_Level45: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtprofilelevel_h263_profile3_level45?language=objc)
    pub static kVTProfileLevel_H263_Profile3_Level45: &'static CFString;
}

extern "C" {
    /// When set, requires the encoder to output bitstream with the requested bit depth, if supported by the configured profile level setting.
    /// In the absence of this property, the video encoder will assume the highest bit depth allowable by the configured profile level setting.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_outputbitdepth?language=objc)
    pub static kVTCompressionPropertyKey_OutputBitDepth: &'static CFString;
}

extern "C" {
    /// The mode for HDR metadata in the output bitstream.
    ///
    /// If set to kVTHDRMetadataInsertionMode_None, no HDR metadata will
    /// be present in the output bitstream.  For other modes,
    /// VTCompressionSession will determine what type of HDR metadata
    /// to insert based on the output color space.  e.g. DolbyVision, HDR10, etc.
    /// This property has no effect if the output color space is not HDR, or if
    /// there is currently no underlying support for the HDR format.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_hdrmetadatainsertionmode?language=objc)
    pub static kVTCompressionPropertyKey_HDRMetadataInsertionMode: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvthdrmetadatainsertionmode_none?language=objc)
    pub static kVTHDRMetadataInsertionMode_None: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvthdrmetadatainsertionmode_auto?language=objc)
    pub static kVTHDRMetadataInsertionMode_Auto: &'static CFString;
}

extern "C" {
    /// The entropy encoding mode for H.264 compression.
    ///
    /// If supported by an H.264 encoder, this property controls whether the encoder should use
    /// Context-based Adaptive Variable Length Coding (CAVLC) or Context-based Adaptive Binary Arithmetic Coding (CABAC).
    /// CABAC generally gives better compression at the expense of higher computational overhead.
    /// The default value is encoder-specific and may change depending on other encoder settings.
    /// Care should be taken when using this property -- changes may result in a configuration
    /// which is not compatible with a requested Profile and Level.  Results in this case are undefined,
    /// and could include encode errors or a non-compliant output stream.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_h264entropymode?language=objc)
    pub static kVTCompressionPropertyKey_H264EntropyMode: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvth264entropymode_cavlc?language=objc)
    pub static kVTH264EntropyMode_CAVLC: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvth264entropymode_cabac?language=objc)
    pub static kVTH264EntropyMode_CABAC: &'static CFString;
}

extern "C" {
    /// The pixel depth of the encoded video.
    ///
    /// This property is only supported by video encoders for formats that are
    /// tied to particular pixel formats (eg, 16-bit RGB, 24-bit RGB).
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_depth?language=objc)
    pub static kVTCompressionPropertyKey_Depth: &'static CFString;
}

extern "C" {
    /// Instructs the encoder to encode or discard the alpha channel of input video frames
    ///
    /// This property allows a client to  specify whether or not the alpha channel in the source pixelBuffers should be encoded.
    /// The client may set this to kCFBooleanFalse in cases where they are not interested in preserving alpha, or if the alpha channel is known to be fully opaque.
    /// This property is not supported by all encoders.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_preservealphachannel?language=objc)
    pub static kVTCompressionPropertyKey_PreserveAlphaChannel: &'static CFString;
}

extern "C" {
    /// The maximum frame delay count is the maximum number of frames that
    /// a compressor is allowed to hold before it must output a compressed
    /// frame.
    ///
    /// It limits the number of frames that may be held in the
    /// "compression window". If the maximum frame delay count is M, then
    /// before the call to encode frame N returns, frame N-M must have
    /// been emitted.
    /// The default is kVTUnlimitedFrameDelayCount, which sets no limit
    /// on the compression window.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_maxframedelaycount?language=objc)
    pub static kVTCompressionPropertyKey_MaxFrameDelayCount: &'static CFString;
}

/// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtunlimitedframedelaycount?language=objc)
pub const kVTUnlimitedFrameDelayCount: c_int = -1;

extern "C" {
    /// Specifies the maximum slice size for H.264 encoding
    ///
    /// If supported by an H.264 encoder, the value limits the size in bytes of
    /// slices produced by the encoder, where possible.
    /// By default, no limit is specified.  A value of zero implies default behavior.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_maxh264slicebytes?language=objc)
    pub static kVTCompressionPropertyKey_MaxH264SliceBytes: &'static CFString;
}

extern "C" {
    /// Hints the video encoder that compression is, or is not, being performed in real time.
    ///
    /// For offline compression, clients are advised to set this property to kCFBooleanFalse.
    /// This indicates that the timeline of the frames is not connected to wall-clock time at all.
    /// This allows the video encoder to run either slower than real-time or faster than real-time,
    /// depending upon the situation and device capabilities.
    /// For real-time compression, clients are advised to set this property to kCFBooleanTrue.
    /// This indicates that the timeline of frames is connected to real time (so, for example,
    /// the client expects to encode one second of frames each second, on average).
    /// In such a case, it is important that encoding keep up, but it is also not valuable to encode
    /// substantially faster than real time.
    /// When this property is set to kCFBooleanTrue, the video encoder may use the value of the
    /// kVTCompressionPropertyKey_ExpectedFrameRate property to optimize energy usage,
    /// by anticipating that encoding requests will happen at this rate.
    /// By default, this property is NULL, indicating unknown.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_realtime?language=objc)
    pub static kVTCompressionPropertyKey_RealTime: &'static CFString;
}

extern "C" {
    /// Hints to the video encoder that it should maximize power efficiency during encode.
    ///
    /// For compression where the client is operating in the background, clients may set this property to kCFBooleanTrue, which indicates that
    /// the encoder can take steps to minimize impact on power usage and other system activity.
    /// Setting the property to NULL is equivalent to setting it to kCFBooleanFalse.
    /// Not all video encoders support this property.
    /// By default, this property is NULL.
    /// If the kVTCompressionPropertyKey_RealTime property is set to kCFBooleanTrue,
    /// the video encoder may act as though this property were set to kCFBooleanFalse.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_maximizepowerefficiency?language=objc)
    pub static kVTCompressionPropertyKey_MaximizePowerEfficiency: &'static CFString;
}

extern "C" {
    /// Indicates the number of source frames, if known.
    ///
    /// This property allows a client to give the video encoder advance guidance as to how
    /// many frames will be encoded.
    /// If nonzero, this should be the exact number of times that the client calls
    /// VTCompressionSessionEncodeFrame in each pass.
    /// The default is 0, which indicates that the number of source frames
    /// is not known.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_sourceframecount?language=objc)
    pub static kVTCompressionPropertyKey_SourceFrameCount: &'static CFString;
}

extern "C" {
    /// Indicates the expected frame rate of the video to be encoded.
    ///
    /// The frame rate is measured in frames per second.
    /// This property is used to inform the encoder of the expected cadence of the presentation time stamp values of frames that will be submitted to the encoder.
    /// The actual frame rate may vary, and will depend on the frame durations calculated by the difference between subsequent presentation time stamps.
    /// If kVTCompressionPropertyKey_RealTime has been set to true, the ExpectedFrameRate may be used to optimize energy usage as well as perform internal encoder configuration before compression begins.
    /// If kVTCompressionPropertyKey_RealTime is not set, or has been set to false, the ExpectedFrameRate is still helpful and allows the encoder to optimize internal encoder configuration before compression begins.
    /// By default, the property has a value of zero indicating "unknown".
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_expectedframerate?language=objc)
    pub static kVTCompressionPropertyKey_ExpectedFrameRate: &'static CFString;
}

extern "C" {
    /// Indicates the maximum real time rate at which frames could be submitted to the VTCompressionSession
    ///
    /// The frame rate is measured in frames per second.
    /// This property can be used to inform the encoder of the maximum rate that frames could be submitted to the encoder during realtime encoding.  This allows the encoder to configure itself to ensure this capability.
    /// This property can only be used when kVTCompressionPropertyKey_RealTime has been set to true.
    /// Unlike kVTCompressionPropertyKey_ExpectedFrameRate, this property informs the maximum possible rate that the VTCompressionSession could see, not the average frame rate that is expected in normal operation.
    /// By default, the property has a value of zero indicating "unknown".
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_maximumrealtimeframerate?language=objc)
    pub static kVTCompressionPropertyKey_MaximumRealTimeFrameRate: &'static CFString;
}

extern "C" {
    /// This property indicates the desired frame rate fraction of the base layer.
    ///
    /// This property indicates the fraction of total frames submitted that should be encoded in the base layer.
    /// For example, a value of 0.5 means that half of the frames are in the base layer, and half are in the enhancement layer.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_baselayerframeratefraction?language=objc)
    pub static kVTCompressionPropertyKey_BaseLayerFrameRateFraction: &'static CFString;
}

extern "C" {
    /// This property indicates the desired bit rate fraction of the base layer
    ///
    /// This is not a hard limit; the encoder will attempt to satisfy this ratio when possible. If not set, the encoder will manage the ratio.
    /// For example: If the target bitrate is set to 500kbps and kVTCompressionPropertyKey_BaseLayerBitRateFraction is set to 0.6, the base layer will be given a
    /// budget of 300kbps and the enhancement layer 200kbps.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_baselayerbitratefraction?language=objc)
    pub static kVTCompressionPropertyKey_BaseLayerBitRateFraction: &'static CFString;
}

extern "C" {
    /// Indicates the expected total duration for the compression session, if known.
    ///
    /// By default, this is zero, indicating "unknown".
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_expectedduration?language=objc)
    pub static kVTCompressionPropertyKey_ExpectedDuration: &'static CFString;
}

extern "C" {
    /// This property indicates the desired frame rate for the base temporal layer used in hierarchical video encoding.
    ///
    /// The frame rate is measured in frames per second.
    /// This property is only implemented by encoders which support hierarchical frame encoding, and requests that this encoding feature be enabled.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_baselayerframerate?language=objc)
    pub static kVTCompressionPropertyKey_BaseLayerFrameRate: &'static CFString;
}

extern "C" {
    /// The client will be able to control the the maximum allowed ReferenceBufferCount using this optional key.
    ///
    /// This is typically used to force the encoder to use lower count than allowed by the stantard for a level/profile.
    /// The encoder will fail and  report an error if the requested value exceeds the limit set by the standard for such a level/profile.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_referencebuffercount?language=objc)
    pub static kVTCompressionPropertyKey_ReferenceBufferCount: &'static CFString;
}

extern "C" {
    /// This property requests that the encoder measure and output the Mean Squared Error(MSE) quality metric.
    ///
    /// The MSE value returned may be measured using an internal representation of the decoded frame which may lack filtering or processing present in the actual decoded frame.  Because of this, there may be a small delta between the reported MSE and the true MSE.
    /// If supported, the MSE values will be returned as sample buffer attachments on the encoded frame using the kVTSampleAttachmentKey_QualityMetrics key.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_calculatemeansquarederror?language=objc)
    pub static kVTCompressionPropertyKey_CalculateMeanSquaredError: &'static CFString;
}

extern "C" {
    /// The value for this key contain quality-related metadata from the video encoder for a video frame.
    ///
    /// The video encoder will attach this via the CMSampleBufferGetSampleAttachmentsArray interface before emitting the sample buffer.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtsampleattachmentkey_qualitymetrics?language=objc)
    pub static kVTSampleAttachmentKey_QualityMetrics: &'static CFString;
}

extern "C" {
    /// Key for mean squared error (MSE) of the encoded Luma channel from the video encoder.
    ///
    /// For single-view video, a CFNumber value is returned.
    /// For multi-view video, a CFArray value is returned, and each element (CFNumber) in the CFArray includes MSE for the corresponding view.
    /// The video encoder will attach this in kVTSampleAttachmentKey_QualityMetrics via the CMSampleBufferGetSampleAttachmentsArray interface before emitting the sample buffer.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtsampleattachmentqualitymetricskey_lumameansquarederror?language=objc)
    pub static kVTSampleAttachmentQualityMetricsKey_LumaMeanSquaredError: &'static CFString;
}

extern "C" {
    /// Key for mean squared error (MSE) of the encoded Chroma Blue channel from the video encoder.
    ///
    /// For single-view video, a CFNumber value is returned.
    /// For multi-view video, a CFArray value is returned, and each element (CFNumber) in the CFArray includes MSE for the corresponding view.
    /// The video encoder will attach this in kVTSampleAttachmentKey_QualityMetrics via the CMSampleBufferGetSampleAttachmentsArray interface before emitting the sample buffer.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtsampleattachmentqualitymetricskey_chromabluemeansquarederror?language=objc)
    pub static kVTSampleAttachmentQualityMetricsKey_ChromaBlueMeanSquaredError: &'static CFString;
}

extern "C" {
    /// Key for mean squared error (MSE) of the encoded Chroma Red channel from the video encoder.
    ///
    /// For single-view video, a CFNumber value is returned.
    /// For multi-view video, a CFArray value is returned, and each element (CFNumber) in the CFArray includes MSE for the corresponding view.
    /// The video encoder will attach this in kVTSampleAttachmentKey_QualityMetrics via the CMSampleBufferGetSampleAttachmentsArray interface before emitting the sample buffer.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtsampleattachmentqualitymetricskey_chromaredmeansquarederror?language=objc)
    pub static kVTSampleAttachmentQualityMetricsKey_ChromaRedMeanSquaredError: &'static CFString;
}

extern "C" {
    /// If set to kCFBooleanTrue, use a hardware accelerated video encoder if available.  If set to
    /// kCFBooleanFalse, hardware encode will never be used.
    ///
    /// This key is set in the encoderSpecification passed in to VTCompressionSessionCreate.  Set it
    /// to kCFBooleanTrue to allow hardware accelerated encode.  To prevent hardware encode,
    /// this property can be set to kCFBooleanFalse.
    /// In MacOS 10.15 and later, hardware encode is enabled in VTCompressionSessions by default.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtvideoencoderspecification_enablehardwareacceleratedvideoencoder?language=objc)
    pub static kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder:
        &'static CFString;
}

extern "C" {
    /// If set to kCFBooleanTrue, only use hardware encode and return an error if this isn't possible.
    /// Setting this key automatically implies kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder --
    /// there is no need to set both and the Enable key does nothing if the Require key is set.
    ///
    /// This key is set in the encoderSpecification passed in to VTCompressionSessionCreate.  Set it
    /// to kCFBooleanTrue to require hardware accelerated encode.  If hardware acceleration is not
    /// possible, the VTCompressionSessionCreate call will fail.
    /// This key is useful for clients that have their own software encode implementation or
    /// those that may want to configure software and hardware encode sessions differently.
    /// Hardware acceleration may be unavailable for a number of reasons.  A few common cases are:
    /// - the machine does not have hardware acceleration capabilities
    /// - the requested encoding format or encoding configuration is not supported
    /// - the hardware encoding resources on the machine are busy
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtvideoencoderspecification_requirehardwareacceleratedvideoencoder?language=objc)
    pub static kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder:
        &'static CFString;
}

extern "C" {
    /// If set to kCFBooleanTrue, a hardware accelerated video encoder is being used.
    ///
    /// You can query this property using VTSessionCopyProperty after you have enabled hardware
    /// accelerated encode using kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder
    /// to see if a hardware accelerated encoder was selected.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_usinghardwareacceleratedvideoencoder?language=objc)
    pub static kVTCompressionPropertyKey_UsingHardwareAcceleratedVideoEncoder: &'static CFString;
}

extern "C" {
    /// If set, the VideoToolbox will only use a hardware encoder running on the GPU specified by the provided GPU registryID.
    ///
    /// This specification implies kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder.  A separate hardware encode opt-in is not required.
    /// The GPU registryID can be obtained from a MTLDevice using [MTLDevice registryID] or can be obtained from OpenGL or OpenCL.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtvideoencoderspecification_requiredencodergpuregistryid?language=objc)
    pub static kVTVideoEncoderSpecification_RequiredEncoderGPURegistryID: &'static CFString;
}

extern "C" {
    /// If set, the VideoToolbox will try to use a hardware encoder running on the GPU specified by the provided GPU registryID.  If the
    /// GPU does not support encode of the specified format, the VideoToolbox will fall back to alternate encoders.
    ///
    /// This specification implies kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder.  A separate hardware encode opt-in is not required.
    /// If both kVTVideoEncoderSpecification_PreferredEncoderGPURegistryID and kVTVideoEncoderSpecification_RequiredEncoderGPURegistryID are set, kVTVideoEncoderSpecification_PreferredEncoderGPURegistryID will be ignored.
    /// This specification can be used in conjunction with kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder to prevent a fallback to software encode.
    /// The GPU registryID can be obtained from a MTLDevice using [MTLDevice registryID] or can be obtained from OpenGL or OpenCL.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtvideoencoderspecification_preferredencodergpuregistryid?language=objc)
    pub static kVTVideoEncoderSpecification_PreferredEncoderGPURegistryID: &'static CFString;
}

extern "C" {
    /// returns CFNumber indicating the gpu registryID of the encoder that was selected.  NULL indicates a built-in encoder or software encode was used.
    ///
    /// You can query this property using VTSessionCopyProperty after building a VTCompressionSession to find out which GPU the encoder is using.
    /// If a encoder based on a built-in GPU was used it will return NULL.  If a software encoder is used, it will return NULL
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_usinggpuregistryid?language=objc)
    pub static kVTCompressionPropertyKey_UsingGPURegistryID: &'static CFString;
}

extern "C" {
    /// This property can be queried to determine if the encoder supports base frame QP requests.
    ///
    /// If this property returns kCFBooleanTrue, it indicates that the encoder supports base frame QP requests through kVTEncodeFrameOptionKey_BaseFrameQP. If it returns false or kVTPropertyNotSupportedErr, base frame QP requests will cause errors on VTCompressionSessionEncodeFrame calls, or will be ignored.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_supportsbaseframeqp?language=objc)
    pub static kVTCompressionPropertyKey_SupportsBaseFrameQP: &'static CFString;
}

extern "C" {
    /// CFBoolean forcing the current frame to be a key frame
    ///
    /// This value is set in the frameProperties CFDictionary passed to
    /// VTCompressionSessionEncodeFrame to force the current frame to be a
    /// keyframe or not.
    /// Note that it may not be possible for the encoder to accomodate all
    /// requests.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtencodeframeoptionkey_forcekeyframe?language=objc)
    pub static kVTEncodeFrameOptionKey_ForceKeyFrame: &'static CFString;
}

extern "C" {
    /// CFNumberRef requesting the current frame to use the provided base frame QP.
    ///
    /// This value is set in the frameProperties CFDictionary passed to VTCompressionSessionEncodeFrame to force
    /// the QP value for the current frame. This is an optional parameter. Use it only when you have a specific requirement
    /// for the video quality and you are familiar with frame QP and are prepared to assume full responsibility for rate control.
    /// Otherwise it is strongly encouraged to rely on the encoder’s rate control for adjusting frame QP.
    ///
    /// Setting BaseFrameQP turns off standard rate control and will cause the following properties to be ignored::
    /// kVTCompressionPropertyKey_DataRateLimits
    /// kVTCompressionPropertyKey_AverageBitRate
    /// kVTCompressionPropertyKey_BaseLayerBitRateFraction
    /// kVTCompressionPropertyKey_Quality
    /// kVTCompressionPropertyKey_MaxAllowedFrameQP
    /// kVTCompressionPropertyKey_MinAllowedFrameQP
    ///
    /// If kVTEncodeFrameOptionKey_BaseFrameQP is used, it must be set for all frames in a session. The QP value specified is
    /// frame-level but macro-block level QP may be modulated inside a frame. There will be no rate-control related frame dropping
    /// if kVTEncodeFrameOptionKey_BaseFrameQP is used.
    ///
    /// kVTEncodeFrameOptionKey_BaseFrameQP is only supported if the encoder returns kCFBooleanTrue when the
    /// kVTCompressionPropertyKey_SupportsBaseFrameQP is queried. If this FrameOptionKey is set for encoder which
    /// does not support it, it will be ignored.
    ///
    /// Note that it may not be possible for the encoder to accommodate all requests.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtencodeframeoptionkey_baseframeqp?language=objc)
    pub static kVTEncodeFrameOptionKey_BaseFrameQP: &'static CFString;
}

extern "C" {
    /// Describes the clean aperture for encoded frames.
    ///
    /// Some video encoders may enforce specific clean apertures;
    /// in those cases this property will be read-only (SetProperty will return kVTPropertyReadOnlyErr).
    /// The clean aperture will be set on the format description for output samples,
    /// and may affect source frame scaling.
    /// NULL is a valid value for this property, meaning that the clean aperture is the full width and height.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_cleanaperture?language=objc)
    pub static kVTCompressionPropertyKey_CleanAperture: &'static CFString;
}

extern "C" {
    /// Describes the pixel aspect ratio for encoded frames.
    ///
    /// Some video encoders may enforce specific pixel aspect ratios;
    /// in those cases this property will be read-only (SetProperty will return kVTPropertyReadOnlyErr).
    /// The pixel aspect ratio will be set on the format description for output samples,
    /// and may affect source frame scaling.
    /// NULL is a valid value for this property, meaning square pixels (1:1).
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_pixelaspectratio?language=objc)
    pub static kVTCompressionPropertyKey_PixelAspectRatio: &'static CFString;
}

extern "C" {
    /// Indicates whether the frames should be encoded progressive (1) or interlaced (2).
    ///
    /// The field count will be set on the format description for output samples,
    /// and may affect source frame scaling.
    /// NULL is a valid value for this property.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_fieldcount?language=objc)
    pub static kVTCompressionPropertyKey_FieldCount: &'static CFString;
}

extern "C" {
    /// Indicates field ordering for encoded interlaced frames.
    ///
    /// Some video encoders may enforce specific field ordering;
    /// in those cases this property will be read-only (SetProperty will return kVTPropertyReadOnlyErr).
    /// The field detail will be set on the format description for output samples,
    /// and may affect source frame scaling.
    /// NULL is a valid value for this property.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_fielddetail?language=objc)
    pub static kVTCompressionPropertyKey_FieldDetail: &'static CFString;
}

extern "C" {
    /// Indicates that the DV video stream should have the 16x9 flag set.
    ///
    /// This property is supported by the DV25/50 family of encoders.
    /// When false, the picture aspect ratio is 4:3.
    /// When true, the picture aspect ratio is 16:9.
    /// Either way, a fixed PixelAspectRatio is used (the specific value depends on whether the format is NTSC or PAL).
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_aspectratio16x9?language=objc)
    pub static kVTCompressionPropertyKey_AspectRatio16x9: &'static CFString;
}

extern "C" {
    /// Indicates that the DV video stream should have the progressive flag set.
    ///
    /// This property is supported by the DV25/50 family of encoders.
    /// If false, content is encoded as interlaced.
    /// If true, content is encoded as progressive.
    /// The value of this property fixes the FieldCount and FieldDetail properties.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_progressivescan?language=objc)
    pub static kVTCompressionPropertyKey_ProgressiveScan: &'static CFString;
}

extern "C" {
    /// Indicates color primaries for compressed content.
    ///
    /// Some video encoders may enforce specific colorimetry;
    /// in those cases this property will be read-only (SetProperty will return kVTPropertyReadOnlyErr).
    /// The value will be set on the format description for output sample buffers.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_colorprimaries?language=objc)
    pub static kVTCompressionPropertyKey_ColorPrimaries: &'static CFString;
}

extern "C" {
    /// Indicates transfer function for compressed content.
    ///
    /// Some video encoders may enforce specific colorimetry;
    /// in those cases this property will be read-only (SetProperty will return kVTPropertyReadOnlyErr).
    /// The value will be set on the format description for output sample buffers.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_transferfunction?language=objc)
    pub static kVTCompressionPropertyKey_TransferFunction: &'static CFString;
}

extern "C" {
    /// Indicates YCbCr matrix for compressed content.
    ///
    /// Some video encoders may enforce specific colorimetry;
    /// in those cases this property will be read-only (SetProperty will return kVTPropertyReadOnlyErr).
    /// The value will be set on the format description for output sample buffers.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_ycbcrmatrix?language=objc)
    pub static kVTCompressionPropertyKey_YCbCrMatrix: &'static CFString;
}

extern "C" {
    /// Indicates ICC profile for compressed content.
    ///
    /// Some video encoders may enforce specific colorimetry;
    /// in those cases this property will be read-only (SetProperty will return kVTPropertyReadOnlyErr).
    /// If this property and any of the previous three are all set, they should be set to consistent values,
    /// or undefined behavior may occur.
    /// The value will be set on the format description for output sample buffers.
    /// NULL can be a valid value for this property.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_iccprofile?language=objc)
    pub static kVTCompressionPropertyKey_ICCProfile: &'static CFString;
}

extern "C" {
    /// The value is 24 bytes containing a big-endian structure as defined in ISO/IEC 23008-2:2015(E), D.2.28 Mastering display colour volume SEI message.
    ///
    /// The value will be set on the format description for output sample buffers,
    /// and incorporated into the appropriate SEI NAL unit where supported by the encoder.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_masteringdisplaycolorvolume?language=objc)
    pub static kVTCompressionPropertyKey_MasteringDisplayColorVolume: &'static CFString;
}

extern "C" {
    /// The value is 4 bytes containing a big-endian structure as defined in the Content Light Level Info SEI message.
    ///
    /// The value will be set on the format description for output sample buffers,
    /// and incorporated into the appropriate SEI NAL unit where supported by the encoder.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_contentlightlevelinfo?language=objc)
    pub static kVTCompressionPropertyKey_ContentLightLevelInfo: &'static CFString;
}

extern "C" {
    /// Indicates gamma level for compressed content.
    ///
    /// This property allows the caller to specify a gamma value to include in the CMVideoFormatDescription attached to output CMSampleBuffers. It does not change pixel data being encoded.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_gammalevel?language=objc)
    pub static kVTCompressionPropertyKey_GammaLevel: &'static CFString;
}

extern "C" {
    /// Specifies whether the source images' RGB values have been premultiplied by the alpha channel values.
    ///
    /// Video compression will fail if source image buffers have a mismatched value in their kCVImageBufferAlphaChannelMode attachment.
    /// If this property is not set, the encoder may read the first source image buffer's kCVImageBufferAlphaChannelMode attachment.
    /// If neither the property nor the first buffer's attachment is set, defaults to kVTAlphaChannelMode_PremultipliedAlpha.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_alphachannelmode?language=objc)
    pub static kVTCompressionPropertyKey_AlphaChannelMode: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtalphachannelmode_straightalpha?language=objc)
    pub static kVTAlphaChannelMode_StraightAlpha: &'static CFString;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtalphachannelmode_premultipliedalpha?language=objc)
    pub static kVTAlphaChannelMode_PremultipliedAlpha: &'static CFString;
}

extern "C" {
    /// Specifies properties to configure a VTPixelTransferSession used to transfer source frames
    /// from the client's image buffers to the video encoder's image buffers, if necessary.
    ///
    /// Setting this property alone does not necessarily guarantee that a VTPixelTransferSession will be created.
    /// See VTPixelTransferProperties.h.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_pixeltransferproperties?language=objc)
    pub static kVTCompressionPropertyKey_PixelTransferProperties: &'static CFString;
}

extern "C" {
    /// Enables multi-pass compression and provides storage for encoder-private data.
    ///
    /// Some video encoders support multi-pass encoding.  To determine whether a VTCompressionSession supports multi-pass encoding, you can inspect the dictionary returned by VTSessionCopySupportedPropertyDictionary to see if it contains kVTCompressionPropertyKey_MultiPassStorage.
    ///
    /// To enable multi-pass encoding, set the kVTCompressionPropertyKey_MultiPassStorage property to a VTMultiPassStorage object, which you can create by calling VTMultiPassStorageCreate.  Then make one or more passes over the source frames.  Bracket each pass with a call to VTCompressionSessionBeginPass at the beginning and VTCompressionSessionEndPass at the end.
    ///
    /// In the first pass of multi-pass encoding, call VTCompressionSessionEncodeFrame for every source frame (just as in single-pass encoding).  At the end of every pass, call VTCompressionSessionEndPass.  This may take some time as the video encoder determines whether it can improve the encoding by performing another pass.  If the user cancels encoding during this time, call VTCompressionSessionInvalidate to interrupt the processing.  VTCompressionSessionEndPass will indicate via the furtherPassesRequestedOut argument whether the video encoder would like to perform another pass.  There is no particular bound on the number of passes the video encoder may request, but the client is free to disregard this request and use the last-emitted set of frames.
    ///
    /// If *furtherPassesRequestedOut is set to true and you want to perform another pass, call VTCompressionSessionGetTimeRangesForNextPass to determine the time ranges for the next pass.  Only the source frames within these time ranges need to be passed to VTCompressionSessionEncodeFrame; the video encoder is satisfied with the already-emitted compressed frames outside these ranges and they can be kept for the final output.
    ///
    /// In second and successive passes, you must pass identical source frames, frame properties and timestamps to VTCompressionSessionEncodeFrame as in the first pass, with the exception that frames not in the requested time ranges should be skipped.
    ///
    /// You can create and use a VTFrameSilo object to merge sequences of compressed frames across passes during multi-pass encoding.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_multipassstorage?language=objc)
    pub static kVTCompressionPropertyKey_MultiPassStorage: &'static CFString;
}

extern "C" {
    /// Specifies a particular video encoder by its ID string.
    ///
    /// Matches the value specified in kVTVideoEncoderSpecification_EncoderID, and the kVTVideoEncoderList_EncoderID value returned from VTCopyVideoEncoderList.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_encoderid?language=objc)
    pub static kVTCompressionPropertyKey_EncoderID: &'static CFString;
}

extern "C" {
    /// If supported by the underlying video encoder, returns the recommended number of VTCompressionSessions to instantiate in a parallel encoding configuration.
    ///
    /// Parallel encoding VTCompressionSessions require the use of the properties kVTCompressionPropertyKey_MoreFramesBeforeStart, kVTCompressionPropertyKey_MoreFramesAfterEnd, and kVTCompressionPropertyKey_SourceFrameCount.
    /// e.g. If the property returns 4, a setup for 4 VTCompressionSessions on a 400 frame movie might look like:
    /// compressionSession1
    /// kVTCompressionPropertyKey_MoreFramesBeforeStart = false
    /// kVTCompressionPropertyKey_MoreFramesAfterEnd = true
    /// kVTCompressionPropertyKey_SourceFrameCount = 100
    /// compressionSession2
    /// kVTCompressionPropertyKey_MoreFramesBeforeStart = true
    /// kVTCompressionPropertyKey_MoreFramesAfterEnd = true
    /// kVTCompressionPropertyKey_SourceFrameCount = 100
    /// compressionSession3
    /// kVTCompressionPropertyKey_MoreFramesBeforeStart = true
    /// kVTCompressionPropertyKey_MoreFramesAfterEnd = true
    /// kVTCompressionPropertyKey_SourceFrameCount = 100
    /// compressionSession4
    /// kVTCompressionPropertyKey_MoreFramesBeforeStart = true
    /// kVTCompressionPropertyKey_MoreFramesAfterEnd = false
    /// kVTCompressionPropertyKey_SourceFrameCount = 100
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_recommendedparallelizationlimit?language=objc)
    pub static kVTCompressionPropertyKey_RecommendedParallelizationLimit: &'static CFString;
}

extern "C" {
    /// If supported by the underlying video encoder, returns the recommended minimum number of video frames for a given subdivision in a parallel encoding configuration.
    ///
    /// For best results, ensure that the total number of frames of a parallelized subdivision is greater than or equal to this returned value.
    /// See also kVTCompressionPropertyKey_RecommendedParallelizationLimit
    /// See also kVTCompressionPropertyKey_RecommendedParallelizedSubdivisionMinimumDuration
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_recommendedparallelizedsubdivisionminimumframecount?language=objc)
    pub static kVTCompressionPropertyKey_RecommendedParallelizedSubdivisionMinimumFrameCount:
        &'static CFString;
}

extern "C" {
    /// If supported by the underlying video encoder, returns the recommended minimum duration for a given subdivision in a parallel encoding configuration.
    ///
    /// For best results, ensure that the total duration of a parallelized subdivision is greater than or equal to this returned value.
    /// See also kVTCompressionPropertyKey_RecommendedParallelizationLimit
    /// See also kVTCompressionPropertyKey_RecommendedParallelizedSubdivisionMinimumFrameCount
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_recommendedparallelizedsubdivisionminimumduration?language=objc)
    pub static kVTCompressionPropertyKey_RecommendedParallelizedSubdivisionMinimumDuration:
        &'static CFString;
}

extern "C" {
    /// Controls whether or not to preserve any dynamic HDR metadata on the input pixel buffer
    ///
    /// If set to false, and kVTCompressionPropertyKey_HDRMetadataInsertionMode is not
    /// kVTHDRMetadataInsertionMode_None, then VTCompressionSession will generate the
    /// dynamic HDR metadata for the pixel buffer, if the HDR format is supported.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_preservedynamichdrmetadata?language=objc)
    pub static kVTCompressionPropertyKey_PreserveDynamicHDRMetadata: &'static CFString;
}

extern "C" {
    /// Requires that an encoder which supports low-latency operation be selected, and enables low-latency mode.
    ///
    /// Low latency RateControl enforces the following behaviors:
    /// - Infinite GOP (all P frames following the beginning IDR).
    /// - No frame reordering (B frame) or looking ahead.
    /// - Only High profiles. Levels are left for the encoder to automatically set.
    /// - Temporal Layer structure.
    ///
    /// Also see:
    /// kVTCompressionPropertyKey_AverageBitRate
    /// kVTCompressionPropertyKey_BaseLayerFrameRateFraction
    /// kVTEncodeFrameOptionKey_ForceKeyFrame
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtvideoencoderspecification_enablelowlatencyratecontrol?language=objc)
    pub static kVTVideoEncoderSpecification_EnableLowLatencyRateControl: &'static CFString;
}

extern "C" {
    /// Specifies the maximum allowed encoded frame QP (Quantization Parameter).
    ///
    /// This is an optional parameter. Use it only when you have a specific requirement for the video quality and you are
    /// familiar with frame QP. To satisfy this requirement, the encoder may drop frames to maintain bitrate and QP goals.
    /// This is not supported in all encoders or in all encoder operating modes. kVTPropertyNotSupportedErr will be
    /// returned when this option is not supported.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_maxallowedframeqp?language=objc)
    pub static kVTCompressionPropertyKey_MaxAllowedFrameQP: &'static CFString;
}

extern "C" {
    /// Specifies the minimum allowed encoded frame QP (Quantization Parameter).
    ///
    /// This is an optional parameter. Use it only when you have a specific requirement for the video quality and you are
    /// familiar with frame QP.
    /// This is not supported in all encoders or in all encoder operating modes. kVTPropertyNotSupportedErr will be
    /// returned when this option is not supported.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_minallowedframeqp?language=objc)
    pub static kVTCompressionPropertyKey_MinAllowedFrameQP: &'static CFString;
}

extern "C" {
    /// Enable Long Term Reference (LTR) frames during encoding
    ///
    /// When an LTR frame is encoded, encoder will signal a unique token of the LTR frame in the encoder callback through:
    /// kVTSampleAttachmentKey_RequireLTRAcknowledgementToken
    /// Clients are responsible for reporting acknowledged LTR frames to the encoder through:
    /// kVTEncodeFrameOptionKey_AcknowledgedLTRTokens
    /// Client can request a refresh frame at any time through:
    /// kVTEncodeFrameOptionKey_ForceLTRRefresh
    /// Encoder will encode a P frame by using one of acknowledged LTR frames
    /// as the reference. Encoder will encode a new reference frame using an acknowledged LTR, or an IDR if no LTR frames have been acknowledged.
    ///
    /// Also see:
    /// kVTEncodeFrameOptionKey_AcknowledgedLTRTokens
    /// kVTEncodeFrameOptionKey_ForceLTRRefresh
    /// kVTSampleAttachmentKey_RequireLTRAcknowledgementToken
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_enableltr?language=objc)
    pub static kVTCompressionPropertyKey_EnableLTR: &'static CFString;
}

extern "C" {
    /// A CFArray of CFNumbers containing the kVTSampleAttachmentKey_RequireLTRAcknowledgementToken values which have been successfully sent to the receiver and can be used as references
    ///
    /// When an LTR frame is encoded, the encoder will return a unique token for the LTR frame on the output CMSampleBuffer through kVTSampleAttachmentKey_RequireLTRAcknowledgementToken.
    /// This token is then returned to the encoder via kVTEncodeFrameOptionKey_AcknowledgedLTRTokens when the LTR frame is received by the remote consumer(s).
    ///
    /// Also see:
    /// kVTCompressionPropertyKey_EnableLTR
    /// kVTEncodeFrameOptionKey_ForceLTRRefresh
    /// kVTSampleAttachmentKey_RequireLTRAcknowledgementToken
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtencodeframeoptionkey_acknowledgedltrtokens?language=objc)
    pub static kVTEncodeFrameOptionKey_AcknowledgedLTRTokens: &'static CFString;
}

extern "C" {
    /// Set this option to kCFBooleanTrue to force an LTR refresh
    ///
    /// When the encoder receives this request on an incoming frame, the encoder will encode a new reference frame using a previously
    /// acknowledged LTR, or it will encode a new IDR if no LTR frames have been acknowledged.
    ///
    /// Also see:
    /// kVTCompressionPropertyKey_EnableLTR
    /// kVTEncodeFrameOptionKey_AcknowledgedLTRTokens
    /// kVTSampleAttachmentKey_RequireLTRAcknowledgementToken
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtencodeframeoptionkey_forceltrrefresh?language=objc)
    pub static kVTEncodeFrameOptionKey_ForceLTRRefresh: &'static CFString;
}

extern "C" {
    /// CFNumber containing a unique token for this LTR
    ///
    /// This CMSampleBuffer attachment contains a unique token which can be returned to the encoder through
    /// kVTEncodeFrameOptionKey_AcknowledgedLTRTokens to indicate that the LTR has been received and may be used as a reference.
    ///
    /// Also see:
    /// kVTCompressionPropertyKey_EnableLTR
    /// kVTEncodeFrameOptionKey_AcknowledgedLTRTokens
    /// kVTEncodeFrameOptionKey_ForceLTRRefresh
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtsampleattachmentkey_requireltracknowledgementtoken?language=objc)
    pub static kVTSampleAttachmentKey_RequireLTRAcknowledgementToken: &'static CFString;
}

extern "C" {
    /// Requests multi-image encoding; advises encoder to expect CMTaggedBufferGroups with specific CMTags referencing these MV-HEVC VideoLayerIDs.
    ///
    /// MV-HEVC specific.
    /// The property value is a CFArray containing VideoLayerIDs as CFNumbers.
    /// The property is NULL by default.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_mvhevcvideolayerids?language=objc)
    pub static kVTCompressionPropertyKey_MVHEVCVideoLayerIDs: &'static CFString;
}

extern "C" {
    /// Specifies the ViewIDs corresponding to the VideoLayerIDs provided via kVTCompressionPropertyKey_MVHEVCVideoLayerIDs.
    ///
    /// MV-HEVC specific.
    /// The property value is a CFArray containing ViewIDs as CFNumbers.
    /// The entries in this array should be in the same order and have the same count as the value set via kVTCompressionPropertyKey_MVHEVCVideoLayerIDs.
    /// The property is NULL by default.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_mvhevcviewids?language=objc)
    pub static kVTCompressionPropertyKey_MVHEVCViewIDs: &'static CFString;
}

extern "C" {
    /// Specifies which of the ViewIDs provided via kVTCompressionPropertyKey_MVHEVCViewIDs is the "left view id" and which is the "right view id".
    ///
    /// MV-HEVC specific.
    /// These ViewIDs will be incorporated into the 3D Reference Displays Info SEI message.
    /// The property value is a CFArray containing two ViewIDs as CFNumbers with the first correspponding to the left eye and the second corresponding to the right eye.
    /// The property is NULL by default.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_mvhevcleftandrightviewids?language=objc)
    pub static kVTCompressionPropertyKey_MVHEVCLeftAndRightViewIDs: &'static CFString;
}

extern "C" {
    /// Specifies the value of kCMFormatDescriptionExtension_HeroEye.
    ///
    /// The value will be set on the format description for output samples and may affect the decoded frame presentation.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_heroeye?language=objc)
    pub static kVTCompressionPropertyKey_HeroEye: &'static CFString;
}

extern "C" {
    /// Specifies the value of kCMFormatDescriptionExtension_StereoCameraBaseline.
    ///
    /// The value will be set on the format description for output samples and may affect the decoded frame presentation.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_stereocamerabaseline?language=objc)
    pub static kVTCompressionPropertyKey_StereoCameraBaseline: &'static CFString;
}

extern "C" {
    /// Specifies the value of kCMFormatDescriptionExtension_HorizontalDisparityAdjustment.
    ///
    /// The value will be set on the format description for output samples and may affect the decoded frame presentation.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_horizontaldisparityadjustment?language=objc)
    pub static kVTCompressionPropertyKey_HorizontalDisparityAdjustment: &'static CFString;
}

extern "C" {
    /// Specifies the value of kCMFormatDescriptionExtension_HasLeftStereoEyeView.
    ///
    /// The value will be set on the format description for output samples and may affect the decoded frame presentation.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_hasleftstereoeyeview?language=objc)
    pub static kVTCompressionPropertyKey_HasLeftStereoEyeView: &'static CFString;
}

extern "C" {
    /// Specifies the value of kCMFormatDescriptionExtension_HasRightStereoEyeView.
    ///
    /// The value will be set on the format description for output samples and may affect the decoded frame presentation.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_hasrightstereoeyeview?language=objc)
    pub static kVTCompressionPropertyKey_HasRightStereoEyeView: &'static CFString;
}

extern "C" {
    /// Specifies the value of kCMFormatDescriptionExtension_HorizontalFieldOfView.
    ///
    /// The value is a CFNumber holding an unsigned 32-bit integer that is interpreted in millidegree or thousandths of a degree (e.g., 123456 is 123.456 degree).
    /// This property is optional and should only be specified if the field of view is known.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_horizontalfieldofview?language=objc)
    pub static kVTCompressionPropertyKey_HorizontalFieldOfView: &'static CFString;
}

extern "C" {
    /// Specifies the value of kCMFormatDescriptionExtension_ProjectionKind.
    ///
    /// The value will be set on the format description for output samples and may affect the decoded frame presentation.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_projectionkind?language=objc)
    pub static kVTCompressionPropertyKey_ProjectionKind: &'static CFString;
}

extern "C" {
    /// Specifies the value of kCMFormatDescriptionExtension_ViewPackingKind.
    ///
    /// The value will be set on the format description for output samples and may affect the decoded frame presentation.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_viewpackingkind?language=objc)
    pub static kVTCompressionPropertyKey_ViewPackingKind: &'static CFString;
}

extern "C" {
    /// Requests that the encoder retain the specified number of frames during encoding. These frames will be used for additional analysis and statistics
    /// gathering before the frame is finally encoded at the end of the window. When this property is not set, video encoder will automatically determine
    /// the number of lookahead frames.
    ///
    /// Encoder will choose number of lookahead frames closer to the suggested value based on internal configuration. This property directly affects latency
    /// of the video encoder. The following properties also affect look ahead frames:
    /// 1. Value of this property must be less than or equal to `kVTCompressionPropertyKey_MaxFrameDelayCount`.
    /// 2. This property is ignored when `VTVideoEncoderSpecification_EnableLowLatencyRateControl` is set to true
    /// 3. This property is ignored when `kVTCompressionPropertyKey_Quality` is set to 1.0
    /// 4. This property can not be used in conjunction with multi-pass feature (`kVTCompressionPropertyKey_MultiPassStorage`)
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_suggestedlookaheadframecount?language=objc)
    pub static kVTCompressionPropertyKey_SuggestedLookAheadFrameCount: &'static CFString;
}

extern "C" {
    /// Control spatial adaptation of the quantization parameter (QP) based on per-frame statistics.
    /// If set to kVTQPModulationLevel_Disable, spatial QP adaptation is not applied based on per-frame statistics.
    /// If set to kVTQPModulationLevel_Default, video encoder is allowed to apply spatial QP adaptation for each macro block (or coding unit) within a video frame.
    /// QP adaptation is based on spatial characteristics of a frame and the level of spatial QP adaptation is decided internally by the rate controller.
    ///
    /// This property must be disabled when low latency rate control is enabled. Support for this property is codec dependent.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtcompressionpropertykey_spatialadaptiveqplevel?language=objc)
    pub static kVTCompressionPropertyKey_SpatialAdaptiveQPLevel: &'static CFString;
}

/// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtqpmodulationlevel_default?language=objc)
pub const kVTQPModulationLevel_Default: c_int = -1;
/// [Apple's documentation](https://developer.apple.com/documentation/videotoolbox/kvtqpmodulationlevel_disable?language=objc)
pub const kVTQPModulationLevel_Disable: c_int = 0;