cidre 0.15.2

Apple frameworks bindings for rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299

pub mod keys {

    use crate::{api, cf};

    #[doc(alias = "kVTDecompressionPropertyKey_PixelBufferPool")]
    pub fn pixel_buffer_pool() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_PixelBufferPool }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_PixelBufferPoolIsShared")]
    pub fn pixel_buffer_is_shared() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_PixelBufferPoolIsShared }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_OutputPoolRequestedMinimumBufferCount")]
    pub fn output_pool_requested_minimum_buffer_count() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_OutputPoolRequestedMinimumBufferCount }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_NumberOfFramesBeingDecoded")]
    pub fn number_of_frames_being_decoded() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_NumberOfFramesBeingDecoded }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_MinOutputPresentationTimeStampOfFramesBeingDecoded")]
    pub fn min_output_pts_of_frames_being_decoded() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_MinOutputPresentationTimeStampOfFramesBeingDecoded }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_MaxOutputPresentationTimeStampOfFramesBeingDecoded")]
    pub fn max_output_pts_of_frames_being_decoded() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_MaxOutputPresentationTimeStampOfFramesBeingDecoded }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_ContentHasInterframeDependencies")]
    pub fn content_has_interframe_dependencies() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_ContentHasInterframeDependencies }
    }

    /// Hints the video decoder that decompression is, or is not, being performed in real time.
    pub fn real_time() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_RealTime }
    }

    /// `cf::Boolean`, Read; assumed false by default
    #[doc(alias = "kVTDecompressionPropertyKey_UsingHardwareAcceleratedVideoDecoder")]
    pub fn using_hardware_accelerated_video_decoder() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_UsingHardwareAcceleratedVideoDecoder }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_MaximizePowerEfficiency")]
    pub fn maximize_power_efficiency() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_MaximizePowerEfficiency }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_ThreadCount")]
    pub fn thread_count() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_ThreadCount }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_FieldMode")]
    pub fn field_mode() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_FieldMode }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_DeinterlaceMode")]
    pub fn deinterlace_mode() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_DeinterlaceMode }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_ReducedResolutionDecode")]
    pub fn reduced_resolution_decode() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_ReducedResolutionDecode }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_ReducedCoefficientDecode")]
    pub fn reduced_coefficent_decode() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_ReducedCoefficientDecode }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_ReducedFrameDelivery")]
    pub fn reduced_frame_delivery() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_ReducedFrameDelivery }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_OnlyTheseFrames")]
    pub fn only_these_frames() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_OnlyTheseFrames }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_SupportedPixelFormatsOrderedByPerformance")]
    pub fn supported_pixel_formats_ordered_by_performance() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_SupportedPixelFormatsOrderedByPerformance }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_PixelFormatsWithReducedResolutionSupport")]
    pub fn pixel_formats_with_reduced_resolution_support() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_PixelFormatsWithReducedResolutionSupport }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_PropagatePerFrameHDRDisplayMetadata")]
    #[api::available(macos = 11.0, ios = 14.0, tvos = 14.0, visionos = 1.0)]
    pub fn propogate_per_frame_hdr_display_metadata() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_PropagatePerFrameHDRDisplayMetadata }
    }

    #[doc(alias = "kVTDecompressionPropertyKey_PixelTransferProperties")]
    pub fn pixel_transfer_props() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_PixelTransferProperties }
    }

    /// cf::Number indicating the gpu registryID of the decoder that was selected.
    /// NULL indicates a built-in decoder or software decode was used.
    /// read-only
    #[doc(alias = "kVTDecompressionPropertyKey_UsingGPURegistryID")]
    pub fn using_gpu_registry_id() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_UsingGPURegistryID }
    }

    /// Generates per frame HDR Metadata and attaches it to the resulting decoded cv::PixelBufs.
    ///
    /// If the color space and YCbCrMatrix matches a supported HDR format such as HLG (kCMFormatDescriptionTransferFunction_ITU_R_2100_HLG)
    /// the decoded frame will be analyzed and metadata will be added as an attachment to the CVPixelBuffer.
    /// CFBoolean, Read/Write, Optional, kCFBooleanFalse by default
    #[doc(alias = "kVTDecompressionPropertyKey_GeneratePerFrameHDRDisplayMetadata")]
    #[api::available(macos = 14.0, ios = 17.0, tvos = 17.0, visionos = 1.0)]
    pub fn generate_per_frame_hdr_display_metadata() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_GeneratePerFrameHDRDisplayMetadata }
    }

    /// cf::Boolean, Read, Optional, kCFBooleanFalse by default
    #[doc(alias = "kVTDecompressionPropertyKey_DecoderProducesRAWOutput")]
    #[api::available(macos = 15.0)]
    pub fn decoder_produces_raw_output() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_DecoderProducesRAWOutput }
    }

    /// cf::Boolean, Read/Write, Optional, kCFBooleanFalse by default
    #[doc(alias = "kVTDecompressionPropertyKey_RequestRAWOutput")]
    #[api::available(macos = 15.0)]
    pub fn request_raw_output() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_RequestRAWOutput }
    }

    /// Requests multi-image decoding of specific MV-HEVC VideoLayerIDs.
    ///
    /// cf::Array of CFNumbers, Optional
    #[doc(alias = "kVTDecompressionPropertyKey_RequestedMVHEVCVideoLayerIDs")]
    #[api::available(macos = 14.0, ios = 17.0, visionos = 1.0)]
    pub fn requested_mv_hevc_video_layer_ids() -> &'static cf::String {
        unsafe { kVTDecompressionPropertyKey_RequestedMVHEVCVideoLayerIDs }
    }

    #[api::weak]
    unsafe extern "C" {
        static kVTDecompressionPropertyKey_PixelBufferPool: &'static cf::String;
        static kVTDecompressionPropertyKey_PixelBufferPoolIsShared: &'static cf::String;
        static kVTDecompressionPropertyKey_OutputPoolRequestedMinimumBufferCount:
            &'static cf::String;
        static kVTDecompressionPropertyKey_NumberOfFramesBeingDecoded: &'static cf::String;
        static kVTDecompressionPropertyKey_MinOutputPresentationTimeStampOfFramesBeingDecoded:
            &'static cf::String;
        static kVTDecompressionPropertyKey_MaxOutputPresentationTimeStampOfFramesBeingDecoded:
            &'static cf::String;

        static kVTDecompressionPropertyKey_ContentHasInterframeDependencies: &'static cf::String;

        static kVTDecompressionPropertyKey_RealTime: &'static cf::String;
        static kVTDecompressionPropertyKey_UsingHardwareAcceleratedVideoDecoder:
            &'static cf::String;

        static kVTDecompressionPropertyKey_MaximizePowerEfficiency: &'static cf::String;
        static kVTDecompressionPropertyKey_ThreadCount: &'static cf::String;
        static kVTDecompressionPropertyKey_FieldMode: &'static cf::String;

        static kVTDecompressionPropertyKey_DeinterlaceMode: &'static cf::String;
        static kVTDecompressionPropertyKey_ReducedResolutionDecode: &'static cf::String;
        static kVTDecompressionPropertyKey_ReducedCoefficientDecode: &'static cf::String;
        static kVTDecompressionPropertyKey_ReducedFrameDelivery: &'static cf::String;
        static kVTDecompressionPropertyKey_OnlyTheseFrames: &'static cf::String;
        static kVTDecompressionPropertyKey_SupportedPixelFormatsOrderedByPerformance:
            &'static cf::String;

        static kVTDecompressionPropertyKey_PixelFormatsWithReducedResolutionSupport:
            &'static cf::String;

        #[api::available(macos = 11.0, ios = 14.0, tvos = 14.0, visionos = 1.0)]
        static kVTDecompressionPropertyKey_PropagatePerFrameHDRDisplayMetadata: &'static cf::String;
        static kVTDecompressionPropertyKey_PixelTransferProperties: &'static cf::String;

        static kVTDecompressionPropertyKey_UsingGPURegistryID: &'static cf::String;

        #[api::available(macos = 14.0, ios = 17.0, tvos = 17.0, visionos = 1.0)]
        static kVTDecompressionPropertyKey_GeneratePerFrameHDRDisplayMetadata: &'static cf::String;

        #[api::available(macos = 15.0)]
        static kVTDecompressionPropertyKey_DecoderProducesRAWOutput: &'static cf::String;

        #[api::available(macos = 15.0)]
        static kVTDecompressionPropertyKey_RequestRAWOutput: &'static cf::String;

        #[api::available(macos = 14.0, ios = 17.0, visionos = 1.0)]
        static kVTDecompressionPropertyKey_RequestedMVHEVCVideoLayerIDs: &'static cf::String;

    }
}

pub mod video_decoder_specification {
    use crate::cf;

    /// If set to `cf::Boolean::value_true()`, the VideoToolbox will use a hardware accelerated video decoder if available.  If set to
    /// `cf::Boolean::value_false()`, hardware decode will never be used.
    ///
    /// This key is set in the `decoderSpecification` passed in to `vt::DecompressionSession::new()`.  Set it
    /// to `cf::Boolean::value_true()` to allow hardware accelerated decode.  To  prevent hardware decode,
    /// this property can be set to `cf::Boolean::value_false()`.
    /// In MacOS 10.15 and later, hardware decode is enabled in vt::DecompressionSessions by default.
    ///
    /// `cf::Boolean`, Optional, true by default
    #[doc(alias = "kVTVideoDecoderSpecification_EnableHardwareAcceleratedVideoDecoder")]
    pub fn enable_hardware_accelerated_video_decoder() -> &'static cf::String {
        unsafe { kVTVideoDecoderSpecification_EnableHardwareAcceleratedVideoDecoder }
    }

    /// if set to `cf::Boolean::value_true()`, the VideoToolbox will try to allocate a hardware accelerated
    /// decoder and return an error if that isn't possible.
    /// Setting this key automatically implies kVTVideoDecoderSpecification_EnableHardwareAcceleratedVideoDecoder --
    /// there is no need to set both and the Enable key does nothing if the Require key is set.
    #[doc(alias = "kVTVideoDecoderSpecification_RequireHardwareAcceleratedVideoDecoder")]
    pub fn require_hardware_accelerated_video_decoder() -> &'static cf::String {
        unsafe { kVTVideoDecoderSpecification_RequireHardwareAcceleratedVideoDecoder }
    }

    /// cf::Number Optional
    #[doc(alias = "kVTVideoDecoderSpecification_RequiredDecoderGPURegistryID")]
    pub fn required_decoder_gpu_registry_id() -> &'static cf::String {
        unsafe { kVTVideoDecoderSpecification_RequiredDecoderGPURegistryID }
    }

    /// cf::Number Optional
    #[doc(alias = "kVTVideoDecoderSpecification_PreferredDecoderGPURegistryID")]
    pub fn preferred_decoder_gpu_registry_id() -> &'static cf::String {
        unsafe { kVTVideoDecoderSpecification_PreferredDecoderGPURegistryID }
    }

    unsafe extern "C" {
        static kVTVideoDecoderSpecification_EnableHardwareAcceleratedVideoDecoder:
            &'static cf::String;

        static kVTVideoDecoderSpecification_RequireHardwareAcceleratedVideoDecoder:
            &'static cf::String;

        static kVTVideoDecoderSpecification_RequiredDecoderGPURegistryID: &'static cf::String;
        static kVTVideoDecoderSpecification_PreferredDecoderGPURegistryID: &'static cf::String;
    }
}

/// Per-frame Decoder Option Keys
pub mod decode_frame_option_keys {
    use crate::{api, cf};

    /// Clockwise rotation (one of 0, 90, 180, 270) to be applied for proper display orientation.
    ///
    /// This value is used for content analysis to properly orient the image before analysis.
    /// The value should be a CFNumber with values of 0, 90, 180, or 270, representing degrees of clockwise rotation.
    /// This key is not used unless you have attached a ``SCVideoStreamAnalyzer`` to the decompression session.
    ///
    /// cf::Number, Optional
    #[doc(alias = "kVTDecodeFrameOptionKey_ContentAnalyzerRotation")]
    #[api::available(macos = 26.0, ios = 26.0, tvos = 26.0, visionos = 26.0)]
    #[inline]
    pub fn content_analyzer_rotation() -> &'static cf::String {
        unsafe { kVTDecodeFrameOptionKey_ContentAnalyzerRotation }
    }

    /// CGRect within the image to be used for content analysis, cropped before applying rotation.
    ///
    /// This value specifies a rectangle within the original frame that should be used for content analysis.
    /// The cropping is applied before any rotation specified by kVTDecodeFrameOptionKey_ContentAnalyzerRotation.
    /// The value should be a CFDictionary representing a CGRect created using CGRectCreateDictionaryRepresentation().
    /// This key is not used unless you have attached a ``SCVideoStreamAnalyzer`` to the decompression session.
    ///
    /// cf::Dictionary with cg::Rect, Optional
    #[api::available(macos = 26.0, ios = 26.0, tvos = 26.0, visionos = 26.0)]
    #[doc(alias = "kVTDecodeFrameOptionKey_ContentAnalyzerCropRectangle")]
    #[inline]
    pub fn content_analyzer_crop_rect() -> &'static cf::String {
        unsafe { kVTDecodeFrameOptionKey_ContentAnalyzerCropRectangle }
    }

    #[api::weak]
    unsafe extern "C" {
        #[api::available(macos = 26.0, ios = 26.0, tvos = 26.0, visionos = 26.0)]
        static kVTDecodeFrameOptionKey_ContentAnalyzerRotation: &'static cf::String;

        #[api::available(macos = 26.0, ios = 26.0, tvos = 26.0, visionos = 26.0)]
        static kVTDecodeFrameOptionKey_ContentAnalyzerCropRectangle: &'static cf::String;
    }
}