1#![allow(warnings)]
2#![allow(clippy::all)]
3
4pub const kCFCoreFoundationVersionNumber10_0: f64 = 196.4;
8pub const kCFCoreFoundationVersionNumber10_0_3: f64 = 196.5;
10pub const kCFCoreFoundationVersionNumber10_1: f64 = 226.0;
12pub const kCFCoreFoundationVersionNumber10_1_1: f64 = 226.0;
14pub const kCFCoreFoundationVersionNumber10_1_2: f64 = 227.2;
16pub const kCFCoreFoundationVersionNumber10_1_3: f64 = 227.2;
18pub const kCFCoreFoundationVersionNumber10_1_4: f64 = 227.3;
20pub const kCFCoreFoundationVersionNumber10_2: f64 = 263.0;
22pub const kCFCoreFoundationVersionNumber10_2_1: f64 = 263.1;
24pub const kCFCoreFoundationVersionNumber10_2_2: f64 = 263.1;
26pub const kCFCoreFoundationVersionNumber10_2_3: f64 = 263.3;
28pub const kCFCoreFoundationVersionNumber10_2_4: f64 = 263.3;
30pub const kCFCoreFoundationVersionNumber10_2_5: f64 = 263.5;
32pub const kCFCoreFoundationVersionNumber10_2_6: f64 = 263.5;
34pub const kCFCoreFoundationVersionNumber10_2_7: f64 = 263.5;
36pub const kCFCoreFoundationVersionNumber10_2_8: f64 = 263.5;
38pub const kCFCoreFoundationVersionNumber10_3: f64 = 299.0;
40pub const kCFCoreFoundationVersionNumber10_3_1: f64 = 299.0;
42pub const kCFCoreFoundationVersionNumber10_3_2: f64 = 299.0;
44pub const kCFCoreFoundationVersionNumber10_3_3: f64 = 299.3;
46pub const kCFCoreFoundationVersionNumber10_3_4: f64 = 299.31;
48pub const kCFCoreFoundationVersionNumber10_3_5: f64 = 299.31;
50pub const kCFCoreFoundationVersionNumber10_3_6: f64 = 299.32;
52pub const kCFCoreFoundationVersionNumber10_3_7: f64 = 299.33;
54pub const kCFCoreFoundationVersionNumber10_3_8: f64 = 299.33;
56pub const kCFCoreFoundationVersionNumber10_3_9: f64 = 299.35;
58pub const kCFCoreFoundationVersionNumber10_4: f64 = 368.0;
60pub const kCFCoreFoundationVersionNumber10_4_1: f64 = 368.1;
62pub const kCFCoreFoundationVersionNumber10_4_2: f64 = 368.11;
64pub const kCFCoreFoundationVersionNumber10_4_3: f64 = 368.18;
66pub const kCFCoreFoundationVersionNumber10_4_4_Intel: f64 = 368.26;
68pub const kCFCoreFoundationVersionNumber10_4_4_PowerPC: f64 = 368.25;
70pub const kCFCoreFoundationVersionNumber10_4_5_Intel: f64 = 368.26;
72pub const kCFCoreFoundationVersionNumber10_4_5_PowerPC: f64 = 368.25;
74pub const kCFCoreFoundationVersionNumber10_4_6_Intel: f64 = 368.26;
76pub const kCFCoreFoundationVersionNumber10_4_6_PowerPC: f64 = 368.25;
78pub const kCFCoreFoundationVersionNumber10_4_7: f64 = 368.27;
80pub const kCFCoreFoundationVersionNumber10_4_8: f64 = 368.27;
82pub const kCFCoreFoundationVersionNumber10_4_9: f64 = 368.28;
84pub const kCFCoreFoundationVersionNumber10_4_10: f64 = 368.28;
86pub const kCFCoreFoundationVersionNumber10_4_11: f64 = 368.31;
88pub const kCFCoreFoundationVersionNumber10_5: f64 = 476.0;
90pub const kCFCoreFoundationVersionNumber10_5_1: f64 = 476.0;
92pub const kCFCoreFoundationVersionNumber10_5_2: f64 = 476.1;
94pub const kCFCoreFoundationVersionNumber10_5_3: f64 = 476.13;
96pub const kCFCoreFoundationVersionNumber10_5_4: f64 = 476.14;
98pub const kCFCoreFoundationVersionNumber10_5_5: f64 = 476.15;
100pub const kCFCoreFoundationVersionNumber10_5_6: f64 = 476.17;
102pub const kCFCoreFoundationVersionNumber10_5_7: f64 = 476.18;
104pub const kCFCoreFoundationVersionNumber10_5_8: f64 = 476.19;
106pub const kCFCoreFoundationVersionNumber10_6: f64 = 550.0;
108pub const kCFCoreFoundationVersionNumber10_6_1: f64 = 550.0;
110pub const kCFCoreFoundationVersionNumber10_6_2: f64 = 550.13;
112pub const kCFCoreFoundationVersionNumber10_6_3: f64 = 550.19;
114pub const kCFCoreFoundationVersionNumber10_6_4: f64 = 550.29;
116pub const kCFCoreFoundationVersionNumber10_6_5: f64 = 550.42;
118pub const kCFCoreFoundationVersionNumber10_6_6: f64 = 550.42;
120pub const kCFCoreFoundationVersionNumber10_6_7: f64 = 550.42;
122pub const kCFCoreFoundationVersionNumber10_6_8: f64 = 550.43;
124pub const kCFCoreFoundationVersionNumber10_7: f64 = 635.0;
126pub const kCFCoreFoundationVersionNumber10_7_1: f64 = 635.0;
128pub const kCFCoreFoundationVersionNumber10_7_2: f64 = 635.15;
130pub const kCFCoreFoundationVersionNumber10_7_3: f64 = 635.19;
132pub const kCFCoreFoundationVersionNumber10_7_4: f64 = 635.21;
134pub const kCFCoreFoundationVersionNumber10_7_5: f64 = 635.21;
136pub const kCFCoreFoundationVersionNumber10_8: f64 = 744.0;
138pub const kCFCoreFoundationVersionNumber10_8_1: f64 = 744.0;
140pub const kCFCoreFoundationVersionNumber10_8_2: f64 = 744.12;
142pub const kCFCoreFoundationVersionNumber10_8_3: f64 = 744.18;
144pub const kCFCoreFoundationVersionNumber10_8_4: f64 = 744.19;
146pub const kCFCoreFoundationVersionNumber10_9: f64 = 855.11;
148pub const kCFCoreFoundationVersionNumber10_9_1: f64 = 855.11;
150pub const kCFCoreFoundationVersionNumber10_9_2: f64 = 855.14;
152pub const kCFCoreFoundationVersionNumber10_10: f64 = 1151.16;
154pub const kCFCoreFoundationVersionNumber10_10_1: f64 = 1151.16;
156pub const kCFCoreFoundationVersionNumber10_10_2: u32 = 1152;
158pub const kCFCoreFoundationVersionNumber10_10_3: f64 = 1153.18;
160pub const kCFCoreFoundationVersionNumber10_10_4: f64 = 1153.18;
162pub const kCFCoreFoundationVersionNumber10_10_5: f64 = 1153.18;
164pub const kCFCoreFoundationVersionNumber10_10_Max: u32 = 1199;
166pub const kCFCoreFoundationVersionNumber10_11: u32 = 1253;
168pub const kCFCoreFoundationVersionNumber10_11_1: f64 = 1255.1;
170pub const kCFCoreFoundationVersionNumber10_11_2: f64 = 1256.14;
172pub const kCFCoreFoundationVersionNumber10_11_3: f64 = 1256.14;
174pub const kCFCoreFoundationVersionNumber10_11_4: f64 = 1258.1;
176pub const kCFCoreFoundationVersionNumber10_11_Max: u32 = 1299;
178pub const kCFStringEncodingInvalidId: u32 = 4294967295;
180pub const DISPATCH_API_VERSION: u32 = 20181008;
182pub const DISPATCH_SWIFT3_OVERLAY: u32 = 0;
184pub const MSEC_PER_SEC: u32 = 1000;
186pub const DISPATCH_TIME_NOW: u32 = 0;
188pub const DISPATCH_TIME_FOREVER: i32 = -1;
190pub const DISPATCH_APPLY_AUTO_AVAILABLE: u32 = 1;
192pub const DISPATCH_QUEUE_PRIORITY_HIGH: u32 = 2;
194pub const DISPATCH_QUEUE_PRIORITY_DEFAULT: u32 = 0;
196pub const DISPATCH_QUEUE_PRIORITY_LOW: i32 = -2;
198pub const DISPATCH_QUEUE_PRIORITY_BACKGROUND: i32 = -32768;
200pub const DISPATCH_MACH_SEND_DEAD: u32 = 1;
202pub const DISPATCH_MEMORYPRESSURE_NORMAL: u32 = 1;
204pub const DISPATCH_MEMORYPRESSURE_WARN: u32 = 2;
206pub const DISPATCH_MEMORYPRESSURE_CRITICAL: u32 = 4;
208pub const DISPATCH_PROC_EXIT: u32 = 2147483648;
210pub const DISPATCH_PROC_FORK: u32 = 1073741824;
212pub const DISPATCH_PROC_EXEC: u32 = 536870912;
214pub const DISPATCH_PROC_SIGNAL: u32 = 134217728;
216pub const DISPATCH_VNODE_DELETE: u32 = 1;
218pub const DISPATCH_VNODE_WRITE: u32 = 2;
220pub const DISPATCH_VNODE_EXTEND: u32 = 4;
222pub const DISPATCH_VNODE_ATTRIB: u32 = 8;
224pub const DISPATCH_VNODE_LINK: u32 = 16;
226pub const DISPATCH_VNODE_RENAME: u32 = 32;
228pub const DISPATCH_VNODE_REVOKE: u32 = 64;
230pub const DISPATCH_VNODE_FUNLOCK: u32 = 256;
232pub const DISPATCH_TIMER_STRICT: u32 = 1;
234pub const DISPATCH_ONCE_INLINE_FASTPATH: u32 = 1;
236pub const DISPATCH_IO_STREAM: u32 = 0;
238pub const DISPATCH_IO_RANDOM: u32 = 1;
240pub const DISPATCH_IO_STOP: u32 = 1;
242pub const DISPATCH_IO_STRICT_INTERVAL: u32 = 1;
244pub const kCMTimeMaxTimescale: u32 = 2147483647;
246pub const kIOSurfaceSuccess: u32 = 0;
248pub type __uint16_t = ::core::ffi::c_ushort;
250pub type __uint32_t = ::core::ffi::c_uint;
252pub type __int64_t = ::core::ffi::c_longlong;
254pub type __darwin_natural_t = ::core::ffi::c_uint;
256pub type __darwin_time_t = ::core::ffi::c_long;
258pub type __darwin_gid_t = __uint32_t;
260pub type __darwin_mach_port_name_t = __darwin_natural_t;
262pub type __darwin_mach_port_t = __darwin_mach_port_name_t;
264pub type __darwin_mode_t = __uint16_t;
266pub type __darwin_off_t = __int64_t;
268pub type __darwin_uid_t = __uint32_t;
270pub type gid_t = __darwin_gid_t;
272pub type mode_t = __darwin_mode_t;
274pub type off_t = __darwin_off_t;
276pub type uid_t = __darwin_uid_t;
278pub type va_list = __builtin_va_list;
280#[repr(C)]
281#[derive(Debug, Copy, Clone)]
282pub struct _malloc_zone_t {
284 _unused: [u8; 0],
285}
286#[repr(C)]
287#[derive(Debug, Copy, Clone)]
288pub struct timespec {
290 pub tv_sec: __darwin_time_t,
291 pub tv_nsec: ::core::ffi::c_long,
292}
293pub type UInt8 = ::core::ffi::c_uchar;
295pub type SInt8 = ::core::ffi::c_schar;
297pub type UInt16 = ::core::ffi::c_ushort;
299pub type SInt16 = ::core::ffi::c_short;
301pub type UInt32 = ::core::ffi::c_uint;
303pub type SInt32 = ::core::ffi::c_int;
305pub type SInt64 = ::core::ffi::c_longlong;
307pub type Fixed = SInt32;
309pub type Float32 = f32;
311pub type Float64 = f64;
313pub type Ptr = *mut ::core::ffi::c_char;
315pub type Handle = *mut Ptr;
317pub type OSErr = SInt16;
319pub type OSStatus = SInt32;
321pub type ScriptCode = SInt16;
323pub type LangCode = SInt16;
325pub type RegionCode = SInt16;
327pub type FourCharCode = UInt32;
329pub type OSType = FourCharCode;
331pub type Boolean = ::core::ffi::c_uchar;
333pub type UTF32Char = UInt32;
335pub type UniChar = UInt16;
337pub type UniCharCount = ::core::ffi::c_ulong;
339pub type Str255 = [::core::ffi::c_uchar; 256usize];
341pub type StringPtr = *mut ::core::ffi::c_uchar;
343pub type ConstStringPtr = *const ::core::ffi::c_uchar;
345pub type ConstStr255Param = *const ::core::ffi::c_uchar;
347pub type CFAllocatorTypeID = ::core::ffi::c_ulonglong;
349extern "C" {
350pub static mut kCFCoreFoundationVersionNumber: f64;
352}
353pub type CFTypeID = ::core::ffi::c_ulong;
355pub type CFOptionFlags = ::core::ffi::c_ulong;
357pub type CFHashCode = ::core::ffi::c_ulong;
359pub type CFIndex = ::core::ffi::c_long;
361pub type CFTypeRef = *const ::core::ffi::c_void;
363#[repr(C)]
364#[derive(Debug, Copy, Clone)]
365pub struct __CFString {
367 _unused: [u8; 0],
368}
369pub type CFStringRef = *const __CFString;
371pub type CFMutableStringRef = *mut __CFString;
373pub type CFPropertyListRef = CFTypeRef;
375pub type CFComparisonResult = CFIndex;
377pub const kCFCompareLessThan: _bindgen_ty_7 = -1;
379pub const kCFCompareEqualTo: _bindgen_ty_7 = 0;
381pub const kCFCompareGreaterThan: _bindgen_ty_7 = 1;
383pub type _bindgen_ty_7 = ::core::ffi::c_int;
385pub type CFComparatorFunction = ::core::option::Option<
387 unsafe extern "C" fn(
388 val1: *const ::core::ffi::c_void,
389 val2: *const ::core::ffi::c_void,
390 context: *mut ::core::ffi::c_void,
391 ) -> CFComparisonResult,
392>;
393pub const kCFNotFound: CFIndex = -1;
395#[repr(C)]
396#[derive(Debug, Copy, Clone)]
397pub struct CFRange {
399 pub location: CFIndex,
400 pub length: CFIndex,
401}
402#[repr(C)]
403#[derive(Debug, Copy, Clone)]
404pub struct __CFNull {
406 _unused: [u8; 0],
407}
408pub type CFNullRef = *const __CFNull;
410extern "C" {
411pub fn CFNullGetTypeID() -> CFTypeID;
413}
414extern "C" {
415pub static kCFNull: CFNullRef;
417}
418#[repr(C)]
419#[derive(Debug, Copy, Clone)]
420pub struct __CFAllocator {
422 _unused: [u8; 0],
423}
424pub type CFAllocatorRef = *const __CFAllocator;
426extern "C" {
427pub static kCFAllocatorDefault: CFAllocatorRef;
429}
430extern "C" {
431pub static kCFAllocatorSystemDefault: CFAllocatorRef;
433}
434extern "C" {
435pub static kCFAllocatorMalloc: CFAllocatorRef;
437}
438extern "C" {
439pub static kCFAllocatorMallocZone: CFAllocatorRef;
441}
442extern "C" {
443pub static kCFAllocatorNull: CFAllocatorRef;
445}
446extern "C" {
447pub static kCFAllocatorUseContext: CFAllocatorRef;
449}
450pub type CFAllocatorRetainCallBack = ::core::option::Option<
452 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> *const ::core::ffi::c_void,
453>;
454pub type CFAllocatorReleaseCallBack =
456 ::core::option::Option<unsafe extern "C" fn(info: *const ::core::ffi::c_void)>;
457pub type CFAllocatorCopyDescriptionCallBack =
459 ::core::option::Option<unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> CFStringRef>;
460pub type CFAllocatorAllocateCallBack = ::core::option::Option<
462 unsafe extern "C" fn(
463 allocSize: CFIndex,
464 hint: CFOptionFlags,
465 info: *mut ::core::ffi::c_void,
466 ) -> *mut ::core::ffi::c_void,
467>;
468pub type CFAllocatorReallocateCallBack = ::core::option::Option<
470 unsafe extern "C" fn(
471 ptr: *mut ::core::ffi::c_void,
472 newsize: CFIndex,
473 hint: CFOptionFlags,
474 info: *mut ::core::ffi::c_void,
475 ) -> *mut ::core::ffi::c_void,
476>;
477pub type CFAllocatorDeallocateCallBack = ::core::option::Option<
479 unsafe extern "C" fn(ptr: *mut ::core::ffi::c_void, info: *mut ::core::ffi::c_void),
480>;
481pub type CFAllocatorPreferredSizeCallBack = ::core::option::Option<
483 unsafe extern "C" fn(
484 size: CFIndex,
485 hint: CFOptionFlags,
486 info: *mut ::core::ffi::c_void,
487 ) -> CFIndex,
488>;
489#[repr(C)]
490#[derive(Debug, Copy, Clone)]
491pub struct CFAllocatorContext {
493 pub version: CFIndex,
494 pub info: *mut ::core::ffi::c_void,
495 pub retain: CFAllocatorRetainCallBack,
496 pub release: CFAllocatorReleaseCallBack,
497 pub copyDescription: CFAllocatorCopyDescriptionCallBack,
498 pub allocate: CFAllocatorAllocateCallBack,
499 pub reallocate: CFAllocatorReallocateCallBack,
500 pub deallocate: CFAllocatorDeallocateCallBack,
501 pub preferredSize: CFAllocatorPreferredSizeCallBack,
502}
503extern "C" {
504pub fn CFAllocatorGetTypeID() -> CFTypeID;
506}
507extern "C" {
508pub fn CFAllocatorSetDefault(allocator: CFAllocatorRef);
510}
511extern "C" {
512pub fn CFAllocatorGetDefault() -> CFAllocatorRef;
514}
515extern "C" {
516pub fn CFAllocatorCreate(
518 allocator: CFAllocatorRef,
519 context: *mut CFAllocatorContext,
520 ) -> CFAllocatorRef;
521}
522extern "C" {
523pub fn CFAllocatorCreateWithZone(
525 allocator: CFAllocatorRef,
526 zone: *mut _malloc_zone_t,
527 ) -> CFAllocatorRef;
528}
529extern "C" {
530pub fn CFAllocatorAllocateTyped(
532 allocator: CFAllocatorRef,
533 size: CFIndex,
534 descriptor: CFAllocatorTypeID,
535 hint: CFOptionFlags,
536 ) -> *mut ::core::ffi::c_void;
537}
538extern "C" {
539pub fn CFAllocatorReallocateTyped(
541 allocator: CFAllocatorRef,
542 ptr: *mut ::core::ffi::c_void,
543 newsize: CFIndex,
544 descriptor: CFAllocatorTypeID,
545 hint: CFOptionFlags,
546 ) -> *mut ::core::ffi::c_void;
547}
548extern "C" {
549pub fn CFAllocatorAllocateBytes(
551 allocator: CFAllocatorRef,
552 size: CFIndex,
553 hint: CFOptionFlags,
554 ) -> *mut ::core::ffi::c_void;
555}
556extern "C" {
557pub fn CFAllocatorReallocateBytes(
559 allocator: CFAllocatorRef,
560 ptr: *mut ::core::ffi::c_void,
561 newsize: CFIndex,
562 hint: CFOptionFlags,
563 ) -> *mut ::core::ffi::c_void;
564}
565extern "C" {
566pub fn CFAllocatorAllocate(
568 allocator: CFAllocatorRef,
569 size: CFIndex,
570 hint: CFOptionFlags,
571 ) -> *mut ::core::ffi::c_void;
572}
573extern "C" {
574pub fn CFAllocatorReallocate(
576 allocator: CFAllocatorRef,
577 ptr: *mut ::core::ffi::c_void,
578 newsize: CFIndex,
579 hint: CFOptionFlags,
580 ) -> *mut ::core::ffi::c_void;
581}
582extern "C" {
583pub fn CFAllocatorDeallocate(allocator: CFAllocatorRef, ptr: *mut ::core::ffi::c_void);
585}
586extern "C" {
587pub fn CFAllocatorGetPreferredSizeForSize(
589 allocator: CFAllocatorRef,
590 size: CFIndex,
591 hint: CFOptionFlags,
592 ) -> CFIndex;
593}
594extern "C" {
595pub fn CFAllocatorGetContext(allocator: CFAllocatorRef, context: *mut CFAllocatorContext);
597}
598extern "C" {
599pub fn CFGetTypeID(cf: CFTypeRef) -> CFTypeID;
601}
602extern "C" {
603pub fn CFCopyTypeIDDescription(type_id: CFTypeID) -> CFStringRef;
605}
606extern "C" {
607pub fn CFRetain(cf: CFTypeRef) -> CFTypeRef;
609}
610extern "C" {
611pub fn CFRelease(cf: CFTypeRef);
613}
614extern "C" {
615pub fn CFAutorelease(arg: CFTypeRef) -> CFTypeRef;
617}
618extern "C" {
619pub fn CFGetRetainCount(cf: CFTypeRef) -> CFIndex;
621}
622extern "C" {
623pub fn CFEqual(cf1: CFTypeRef, cf2: CFTypeRef) -> Boolean;
625}
626extern "C" {
627pub fn CFHash(cf: CFTypeRef) -> CFHashCode;
629}
630extern "C" {
631pub fn CFCopyDescription(cf: CFTypeRef) -> CFStringRef;
633}
634extern "C" {
635pub fn CFGetAllocator(cf: CFTypeRef) -> CFAllocatorRef;
637}
638extern "C" {
639pub fn CFMakeCollectable(cf: CFTypeRef) -> CFTypeRef;
641}
642pub type CFArrayRetainCallBack = ::core::option::Option<
644 unsafe extern "C" fn(
645 allocator: CFAllocatorRef,
646 value: *const ::core::ffi::c_void,
647 ) -> *const ::core::ffi::c_void,
648>;
649pub type CFArrayReleaseCallBack = ::core::option::Option<
651 unsafe extern "C" fn(allocator: CFAllocatorRef, value: *const ::core::ffi::c_void),
652>;
653pub type CFArrayCopyDescriptionCallBack =
655 ::core::option::Option<unsafe extern "C" fn(value: *const ::core::ffi::c_void) -> CFStringRef>;
656pub type CFArrayEqualCallBack = ::core::option::Option<
658 unsafe extern "C" fn(
659 value1: *const ::core::ffi::c_void,
660 value2: *const ::core::ffi::c_void,
661 ) -> Boolean,
662>;
663#[repr(C)]
664#[derive(Debug, Copy, Clone)]
665pub struct CFArrayCallBacks {
667 pub version: CFIndex,
668 pub retain: CFArrayRetainCallBack,
669 pub release: CFArrayReleaseCallBack,
670 pub copyDescription: CFArrayCopyDescriptionCallBack,
671 pub equal: CFArrayEqualCallBack,
672}
673extern "C" {
674pub static kCFTypeArrayCallBacks: CFArrayCallBacks;
676}
677pub type CFArrayApplierFunction = ::core::option::Option<
679 unsafe extern "C" fn(value: *const ::core::ffi::c_void, context: *mut ::core::ffi::c_void),
680>;
681#[repr(C)]
682#[derive(Debug, Copy, Clone)]
683pub struct __CFArray {
685 _unused: [u8; 0],
686}
687pub type CFArrayRef = *const __CFArray;
689pub type CFMutableArrayRef = *mut __CFArray;
691extern "C" {
692pub fn CFArrayGetTypeID() -> CFTypeID;
694}
695extern "C" {
696pub fn CFArrayCreate(
698 allocator: CFAllocatorRef,
699 values: *mut *const ::core::ffi::c_void,
700 numValues: CFIndex,
701 callBacks: *const CFArrayCallBacks,
702 ) -> CFArrayRef;
703}
704extern "C" {
705pub fn CFArrayCreateCopy(allocator: CFAllocatorRef, theArray: CFArrayRef) -> CFArrayRef;
707}
708extern "C" {
709pub fn CFArrayCreateMutable(
711 allocator: CFAllocatorRef,
712 capacity: CFIndex,
713 callBacks: *const CFArrayCallBacks,
714 ) -> CFMutableArrayRef;
715}
716extern "C" {
717pub fn CFArrayCreateMutableCopy(
719 allocator: CFAllocatorRef,
720 capacity: CFIndex,
721 theArray: CFArrayRef,
722 ) -> CFMutableArrayRef;
723}
724extern "C" {
725pub fn CFArrayGetCount(theArray: CFArrayRef) -> CFIndex;
727}
728extern "C" {
729pub fn CFArrayGetCountOfValue(
731 theArray: CFArrayRef,
732 range: CFRange,
733 value: *const ::core::ffi::c_void,
734 ) -> CFIndex;
735}
736extern "C" {
737pub fn CFArrayContainsValue(
739 theArray: CFArrayRef,
740 range: CFRange,
741 value: *const ::core::ffi::c_void,
742 ) -> Boolean;
743}
744extern "C" {
745pub fn CFArrayGetValueAtIndex(theArray: CFArrayRef, idx: CFIndex)
747 -> *const ::core::ffi::c_void;
748}
749extern "C" {
750pub fn CFArrayGetValues(
752 theArray: CFArrayRef,
753 range: CFRange,
754 values: *mut *const ::core::ffi::c_void,
755 );
756}
757extern "C" {
758pub fn CFArrayApplyFunction(
760 theArray: CFArrayRef,
761 range: CFRange,
762 applier: CFArrayApplierFunction,
763 context: *mut ::core::ffi::c_void,
764 );
765}
766extern "C" {
767pub fn CFArrayGetFirstIndexOfValue(
769 theArray: CFArrayRef,
770 range: CFRange,
771 value: *const ::core::ffi::c_void,
772 ) -> CFIndex;
773}
774extern "C" {
775pub fn CFArrayGetLastIndexOfValue(
777 theArray: CFArrayRef,
778 range: CFRange,
779 value: *const ::core::ffi::c_void,
780 ) -> CFIndex;
781}
782extern "C" {
783pub fn CFArrayBSearchValues(
785 theArray: CFArrayRef,
786 range: CFRange,
787 value: *const ::core::ffi::c_void,
788 comparator: CFComparatorFunction,
789 context: *mut ::core::ffi::c_void,
790 ) -> CFIndex;
791}
792extern "C" {
793pub fn CFArrayAppendValue(theArray: CFMutableArrayRef, value: *const ::core::ffi::c_void);
795}
796extern "C" {
797pub fn CFArrayInsertValueAtIndex(
799 theArray: CFMutableArrayRef,
800 idx: CFIndex,
801 value: *const ::core::ffi::c_void,
802 );
803}
804extern "C" {
805pub fn CFArraySetValueAtIndex(
807 theArray: CFMutableArrayRef,
808 idx: CFIndex,
809 value: *const ::core::ffi::c_void,
810 );
811}
812extern "C" {
813pub fn CFArrayRemoveValueAtIndex(theArray: CFMutableArrayRef, idx: CFIndex);
815}
816extern "C" {
817pub fn CFArrayRemoveAllValues(theArray: CFMutableArrayRef);
819}
820extern "C" {
821pub fn CFArrayReplaceValues(
823 theArray: CFMutableArrayRef,
824 range: CFRange,
825 newValues: *mut *const ::core::ffi::c_void,
826 newCount: CFIndex,
827 );
828}
829extern "C" {
830pub fn CFArrayExchangeValuesAtIndices(
832 theArray: CFMutableArrayRef,
833 idx1: CFIndex,
834 idx2: CFIndex,
835 );
836}
837extern "C" {
838pub fn CFArraySortValues(
840 theArray: CFMutableArrayRef,
841 range: CFRange,
842 comparator: CFComparatorFunction,
843 context: *mut ::core::ffi::c_void,
844 );
845}
846extern "C" {
847pub fn CFArrayAppendArray(
849 theArray: CFMutableArrayRef,
850 otherArray: CFArrayRef,
851 otherRange: CFRange,
852 );
853}
854pub type CFBagRetainCallBack = ::core::option::Option<
856 unsafe extern "C" fn(
857 allocator: CFAllocatorRef,
858 value: *const ::core::ffi::c_void,
859 ) -> *const ::core::ffi::c_void,
860>;
861pub type CFBagReleaseCallBack = ::core::option::Option<
863 unsafe extern "C" fn(allocator: CFAllocatorRef, value: *const ::core::ffi::c_void),
864>;
865pub type CFBagCopyDescriptionCallBack =
867 ::core::option::Option<unsafe extern "C" fn(value: *const ::core::ffi::c_void) -> CFStringRef>;
868pub type CFBagEqualCallBack = ::core::option::Option<
870 unsafe extern "C" fn(
871 value1: *const ::core::ffi::c_void,
872 value2: *const ::core::ffi::c_void,
873 ) -> Boolean,
874>;
875pub type CFBagHashCallBack =
877 ::core::option::Option<unsafe extern "C" fn(value: *const ::core::ffi::c_void) -> CFHashCode>;
878#[repr(C)]
879#[derive(Debug, Copy, Clone)]
880pub struct CFBagCallBacks {
882 pub version: CFIndex,
883 pub retain: CFBagRetainCallBack,
884 pub release: CFBagReleaseCallBack,
885 pub copyDescription: CFBagCopyDescriptionCallBack,
886 pub equal: CFBagEqualCallBack,
887 pub hash: CFBagHashCallBack,
888}
889extern "C" {
890pub static kCFTypeBagCallBacks: CFBagCallBacks;
892}
893extern "C" {
894pub static kCFCopyStringBagCallBacks: CFBagCallBacks;
896}
897pub type CFBagApplierFunction = ::core::option::Option<
899 unsafe extern "C" fn(value: *const ::core::ffi::c_void, context: *mut ::core::ffi::c_void),
900>;
901#[repr(C)]
902#[derive(Debug, Copy, Clone)]
903pub struct __CFBag {
905 _unused: [u8; 0],
906}
907pub type CFBagRef = *const __CFBag;
909pub type CFMutableBagRef = *mut __CFBag;
911extern "C" {
912pub fn CFBagGetTypeID() -> CFTypeID;
914}
915extern "C" {
916pub fn CFBagCreate(
918 allocator: CFAllocatorRef,
919 values: *mut *const ::core::ffi::c_void,
920 numValues: CFIndex,
921 callBacks: *const CFBagCallBacks,
922 ) -> CFBagRef;
923}
924extern "C" {
925pub fn CFBagCreateCopy(allocator: CFAllocatorRef, theBag: CFBagRef) -> CFBagRef;
927}
928extern "C" {
929pub fn CFBagCreateMutable(
931 allocator: CFAllocatorRef,
932 capacity: CFIndex,
933 callBacks: *const CFBagCallBacks,
934 ) -> CFMutableBagRef;
935}
936extern "C" {
937pub fn CFBagCreateMutableCopy(
939 allocator: CFAllocatorRef,
940 capacity: CFIndex,
941 theBag: CFBagRef,
942 ) -> CFMutableBagRef;
943}
944extern "C" {
945pub fn CFBagGetCount(theBag: CFBagRef) -> CFIndex;
947}
948extern "C" {
949pub fn CFBagGetCountOfValue(theBag: CFBagRef, value: *const ::core::ffi::c_void) -> CFIndex;
951}
952extern "C" {
953pub fn CFBagContainsValue(theBag: CFBagRef, value: *const ::core::ffi::c_void) -> Boolean;
955}
956extern "C" {
957pub fn CFBagGetValue(
959 theBag: CFBagRef,
960 value: *const ::core::ffi::c_void,
961 ) -> *const ::core::ffi::c_void;
962}
963extern "C" {
964pub fn CFBagGetValueIfPresent(
966 theBag: CFBagRef,
967 candidate: *const ::core::ffi::c_void,
968 value: *mut *const ::core::ffi::c_void,
969 ) -> Boolean;
970}
971extern "C" {
972pub fn CFBagGetValues(theBag: CFBagRef, values: *mut *const ::core::ffi::c_void);
974}
975extern "C" {
976pub fn CFBagApplyFunction(
978 theBag: CFBagRef,
979 applier: CFBagApplierFunction,
980 context: *mut ::core::ffi::c_void,
981 );
982}
983extern "C" {
984pub fn CFBagAddValue(theBag: CFMutableBagRef, value: *const ::core::ffi::c_void);
986}
987extern "C" {
988pub fn CFBagReplaceValue(theBag: CFMutableBagRef, value: *const ::core::ffi::c_void);
990}
991extern "C" {
992pub fn CFBagSetValue(theBag: CFMutableBagRef, value: *const ::core::ffi::c_void);
994}
995extern "C" {
996pub fn CFBagRemoveValue(theBag: CFMutableBagRef, value: *const ::core::ffi::c_void);
998}
999extern "C" {
1000pub fn CFBagRemoveAllValues(theBag: CFMutableBagRef);
1002}
1003#[repr(C)]
1004#[derive(Debug, Copy, Clone)]
1005pub struct CFBinaryHeapCompareContext {
1007 pub version: CFIndex,
1008 pub info: *mut ::core::ffi::c_void,
1009 pub retain: ::core::option::Option<
1010 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> *const ::core::ffi::c_void,
1011 >,
1012 pub release: ::core::option::Option<unsafe extern "C" fn(info: *const ::core::ffi::c_void)>,
1013 pub copyDescription: ::core::option::Option<
1014 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> CFStringRef,
1015 >,
1016}
1017#[repr(C)]
1018#[derive(Debug, Copy, Clone)]
1019pub struct CFBinaryHeapCallBacks {
1021 pub version: CFIndex,
1022 pub retain: ::core::option::Option<
1023 unsafe extern "C" fn(
1024 allocator: CFAllocatorRef,
1025 ptr: *const ::core::ffi::c_void,
1026 ) -> *const ::core::ffi::c_void,
1027 >,
1028 pub release: ::core::option::Option<
1029 unsafe extern "C" fn(allocator: CFAllocatorRef, ptr: *const ::core::ffi::c_void),
1030 >,
1031 pub copyDescription: ::core::option::Option<
1032 unsafe extern "C" fn(ptr: *const ::core::ffi::c_void) -> CFStringRef,
1033 >,
1034 pub compare: ::core::option::Option<
1035 unsafe extern "C" fn(
1036 ptr1: *const ::core::ffi::c_void,
1037 ptr2: *const ::core::ffi::c_void,
1038 context: *mut ::core::ffi::c_void,
1039 ) -> CFComparisonResult,
1040 >,
1041}
1042extern "C" {
1043pub static kCFStringBinaryHeapCallBacks: CFBinaryHeapCallBacks;
1045}
1046pub type CFBinaryHeapApplierFunction = ::core::option::Option<
1048 unsafe extern "C" fn(val: *const ::core::ffi::c_void, context: *mut ::core::ffi::c_void),
1049>;
1050#[repr(C)]
1051#[derive(Debug, Copy, Clone)]
1052pub struct __CFBinaryHeap {
1054 _unused: [u8; 0],
1055}
1056pub type CFBinaryHeapRef = *mut __CFBinaryHeap;
1058extern "C" {
1059pub fn CFBinaryHeapGetTypeID() -> CFTypeID;
1061}
1062extern "C" {
1063pub fn CFBinaryHeapCreate(
1065 allocator: CFAllocatorRef,
1066 capacity: CFIndex,
1067 callBacks: *const CFBinaryHeapCallBacks,
1068 compareContext: *const CFBinaryHeapCompareContext,
1069 ) -> CFBinaryHeapRef;
1070}
1071extern "C" {
1072pub fn CFBinaryHeapCreateCopy(
1074 allocator: CFAllocatorRef,
1075 capacity: CFIndex,
1076 heap: CFBinaryHeapRef,
1077 ) -> CFBinaryHeapRef;
1078}
1079extern "C" {
1080pub fn CFBinaryHeapGetCount(heap: CFBinaryHeapRef) -> CFIndex;
1082}
1083extern "C" {
1084pub fn CFBinaryHeapGetCountOfValue(
1086 heap: CFBinaryHeapRef,
1087 value: *const ::core::ffi::c_void,
1088 ) -> CFIndex;
1089}
1090extern "C" {
1091pub fn CFBinaryHeapContainsValue(
1093 heap: CFBinaryHeapRef,
1094 value: *const ::core::ffi::c_void,
1095 ) -> Boolean;
1096}
1097extern "C" {
1098pub fn CFBinaryHeapGetMinimum(heap: CFBinaryHeapRef) -> *const ::core::ffi::c_void;
1100}
1101extern "C" {
1102pub fn CFBinaryHeapGetMinimumIfPresent(
1104 heap: CFBinaryHeapRef,
1105 value: *mut *const ::core::ffi::c_void,
1106 ) -> Boolean;
1107}
1108extern "C" {
1109pub fn CFBinaryHeapGetValues(heap: CFBinaryHeapRef, values: *mut *const ::core::ffi::c_void);
1111}
1112extern "C" {
1113pub fn CFBinaryHeapApplyFunction(
1115 heap: CFBinaryHeapRef,
1116 applier: CFBinaryHeapApplierFunction,
1117 context: *mut ::core::ffi::c_void,
1118 );
1119}
1120extern "C" {
1121pub fn CFBinaryHeapAddValue(heap: CFBinaryHeapRef, value: *const ::core::ffi::c_void);
1123}
1124extern "C" {
1125pub fn CFBinaryHeapRemoveMinimumValue(heap: CFBinaryHeapRef);
1127}
1128extern "C" {
1129pub fn CFBinaryHeapRemoveAllValues(heap: CFBinaryHeapRef);
1131}
1132pub type CFBit = UInt32;
1134#[repr(C)]
1135#[derive(Debug, Copy, Clone)]
1136pub struct __CFBitVector {
1138 _unused: [u8; 0],
1139}
1140pub type CFBitVectorRef = *const __CFBitVector;
1142pub type CFMutableBitVectorRef = *mut __CFBitVector;
1144extern "C" {
1145pub fn CFBitVectorGetTypeID() -> CFTypeID;
1147}
1148extern "C" {
1149pub fn CFBitVectorCreate(
1151 allocator: CFAllocatorRef,
1152 bytes: *const UInt8,
1153 numBits: CFIndex,
1154 ) -> CFBitVectorRef;
1155}
1156extern "C" {
1157pub fn CFBitVectorCreateCopy(allocator: CFAllocatorRef, bv: CFBitVectorRef) -> CFBitVectorRef;
1159}
1160extern "C" {
1161pub fn CFBitVectorCreateMutable(
1163 allocator: CFAllocatorRef,
1164 capacity: CFIndex,
1165 ) -> CFMutableBitVectorRef;
1166}
1167extern "C" {
1168pub fn CFBitVectorCreateMutableCopy(
1170 allocator: CFAllocatorRef,
1171 capacity: CFIndex,
1172 bv: CFBitVectorRef,
1173 ) -> CFMutableBitVectorRef;
1174}
1175extern "C" {
1176pub fn CFBitVectorGetCount(bv: CFBitVectorRef) -> CFIndex;
1178}
1179extern "C" {
1180pub fn CFBitVectorGetCountOfBit(bv: CFBitVectorRef, range: CFRange, value: CFBit) -> CFIndex;
1182}
1183extern "C" {
1184pub fn CFBitVectorContainsBit(bv: CFBitVectorRef, range: CFRange, value: CFBit) -> Boolean;
1186}
1187extern "C" {
1188pub fn CFBitVectorGetBitAtIndex(bv: CFBitVectorRef, idx: CFIndex) -> CFBit;
1190}
1191extern "C" {
1192pub fn CFBitVectorGetBits(bv: CFBitVectorRef, range: CFRange, bytes: *mut UInt8);
1194}
1195extern "C" {
1196pub fn CFBitVectorGetFirstIndexOfBit(
1198 bv: CFBitVectorRef,
1199 range: CFRange,
1200 value: CFBit,
1201 ) -> CFIndex;
1202}
1203extern "C" {
1204pub fn CFBitVectorGetLastIndexOfBit(
1206 bv: CFBitVectorRef,
1207 range: CFRange,
1208 value: CFBit,
1209 ) -> CFIndex;
1210}
1211extern "C" {
1212pub fn CFBitVectorSetCount(bv: CFMutableBitVectorRef, count: CFIndex);
1214}
1215extern "C" {
1216pub fn CFBitVectorFlipBitAtIndex(bv: CFMutableBitVectorRef, idx: CFIndex);
1218}
1219extern "C" {
1220pub fn CFBitVectorFlipBits(bv: CFMutableBitVectorRef, range: CFRange);
1222}
1223extern "C" {
1224pub fn CFBitVectorSetBitAtIndex(bv: CFMutableBitVectorRef, idx: CFIndex, value: CFBit);
1226}
1227extern "C" {
1228pub fn CFBitVectorSetBits(bv: CFMutableBitVectorRef, range: CFRange, value: CFBit);
1230}
1231extern "C" {
1232pub fn CFBitVectorSetAllBits(bv: CFMutableBitVectorRef, value: CFBit);
1234}
1235pub type CFByteOrder = CFIndex;
1237#[repr(C)]
1238#[derive(Debug, Copy, Clone)]
1239pub struct CFSwappedFloat32 {
1241 pub v: u32,
1242}
1243#[repr(C)]
1244#[derive(Debug, Copy, Clone)]
1245pub struct CFSwappedFloat64 {
1247 pub v: u64,
1248}
1249pub type CFDictionaryRetainCallBack = ::core::option::Option<
1251 unsafe extern "C" fn(
1252 allocator: CFAllocatorRef,
1253 value: *const ::core::ffi::c_void,
1254 ) -> *const ::core::ffi::c_void,
1255>;
1256pub type CFDictionaryReleaseCallBack = ::core::option::Option<
1258 unsafe extern "C" fn(allocator: CFAllocatorRef, value: *const ::core::ffi::c_void),
1259>;
1260pub type CFDictionaryCopyDescriptionCallBack =
1262 ::core::option::Option<unsafe extern "C" fn(value: *const ::core::ffi::c_void) -> CFStringRef>;
1263pub type CFDictionaryEqualCallBack = ::core::option::Option<
1265 unsafe extern "C" fn(
1266 value1: *const ::core::ffi::c_void,
1267 value2: *const ::core::ffi::c_void,
1268 ) -> Boolean,
1269>;
1270pub type CFDictionaryHashCallBack =
1272 ::core::option::Option<unsafe extern "C" fn(value: *const ::core::ffi::c_void) -> CFHashCode>;
1273#[repr(C)]
1274#[derive(Debug, Copy, Clone)]
1275pub struct CFDictionaryKeyCallBacks {
1277 pub version: CFIndex,
1278 pub retain: CFDictionaryRetainCallBack,
1279 pub release: CFDictionaryReleaseCallBack,
1280 pub copyDescription: CFDictionaryCopyDescriptionCallBack,
1281 pub equal: CFDictionaryEqualCallBack,
1282 pub hash: CFDictionaryHashCallBack,
1283}
1284extern "C" {
1285pub static kCFTypeDictionaryKeyCallBacks: CFDictionaryKeyCallBacks;
1287}
1288extern "C" {
1289pub static kCFCopyStringDictionaryKeyCallBacks: CFDictionaryKeyCallBacks;
1291}
1292#[repr(C)]
1293#[derive(Debug, Copy, Clone)]
1294pub struct CFDictionaryValueCallBacks {
1296 pub version: CFIndex,
1297 pub retain: CFDictionaryRetainCallBack,
1298 pub release: CFDictionaryReleaseCallBack,
1299 pub copyDescription: CFDictionaryCopyDescriptionCallBack,
1300 pub equal: CFDictionaryEqualCallBack,
1301}
1302extern "C" {
1303pub static kCFTypeDictionaryValueCallBacks: CFDictionaryValueCallBacks;
1305}
1306pub type CFDictionaryApplierFunction = ::core::option::Option<
1308 unsafe extern "C" fn(
1309 key: *const ::core::ffi::c_void,
1310 value: *const ::core::ffi::c_void,
1311 context: *mut ::core::ffi::c_void,
1312 ),
1313>;
1314#[repr(C)]
1315#[derive(Debug, Copy, Clone)]
1316pub struct __CFDictionary {
1318 _unused: [u8; 0],
1319}
1320pub type CFDictionaryRef = *const __CFDictionary;
1322pub type CFMutableDictionaryRef = *mut __CFDictionary;
1324extern "C" {
1325pub fn CFDictionaryGetTypeID() -> CFTypeID;
1327}
1328extern "C" {
1329pub fn CFDictionaryCreate(
1331 allocator: CFAllocatorRef,
1332 keys: *mut *const ::core::ffi::c_void,
1333 values: *mut *const ::core::ffi::c_void,
1334 numValues: CFIndex,
1335 keyCallBacks: *const CFDictionaryKeyCallBacks,
1336 valueCallBacks: *const CFDictionaryValueCallBacks,
1337 ) -> CFDictionaryRef;
1338}
1339extern "C" {
1340pub fn CFDictionaryCreateCopy(
1342 allocator: CFAllocatorRef,
1343 theDict: CFDictionaryRef,
1344 ) -> CFDictionaryRef;
1345}
1346extern "C" {
1347pub fn CFDictionaryCreateMutable(
1349 allocator: CFAllocatorRef,
1350 capacity: CFIndex,
1351 keyCallBacks: *const CFDictionaryKeyCallBacks,
1352 valueCallBacks: *const CFDictionaryValueCallBacks,
1353 ) -> CFMutableDictionaryRef;
1354}
1355extern "C" {
1356pub fn CFDictionaryCreateMutableCopy(
1358 allocator: CFAllocatorRef,
1359 capacity: CFIndex,
1360 theDict: CFDictionaryRef,
1361 ) -> CFMutableDictionaryRef;
1362}
1363extern "C" {
1364pub fn CFDictionaryGetCount(theDict: CFDictionaryRef) -> CFIndex;
1366}
1367extern "C" {
1368pub fn CFDictionaryGetCountOfKey(
1370 theDict: CFDictionaryRef,
1371 key: *const ::core::ffi::c_void,
1372 ) -> CFIndex;
1373}
1374extern "C" {
1375pub fn CFDictionaryGetCountOfValue(
1377 theDict: CFDictionaryRef,
1378 value: *const ::core::ffi::c_void,
1379 ) -> CFIndex;
1380}
1381extern "C" {
1382pub fn CFDictionaryContainsKey(
1384 theDict: CFDictionaryRef,
1385 key: *const ::core::ffi::c_void,
1386 ) -> Boolean;
1387}
1388extern "C" {
1389pub fn CFDictionaryContainsValue(
1391 theDict: CFDictionaryRef,
1392 value: *const ::core::ffi::c_void,
1393 ) -> Boolean;
1394}
1395extern "C" {
1396pub fn CFDictionaryGetValue(
1398 theDict: CFDictionaryRef,
1399 key: *const ::core::ffi::c_void,
1400 ) -> *const ::core::ffi::c_void;
1401}
1402extern "C" {
1403pub fn CFDictionaryGetValueIfPresent(
1405 theDict: CFDictionaryRef,
1406 key: *const ::core::ffi::c_void,
1407 value: *mut *const ::core::ffi::c_void,
1408 ) -> Boolean;
1409}
1410extern "C" {
1411pub fn CFDictionaryGetKeysAndValues(
1413 theDict: CFDictionaryRef,
1414 keys: *mut *const ::core::ffi::c_void,
1415 values: *mut *const ::core::ffi::c_void,
1416 );
1417}
1418extern "C" {
1419pub fn CFDictionaryApplyFunction(
1421 theDict: CFDictionaryRef,
1422 applier: CFDictionaryApplierFunction,
1423 context: *mut ::core::ffi::c_void,
1424 );
1425}
1426extern "C" {
1427pub fn CFDictionaryAddValue(
1429 theDict: CFMutableDictionaryRef,
1430 key: *const ::core::ffi::c_void,
1431 value: *const ::core::ffi::c_void,
1432 );
1433}
1434extern "C" {
1435pub fn CFDictionarySetValue(
1437 theDict: CFMutableDictionaryRef,
1438 key: *const ::core::ffi::c_void,
1439 value: *const ::core::ffi::c_void,
1440 );
1441}
1442extern "C" {
1443pub fn CFDictionaryReplaceValue(
1445 theDict: CFMutableDictionaryRef,
1446 key: *const ::core::ffi::c_void,
1447 value: *const ::core::ffi::c_void,
1448 );
1449}
1450extern "C" {
1451pub fn CFDictionaryRemoveValue(
1453 theDict: CFMutableDictionaryRef,
1454 key: *const ::core::ffi::c_void,
1455 );
1456}
1457extern "C" {
1458pub fn CFDictionaryRemoveAllValues(theDict: CFMutableDictionaryRef);
1460}
1461pub type CFNotificationName = CFStringRef;
1463#[repr(C)]
1464#[derive(Debug, Copy, Clone)]
1465pub struct __CFNotificationCenter {
1467 _unused: [u8; 0],
1468}
1469pub type CFNotificationCenterRef = *mut __CFNotificationCenter;
1471pub type CFNotificationCallback = ::core::option::Option<
1473 unsafe extern "C" fn(
1474 center: CFNotificationCenterRef,
1475 observer: *mut ::core::ffi::c_void,
1476 name: CFNotificationName,
1477 object: *const ::core::ffi::c_void,
1478 userInfo: CFDictionaryRef,
1479 ),
1480>;
1481pub type CFNotificationSuspensionBehavior = CFIndex;
1483extern "C" {
1484pub fn CFNotificationCenterGetTypeID() -> CFTypeID;
1486}
1487extern "C" {
1488pub fn CFNotificationCenterGetLocalCenter() -> CFNotificationCenterRef;
1490}
1491extern "C" {
1492pub fn CFNotificationCenterGetDistributedCenter() -> CFNotificationCenterRef;
1494}
1495extern "C" {
1496pub fn CFNotificationCenterGetDarwinNotifyCenter() -> CFNotificationCenterRef;
1498}
1499extern "C" {
1500pub fn CFNotificationCenterAddObserver(
1502 center: CFNotificationCenterRef,
1503 observer: *const ::core::ffi::c_void,
1504 callBack: CFNotificationCallback,
1505 name: CFStringRef,
1506 object: *const ::core::ffi::c_void,
1507 suspensionBehavior: CFNotificationSuspensionBehavior,
1508 );
1509}
1510extern "C" {
1511pub fn CFNotificationCenterRemoveObserver(
1513 center: CFNotificationCenterRef,
1514 observer: *const ::core::ffi::c_void,
1515 name: CFNotificationName,
1516 object: *const ::core::ffi::c_void,
1517 );
1518}
1519extern "C" {
1520pub fn CFNotificationCenterRemoveEveryObserver(
1522 center: CFNotificationCenterRef,
1523 observer: *const ::core::ffi::c_void,
1524 );
1525}
1526extern "C" {
1527pub fn CFNotificationCenterPostNotification(
1529 center: CFNotificationCenterRef,
1530 name: CFNotificationName,
1531 object: *const ::core::ffi::c_void,
1532 userInfo: CFDictionaryRef,
1533 deliverImmediately: Boolean,
1534 );
1535}
1536pub const kCFNotificationDeliverImmediately: _bindgen_ty_10 = 1;
1538pub const kCFNotificationPostToAllSessions: _bindgen_ty_10 = 2;
1540pub type _bindgen_ty_10 = ::core::ffi::c_uint;
1542extern "C" {
1543pub fn CFNotificationCenterPostNotificationWithOptions(
1545 center: CFNotificationCenterRef,
1546 name: CFNotificationName,
1547 object: *const ::core::ffi::c_void,
1548 userInfo: CFDictionaryRef,
1549 options: CFOptionFlags,
1550 );
1551}
1552pub type CFLocaleIdentifier = CFStringRef;
1554pub type CFLocaleKey = CFStringRef;
1556#[repr(C)]
1557#[derive(Debug, Copy, Clone)]
1558pub struct __CFLocale {
1560 _unused: [u8; 0],
1561}
1562pub type CFLocaleRef = *const __CFLocale;
1564extern "C" {
1565pub fn CFLocaleGetTypeID() -> CFTypeID;
1567}
1568extern "C" {
1569pub fn CFLocaleGetSystem() -> CFLocaleRef;
1571}
1572extern "C" {
1573pub fn CFLocaleCopyCurrent() -> CFLocaleRef;
1575}
1576extern "C" {
1577pub fn CFLocaleCopyAvailableLocaleIdentifiers() -> CFArrayRef;
1579}
1580extern "C" {
1581pub fn CFLocaleCopyISOLanguageCodes() -> CFArrayRef;
1583}
1584extern "C" {
1585pub fn CFLocaleCopyISOCountryCodes() -> CFArrayRef;
1587}
1588extern "C" {
1589pub fn CFLocaleCopyISOCurrencyCodes() -> CFArrayRef;
1591}
1592extern "C" {
1593pub fn CFLocaleCopyCommonISOCurrencyCodes() -> CFArrayRef;
1595}
1596extern "C" {
1597pub fn CFLocaleCopyPreferredLanguages() -> CFArrayRef;
1599}
1600extern "C" {
1601pub fn CFLocaleCreateCanonicalLanguageIdentifierFromString(
1603 allocator: CFAllocatorRef,
1604 localeIdentifier: CFStringRef,
1605 ) -> CFLocaleIdentifier;
1606}
1607extern "C" {
1608pub fn CFLocaleCreateCanonicalLocaleIdentifierFromString(
1610 allocator: CFAllocatorRef,
1611 localeIdentifier: CFStringRef,
1612 ) -> CFLocaleIdentifier;
1613}
1614extern "C" {
1615pub fn CFLocaleCreateCanonicalLocaleIdentifierFromScriptManagerCodes(
1617 allocator: CFAllocatorRef,
1618 lcode: LangCode,
1619 rcode: RegionCode,
1620 ) -> CFLocaleIdentifier;
1621}
1622extern "C" {
1623pub fn CFLocaleCreateLocaleIdentifierFromWindowsLocaleCode(
1625 allocator: CFAllocatorRef,
1626 lcid: u32,
1627 ) -> CFLocaleIdentifier;
1628}
1629extern "C" {
1630pub fn CFLocaleGetWindowsLocaleCodeFromLocaleIdentifier(
1632 localeIdentifier: CFLocaleIdentifier,
1633 ) -> u32;
1634}
1635pub type CFLocaleLanguageDirection = CFIndex;
1637pub const kCFLocaleLanguageDirectionUnknown: _bindgen_ty_11 = 0;
1639pub const kCFLocaleLanguageDirectionLeftToRight: _bindgen_ty_11 = 1;
1641pub const kCFLocaleLanguageDirectionRightToLeft: _bindgen_ty_11 = 2;
1643pub const kCFLocaleLanguageDirectionTopToBottom: _bindgen_ty_11 = 3;
1645pub const kCFLocaleLanguageDirectionBottomToTop: _bindgen_ty_11 = 4;
1647pub type _bindgen_ty_11 = ::core::ffi::c_uint;
1649extern "C" {
1650pub fn CFLocaleGetLanguageCharacterDirection(
1652 isoLangCode: CFStringRef,
1653 ) -> CFLocaleLanguageDirection;
1654}
1655extern "C" {
1656pub fn CFLocaleGetLanguageLineDirection(isoLangCode: CFStringRef) -> CFLocaleLanguageDirection;
1658}
1659extern "C" {
1660pub fn CFLocaleCreateComponentsFromLocaleIdentifier(
1662 allocator: CFAllocatorRef,
1663 localeID: CFLocaleIdentifier,
1664 ) -> CFDictionaryRef;
1665}
1666extern "C" {
1667pub fn CFLocaleCreateLocaleIdentifierFromComponents(
1669 allocator: CFAllocatorRef,
1670 dictionary: CFDictionaryRef,
1671 ) -> CFLocaleIdentifier;
1672}
1673extern "C" {
1674pub fn CFLocaleCreate(
1676 allocator: CFAllocatorRef,
1677 localeIdentifier: CFLocaleIdentifier,
1678 ) -> CFLocaleRef;
1679}
1680extern "C" {
1681pub fn CFLocaleCreateCopy(allocator: CFAllocatorRef, locale: CFLocaleRef) -> CFLocaleRef;
1683}
1684extern "C" {
1685pub fn CFLocaleGetIdentifier(locale: CFLocaleRef) -> CFLocaleIdentifier;
1687}
1688extern "C" {
1689pub fn CFLocaleGetValue(locale: CFLocaleRef, key: CFLocaleKey) -> CFTypeRef;
1691}
1692extern "C" {
1693pub fn CFLocaleCopyDisplayNameForPropertyValue(
1695 displayLocale: CFLocaleRef,
1696 key: CFLocaleKey,
1697 value: CFStringRef,
1698 ) -> CFStringRef;
1699}
1700extern "C" {
1701pub static kCFLocaleCurrentLocaleDidChangeNotification: CFNotificationName;
1703}
1704extern "C" {
1705pub static kCFLocaleIdentifier: CFLocaleKey;
1707}
1708extern "C" {
1709pub static kCFLocaleLanguageCode: CFLocaleKey;
1711}
1712extern "C" {
1713pub static kCFLocaleCountryCode: CFLocaleKey;
1715}
1716extern "C" {
1717pub static kCFLocaleScriptCode: CFLocaleKey;
1719}
1720extern "C" {
1721pub static kCFLocaleVariantCode: CFLocaleKey;
1723}
1724extern "C" {
1725pub static kCFLocaleExemplarCharacterSet: CFLocaleKey;
1727}
1728extern "C" {
1729pub static kCFLocaleCalendarIdentifier: CFLocaleKey;
1731}
1732extern "C" {
1733pub static kCFLocaleCalendar: CFLocaleKey;
1735}
1736extern "C" {
1737pub static kCFLocaleCollationIdentifier: CFLocaleKey;
1739}
1740extern "C" {
1741pub static kCFLocaleUsesMetricSystem: CFLocaleKey;
1743}
1744extern "C" {
1745pub static kCFLocaleMeasurementSystem: CFLocaleKey;
1747}
1748extern "C" {
1749pub static kCFLocaleDecimalSeparator: CFLocaleKey;
1751}
1752extern "C" {
1753pub static kCFLocaleGroupingSeparator: CFLocaleKey;
1755}
1756extern "C" {
1757pub static kCFLocaleCurrencySymbol: CFLocaleKey;
1759}
1760extern "C" {
1761pub static kCFLocaleCurrencyCode: CFLocaleKey;
1763}
1764extern "C" {
1765pub static kCFLocaleCollatorIdentifier: CFLocaleKey;
1767}
1768extern "C" {
1769pub static kCFLocaleQuotationBeginDelimiterKey: CFLocaleKey;
1771}
1772extern "C" {
1773pub static kCFLocaleQuotationEndDelimiterKey: CFLocaleKey;
1775}
1776extern "C" {
1777pub static kCFLocaleAlternateQuotationBeginDelimiterKey: CFLocaleKey;
1779}
1780extern "C" {
1781pub static kCFLocaleAlternateQuotationEndDelimiterKey: CFLocaleKey;
1783}
1784pub type CFCalendarIdentifier = CFStringRef;
1786extern "C" {
1787pub static kCFGregorianCalendar: CFCalendarIdentifier;
1789}
1790extern "C" {
1791pub static kCFBuddhistCalendar: CFCalendarIdentifier;
1793}
1794extern "C" {
1795pub static kCFChineseCalendar: CFCalendarIdentifier;
1797}
1798extern "C" {
1799pub static kCFHebrewCalendar: CFCalendarIdentifier;
1801}
1802extern "C" {
1803pub static kCFIslamicCalendar: CFCalendarIdentifier;
1805}
1806extern "C" {
1807pub static kCFIslamicCivilCalendar: CFCalendarIdentifier;
1809}
1810extern "C" {
1811pub static kCFJapaneseCalendar: CFCalendarIdentifier;
1813}
1814extern "C" {
1815pub static kCFRepublicOfChinaCalendar: CFCalendarIdentifier;
1817}
1818extern "C" {
1819pub static kCFPersianCalendar: CFCalendarIdentifier;
1821}
1822extern "C" {
1823pub static kCFIndianCalendar: CFCalendarIdentifier;
1825}
1826extern "C" {
1827pub static kCFISO8601Calendar: CFCalendarIdentifier;
1829}
1830extern "C" {
1831pub static kCFIslamicTabularCalendar: CFCalendarIdentifier;
1833}
1834extern "C" {
1835pub static kCFIslamicUmmAlQuraCalendar: CFCalendarIdentifier;
1837}
1838extern "C" {
1839pub static kCFBanglaCalendar: CFCalendarIdentifier;
1841}
1842extern "C" {
1843pub static kCFGujaratiCalendar: CFCalendarIdentifier;
1845}
1846extern "C" {
1847pub static kCFKannadaCalendar: CFCalendarIdentifier;
1849}
1850extern "C" {
1851pub static kCFMalayalamCalendar: CFCalendarIdentifier;
1853}
1854extern "C" {
1855pub static kCFMarathiCalendar: CFCalendarIdentifier;
1857}
1858extern "C" {
1859pub static kCFOdiaCalendar: CFCalendarIdentifier;
1861}
1862extern "C" {
1863pub static kCFTamilCalendar: CFCalendarIdentifier;
1865}
1866extern "C" {
1867pub static kCFTeluguCalendar: CFCalendarIdentifier;
1869}
1870extern "C" {
1871pub static kCFVikramCalendar: CFCalendarIdentifier;
1873}
1874extern "C" {
1875pub static kCFDangiCalendar: CFCalendarIdentifier;
1877}
1878extern "C" {
1879pub static kCFVietnameseCalendar: CFCalendarIdentifier;
1881}
1882pub type CFTimeInterval = f64;
1884pub type CFAbsoluteTime = CFTimeInterval;
1886extern "C" {
1887pub fn CFAbsoluteTimeGetCurrent() -> CFAbsoluteTime;
1889}
1890extern "C" {
1891pub static kCFAbsoluteTimeIntervalSince1970: CFTimeInterval;
1893}
1894extern "C" {
1895pub static kCFAbsoluteTimeIntervalSince1904: CFTimeInterval;
1897}
1898#[repr(C)]
1899#[derive(Debug, Copy, Clone)]
1900pub struct __CFDate {
1902 _unused: [u8; 0],
1903}
1904pub type CFDateRef = *const __CFDate;
1906extern "C" {
1907pub fn CFDateGetTypeID() -> CFTypeID;
1909}
1910extern "C" {
1911pub fn CFDateCreate(allocator: CFAllocatorRef, at: CFAbsoluteTime) -> CFDateRef;
1913}
1914extern "C" {
1915pub fn CFDateGetAbsoluteTime(theDate: CFDateRef) -> CFAbsoluteTime;
1917}
1918extern "C" {
1919pub fn CFDateGetTimeIntervalSinceDate(
1921 theDate: CFDateRef,
1922 otherDate: CFDateRef,
1923 ) -> CFTimeInterval;
1924}
1925extern "C" {
1926pub fn CFDateCompare(
1928 theDate: CFDateRef,
1929 otherDate: CFDateRef,
1930 context: *mut ::core::ffi::c_void,
1931 ) -> CFComparisonResult;
1932}
1933#[repr(C)]
1934#[derive(Debug, Copy, Clone)]
1935pub struct __CFTimeZone {
1937 _unused: [u8; 0],
1938}
1939pub type CFTimeZoneRef = *const __CFTimeZone;
1941#[repr(C)]
1942#[derive(Debug, Copy, Clone)]
1943pub struct CFGregorianDate {
1945 pub year: SInt32,
1946 pub month: SInt8,
1947 pub day: SInt8,
1948 pub hour: SInt8,
1949 pub minute: SInt8,
1950 pub second: f64,
1951}
1952#[repr(C)]
1953#[derive(Debug, Copy, Clone)]
1954pub struct CFGregorianUnits {
1956 pub years: SInt32,
1957 pub months: SInt32,
1958 pub days: SInt32,
1959 pub hours: SInt32,
1960 pub minutes: SInt32,
1961 pub seconds: f64,
1962}
1963pub type CFGregorianUnitFlags = CFOptionFlags;
1965pub const kCFGregorianUnitsYears: _bindgen_ty_12 = 1;
1967pub const kCFGregorianUnitsMonths: _bindgen_ty_12 = 2;
1969pub const kCFGregorianUnitsDays: _bindgen_ty_12 = 4;
1971pub const kCFGregorianUnitsHours: _bindgen_ty_12 = 8;
1973pub const kCFGregorianUnitsMinutes: _bindgen_ty_12 = 16;
1975pub const kCFGregorianUnitsSeconds: _bindgen_ty_12 = 32;
1977pub const kCFGregorianAllUnits: _bindgen_ty_12 = 16777215;
1979pub type _bindgen_ty_12 = ::core::ffi::c_uint;
1981extern "C" {
1982pub fn CFGregorianDateIsValid(gdate: CFGregorianDate, unitFlags: CFOptionFlags) -> Boolean;
1984}
1985extern "C" {
1986pub fn CFGregorianDateGetAbsoluteTime(
1988 gdate: CFGregorianDate,
1989 tz: CFTimeZoneRef,
1990 ) -> CFAbsoluteTime;
1991}
1992extern "C" {
1993pub fn CFAbsoluteTimeGetGregorianDate(at: CFAbsoluteTime, tz: CFTimeZoneRef)
1995 -> CFGregorianDate;
1996}
1997extern "C" {
1998pub fn CFAbsoluteTimeAddGregorianUnits(
2000 at: CFAbsoluteTime,
2001 tz: CFTimeZoneRef,
2002 units: CFGregorianUnits,
2003 ) -> CFAbsoluteTime;
2004}
2005extern "C" {
2006pub fn CFAbsoluteTimeGetDifferenceAsGregorianUnits(
2008 at1: CFAbsoluteTime,
2009 at2: CFAbsoluteTime,
2010 tz: CFTimeZoneRef,
2011 unitFlags: CFOptionFlags,
2012 ) -> CFGregorianUnits;
2013}
2014extern "C" {
2015pub fn CFAbsoluteTimeGetDayOfWeek(at: CFAbsoluteTime, tz: CFTimeZoneRef) -> SInt32;
2017}
2018extern "C" {
2019pub fn CFAbsoluteTimeGetDayOfYear(at: CFAbsoluteTime, tz: CFTimeZoneRef) -> SInt32;
2021}
2022extern "C" {
2023pub fn CFAbsoluteTimeGetWeekOfYear(at: CFAbsoluteTime, tz: CFTimeZoneRef) -> SInt32;
2025}
2026#[repr(C)]
2027#[derive(Debug, Copy, Clone)]
2028pub struct __CFData {
2030 _unused: [u8; 0],
2031}
2032pub type CFDataRef = *const __CFData;
2034pub type CFMutableDataRef = *mut __CFData;
2036extern "C" {
2037pub fn CFDataGetTypeID() -> CFTypeID;
2039}
2040extern "C" {
2041pub fn CFDataCreate(
2043 allocator: CFAllocatorRef,
2044 bytes: *const UInt8,
2045 length: CFIndex,
2046 ) -> CFDataRef;
2047}
2048extern "C" {
2049pub fn CFDataCreateWithBytesNoCopy(
2051 allocator: CFAllocatorRef,
2052 bytes: *const UInt8,
2053 length: CFIndex,
2054 bytesDeallocator: CFAllocatorRef,
2055 ) -> CFDataRef;
2056}
2057extern "C" {
2058pub fn CFDataCreateCopy(allocator: CFAllocatorRef, theData: CFDataRef) -> CFDataRef;
2060}
2061extern "C" {
2062pub fn CFDataCreateMutable(allocator: CFAllocatorRef, capacity: CFIndex) -> CFMutableDataRef;
2064}
2065extern "C" {
2066pub fn CFDataCreateMutableCopy(
2068 allocator: CFAllocatorRef,
2069 capacity: CFIndex,
2070 theData: CFDataRef,
2071 ) -> CFMutableDataRef;
2072}
2073extern "C" {
2074pub fn CFDataGetLength(theData: CFDataRef) -> CFIndex;
2076}
2077extern "C" {
2078pub fn CFDataGetBytePtr(theData: CFDataRef) -> *const UInt8;
2080}
2081extern "C" {
2082pub fn CFDataGetMutableBytePtr(theData: CFMutableDataRef) -> *mut UInt8;
2084}
2085extern "C" {
2086pub fn CFDataGetBytes(theData: CFDataRef, range: CFRange, buffer: *mut UInt8);
2088}
2089extern "C" {
2090pub fn CFDataSetLength(theData: CFMutableDataRef, length: CFIndex);
2092}
2093extern "C" {
2094pub fn CFDataIncreaseLength(theData: CFMutableDataRef, extraLength: CFIndex);
2096}
2097extern "C" {
2098pub fn CFDataAppendBytes(theData: CFMutableDataRef, bytes: *const UInt8, length: CFIndex);
2100}
2101extern "C" {
2102pub fn CFDataReplaceBytes(
2104 theData: CFMutableDataRef,
2105 range: CFRange,
2106 newBytes: *const UInt8,
2107 newLength: CFIndex,
2108 );
2109}
2110extern "C" {
2111pub fn CFDataDeleteBytes(theData: CFMutableDataRef, range: CFRange);
2113}
2114pub type CFDataSearchFlags = CFOptionFlags;
2116pub const kCFDataSearchBackwards: _bindgen_ty_13 = 1;
2118pub const kCFDataSearchAnchored: _bindgen_ty_13 = 2;
2120pub type _bindgen_ty_13 = ::core::ffi::c_uint;
2122extern "C" {
2123pub fn CFDataFind(
2125 theData: CFDataRef,
2126 dataToFind: CFDataRef,
2127 searchRange: CFRange,
2128 compareOptions: CFDataSearchFlags,
2129 ) -> CFRange;
2130}
2131#[repr(C)]
2132#[derive(Debug, Copy, Clone)]
2133pub struct __CFCharacterSet {
2135 _unused: [u8; 0],
2136}
2137pub type CFCharacterSetRef = *const __CFCharacterSet;
2139pub type CFMutableCharacterSetRef = *mut __CFCharacterSet;
2141pub type CFCharacterSetPredefinedSet = CFIndex;
2143pub const kCFCharacterSetControl: _bindgen_ty_14 = 1;
2145pub const kCFCharacterSetWhitespace: _bindgen_ty_14 = 2;
2147pub const kCFCharacterSetWhitespaceAndNewline: _bindgen_ty_14 = 3;
2149pub const kCFCharacterSetDecimalDigit: _bindgen_ty_14 = 4;
2151pub const kCFCharacterSetLetter: _bindgen_ty_14 = 5;
2153pub const kCFCharacterSetLowercaseLetter: _bindgen_ty_14 = 6;
2155pub const kCFCharacterSetUppercaseLetter: _bindgen_ty_14 = 7;
2157pub const kCFCharacterSetNonBase: _bindgen_ty_14 = 8;
2159pub const kCFCharacterSetDecomposable: _bindgen_ty_14 = 9;
2161pub const kCFCharacterSetAlphaNumeric: _bindgen_ty_14 = 10;
2163pub const kCFCharacterSetPunctuation: _bindgen_ty_14 = 11;
2165pub const kCFCharacterSetCapitalizedLetter: _bindgen_ty_14 = 13;
2167pub const kCFCharacterSetSymbol: _bindgen_ty_14 = 14;
2169pub const kCFCharacterSetNewline: _bindgen_ty_14 = 15;
2171pub const kCFCharacterSetIllegal: _bindgen_ty_14 = 12;
2173pub type _bindgen_ty_14 = ::core::ffi::c_uint;
2175extern "C" {
2176pub fn CFCharacterSetGetTypeID() -> CFTypeID;
2178}
2179extern "C" {
2180pub fn CFCharacterSetGetPredefined(
2182 theSetIdentifier: CFCharacterSetPredefinedSet,
2183 ) -> CFCharacterSetRef;
2184}
2185extern "C" {
2186pub fn CFCharacterSetCreateWithCharactersInRange(
2188 alloc: CFAllocatorRef,
2189 theRange: CFRange,
2190 ) -> CFCharacterSetRef;
2191}
2192extern "C" {
2193pub fn CFCharacterSetCreateWithCharactersInString(
2195 alloc: CFAllocatorRef,
2196 theString: CFStringRef,
2197 ) -> CFCharacterSetRef;
2198}
2199extern "C" {
2200pub fn CFCharacterSetCreateWithBitmapRepresentation(
2202 alloc: CFAllocatorRef,
2203 theData: CFDataRef,
2204 ) -> CFCharacterSetRef;
2205}
2206extern "C" {
2207pub fn CFCharacterSetCreateInvertedSet(
2209 alloc: CFAllocatorRef,
2210 theSet: CFCharacterSetRef,
2211 ) -> CFCharacterSetRef;
2212}
2213extern "C" {
2214pub fn CFCharacterSetIsSupersetOfSet(
2216 theSet: CFCharacterSetRef,
2217 theOtherset: CFCharacterSetRef,
2218 ) -> Boolean;
2219}
2220extern "C" {
2221pub fn CFCharacterSetHasMemberInPlane(theSet: CFCharacterSetRef, thePlane: CFIndex) -> Boolean;
2223}
2224extern "C" {
2225pub fn CFCharacterSetCreateMutable(alloc: CFAllocatorRef) -> CFMutableCharacterSetRef;
2227}
2228extern "C" {
2229pub fn CFCharacterSetCreateCopy(
2231 alloc: CFAllocatorRef,
2232 theSet: CFCharacterSetRef,
2233 ) -> CFCharacterSetRef;
2234}
2235extern "C" {
2236pub fn CFCharacterSetCreateMutableCopy(
2238 alloc: CFAllocatorRef,
2239 theSet: CFCharacterSetRef,
2240 ) -> CFMutableCharacterSetRef;
2241}
2242extern "C" {
2243pub fn CFCharacterSetIsCharacterMember(theSet: CFCharacterSetRef, theChar: UniChar) -> Boolean;
2245}
2246extern "C" {
2247pub fn CFCharacterSetIsLongCharacterMember(
2249 theSet: CFCharacterSetRef,
2250 theChar: UTF32Char,
2251 ) -> Boolean;
2252}
2253extern "C" {
2254pub fn CFCharacterSetCreateBitmapRepresentation(
2256 alloc: CFAllocatorRef,
2257 theSet: CFCharacterSetRef,
2258 ) -> CFDataRef;
2259}
2260extern "C" {
2261pub fn CFCharacterSetAddCharactersInRange(theSet: CFMutableCharacterSetRef, theRange: CFRange);
2263}
2264extern "C" {
2265pub fn CFCharacterSetRemoveCharactersInRange(
2267 theSet: CFMutableCharacterSetRef,
2268 theRange: CFRange,
2269 );
2270}
2271extern "C" {
2272pub fn CFCharacterSetAddCharactersInString(
2274 theSet: CFMutableCharacterSetRef,
2275 theString: CFStringRef,
2276 );
2277}
2278extern "C" {
2279pub fn CFCharacterSetRemoveCharactersInString(
2281 theSet: CFMutableCharacterSetRef,
2282 theString: CFStringRef,
2283 );
2284}
2285extern "C" {
2286pub fn CFCharacterSetUnion(theSet: CFMutableCharacterSetRef, theOtherSet: CFCharacterSetRef);
2288}
2289extern "C" {
2290pub fn CFCharacterSetIntersect(
2292 theSet: CFMutableCharacterSetRef,
2293 theOtherSet: CFCharacterSetRef,
2294 );
2295}
2296extern "C" {
2297pub fn CFCharacterSetInvert(theSet: CFMutableCharacterSetRef);
2299}
2300pub type CFErrorDomain = CFStringRef;
2302#[repr(C)]
2303#[derive(Debug, Copy, Clone)]
2304pub struct __CFError {
2306 _unused: [u8; 0],
2307}
2308pub type CFErrorRef = *mut __CFError;
2310extern "C" {
2311pub fn CFErrorGetTypeID() -> CFTypeID;
2313}
2314extern "C" {
2315pub static kCFErrorDomainPOSIX: CFErrorDomain;
2317}
2318extern "C" {
2319pub static kCFErrorDomainOSStatus: CFErrorDomain;
2321}
2322extern "C" {
2323pub static kCFErrorDomainMach: CFErrorDomain;
2325}
2326extern "C" {
2327pub static kCFErrorDomainCocoa: CFErrorDomain;
2329}
2330extern "C" {
2331pub static kCFErrorLocalizedDescriptionKey: CFStringRef;
2333}
2334extern "C" {
2335pub static kCFErrorLocalizedFailureKey: CFStringRef;
2337}
2338extern "C" {
2339pub static kCFErrorLocalizedFailureReasonKey: CFStringRef;
2341}
2342extern "C" {
2343pub static kCFErrorLocalizedRecoverySuggestionKey: CFStringRef;
2345}
2346extern "C" {
2347pub static kCFErrorDescriptionKey: CFStringRef;
2349}
2350extern "C" {
2351pub static kCFErrorUnderlyingErrorKey: CFStringRef;
2353}
2354extern "C" {
2355pub static kCFErrorURLKey: CFStringRef;
2357}
2358extern "C" {
2359pub static kCFErrorFilePathKey: CFStringRef;
2361}
2362extern "C" {
2363pub fn CFErrorCreate(
2365 allocator: CFAllocatorRef,
2366 domain: CFErrorDomain,
2367 code: CFIndex,
2368 userInfo: CFDictionaryRef,
2369 ) -> CFErrorRef;
2370}
2371extern "C" {
2372pub fn CFErrorCreateWithUserInfoKeysAndValues(
2374 allocator: CFAllocatorRef,
2375 domain: CFErrorDomain,
2376 code: CFIndex,
2377 userInfoKeys: *const *const ::core::ffi::c_void,
2378 userInfoValues: *const *const ::core::ffi::c_void,
2379 numUserInfoValues: CFIndex,
2380 ) -> CFErrorRef;
2381}
2382extern "C" {
2383pub fn CFErrorGetDomain(err: CFErrorRef) -> CFErrorDomain;
2385}
2386extern "C" {
2387pub fn CFErrorGetCode(err: CFErrorRef) -> CFIndex;
2389}
2390extern "C" {
2391pub fn CFErrorCopyUserInfo(err: CFErrorRef) -> CFDictionaryRef;
2393}
2394extern "C" {
2395pub fn CFErrorCopyDescription(err: CFErrorRef) -> CFStringRef;
2397}
2398extern "C" {
2399pub fn CFErrorCopyFailureReason(err: CFErrorRef) -> CFStringRef;
2401}
2402extern "C" {
2403pub fn CFErrorCopyRecoverySuggestion(err: CFErrorRef) -> CFStringRef;
2405}
2406pub type CFStringEncoding = UInt32;
2408pub type CFStringBuiltInEncodings = CFStringEncoding;
2410pub const kCFStringEncodingMacRoman: _bindgen_ty_15 = 0;
2412pub const kCFStringEncodingWindowsLatin1: _bindgen_ty_15 = 1280;
2414pub const kCFStringEncodingISOLatin1: _bindgen_ty_15 = 513;
2416pub const kCFStringEncodingNextStepLatin: _bindgen_ty_15 = 2817;
2418pub const kCFStringEncodingASCII: _bindgen_ty_15 = 1536;
2420pub const kCFStringEncodingUnicode: _bindgen_ty_15 = 256;
2422pub const kCFStringEncodingUTF8: _bindgen_ty_15 = 134217984;
2424pub const kCFStringEncodingNonLossyASCII: _bindgen_ty_15 = 3071;
2426pub const kCFStringEncodingUTF16: _bindgen_ty_15 = 256;
2428pub const kCFStringEncodingUTF16BE: _bindgen_ty_15 = 268435712;
2430pub const kCFStringEncodingUTF16LE: _bindgen_ty_15 = 335544576;
2432pub const kCFStringEncodingUTF32: _bindgen_ty_15 = 201326848;
2434pub const kCFStringEncodingUTF32BE: _bindgen_ty_15 = 402653440;
2436pub const kCFStringEncodingUTF32LE: _bindgen_ty_15 = 469762304;
2438pub type _bindgen_ty_15 = ::core::ffi::c_uint;
2440extern "C" {
2441pub fn CFStringGetTypeID() -> CFTypeID;
2443}
2444extern "C" {
2445pub fn CFStringCreateWithPascalString(
2447 alloc: CFAllocatorRef,
2448 pStr: ConstStr255Param,
2449 encoding: CFStringEncoding,
2450 ) -> CFStringRef;
2451}
2452extern "C" {
2453pub fn CFStringCreateWithCString(
2455 alloc: CFAllocatorRef,
2456 cStr: *const ::core::ffi::c_char,
2457 encoding: CFStringEncoding,
2458 ) -> CFStringRef;
2459}
2460extern "C" {
2461pub fn CFStringCreateWithBytes(
2463 alloc: CFAllocatorRef,
2464 bytes: *const UInt8,
2465 numBytes: CFIndex,
2466 encoding: CFStringEncoding,
2467 isExternalRepresentation: Boolean,
2468 ) -> CFStringRef;
2469}
2470extern "C" {
2471pub fn CFStringCreateWithCharacters(
2473 alloc: CFAllocatorRef,
2474 chars: *const UniChar,
2475 numChars: CFIndex,
2476 ) -> CFStringRef;
2477}
2478extern "C" {
2479pub fn CFStringCreateWithPascalStringNoCopy(
2481 alloc: CFAllocatorRef,
2482 pStr: ConstStr255Param,
2483 encoding: CFStringEncoding,
2484 contentsDeallocator: CFAllocatorRef,
2485 ) -> CFStringRef;
2486}
2487extern "C" {
2488pub fn CFStringCreateWithCStringNoCopy(
2490 alloc: CFAllocatorRef,
2491 cStr: *const ::core::ffi::c_char,
2492 encoding: CFStringEncoding,
2493 contentsDeallocator: CFAllocatorRef,
2494 ) -> CFStringRef;
2495}
2496extern "C" {
2497pub fn CFStringCreateWithBytesNoCopy(
2499 alloc: CFAllocatorRef,
2500 bytes: *const UInt8,
2501 numBytes: CFIndex,
2502 encoding: CFStringEncoding,
2503 isExternalRepresentation: Boolean,
2504 contentsDeallocator: CFAllocatorRef,
2505 ) -> CFStringRef;
2506}
2507extern "C" {
2508pub fn CFStringCreateWithCharactersNoCopy(
2510 alloc: CFAllocatorRef,
2511 chars: *const UniChar,
2512 numChars: CFIndex,
2513 contentsDeallocator: CFAllocatorRef,
2514 ) -> CFStringRef;
2515}
2516extern "C" {
2517pub fn CFStringCreateWithSubstring(
2519 alloc: CFAllocatorRef,
2520 str_: CFStringRef,
2521 range: CFRange,
2522 ) -> CFStringRef;
2523}
2524extern "C" {
2525pub fn CFStringCreateCopy(alloc: CFAllocatorRef, theString: CFStringRef) -> CFStringRef;
2527}
2528extern "C" {
2529pub fn CFStringCreateWithFormat(
2531 alloc: CFAllocatorRef,
2532 formatOptions: CFDictionaryRef,
2533 format: CFStringRef,
2534 ...
2535 ) -> CFStringRef;
2536}
2537extern "C" {
2538pub fn CFStringCreateWithFormatAndArguments(
2540 alloc: CFAllocatorRef,
2541 formatOptions: CFDictionaryRef,
2542 format: CFStringRef,
2543 arguments: va_list,
2544 ) -> CFStringRef;
2545}
2546extern "C" {
2547pub fn CFStringCreateStringWithValidatedFormat(
2549 alloc: CFAllocatorRef,
2550 formatOptions: CFDictionaryRef,
2551 validFormatSpecifiers: CFStringRef,
2552 format: CFStringRef,
2553 errorPtr: *mut CFErrorRef,
2554 ...
2555 ) -> CFStringRef;
2556}
2557extern "C" {
2558pub fn CFStringCreateStringWithValidatedFormatAndArguments(
2560 alloc: CFAllocatorRef,
2561 formatOptions: CFDictionaryRef,
2562 validFormatSpecifiers: CFStringRef,
2563 format: CFStringRef,
2564 arguments: va_list,
2565 errorPtr: *mut CFErrorRef,
2566 ) -> CFStringRef;
2567}
2568extern "C" {
2569pub fn CFStringCreateMutable(alloc: CFAllocatorRef, maxLength: CFIndex) -> CFMutableStringRef;
2571}
2572extern "C" {
2573pub fn CFStringCreateMutableCopy(
2575 alloc: CFAllocatorRef,
2576 maxLength: CFIndex,
2577 theString: CFStringRef,
2578 ) -> CFMutableStringRef;
2579}
2580extern "C" {
2581pub fn CFStringCreateMutableWithExternalCharactersNoCopy(
2583 alloc: CFAllocatorRef,
2584 chars: *mut UniChar,
2585 numChars: CFIndex,
2586 capacity: CFIndex,
2587 externalCharactersAllocator: CFAllocatorRef,
2588 ) -> CFMutableStringRef;
2589}
2590extern "C" {
2591pub fn CFStringGetLength(theString: CFStringRef) -> CFIndex;
2593}
2594extern "C" {
2595pub fn CFStringGetCharacterAtIndex(theString: CFStringRef, idx: CFIndex) -> UniChar;
2597}
2598extern "C" {
2599pub fn CFStringGetCharacters(theString: CFStringRef, range: CFRange, buffer: *mut UniChar);
2601}
2602extern "C" {
2603pub fn CFStringGetPascalString(
2605 theString: CFStringRef,
2606 buffer: StringPtr,
2607 bufferSize: CFIndex,
2608 encoding: CFStringEncoding,
2609 ) -> Boolean;
2610}
2611extern "C" {
2612pub fn CFStringGetCString(
2614 theString: CFStringRef,
2615 buffer: *mut ::core::ffi::c_char,
2616 bufferSize: CFIndex,
2617 encoding: CFStringEncoding,
2618 ) -> Boolean;
2619}
2620extern "C" {
2621pub fn CFStringGetPascalStringPtr(
2623 theString: CFStringRef,
2624 encoding: CFStringEncoding,
2625 ) -> ConstStringPtr;
2626}
2627extern "C" {
2628pub fn CFStringGetCStringPtr(
2630 theString: CFStringRef,
2631 encoding: CFStringEncoding,
2632 ) -> *const ::core::ffi::c_char;
2633}
2634extern "C" {
2635pub fn CFStringGetCharactersPtr(theString: CFStringRef) -> *const UniChar;
2637}
2638extern "C" {
2639pub fn CFStringGetBytes(
2641 theString: CFStringRef,
2642 range: CFRange,
2643 encoding: CFStringEncoding,
2644 lossByte: UInt8,
2645 isExternalRepresentation: Boolean,
2646 buffer: *mut UInt8,
2647 maxBufLen: CFIndex,
2648 usedBufLen: *mut CFIndex,
2649 ) -> CFIndex;
2650}
2651extern "C" {
2652pub fn CFStringCreateFromExternalRepresentation(
2654 alloc: CFAllocatorRef,
2655 data: CFDataRef,
2656 encoding: CFStringEncoding,
2657 ) -> CFStringRef;
2658}
2659extern "C" {
2660pub fn CFStringCreateExternalRepresentation(
2662 alloc: CFAllocatorRef,
2663 theString: CFStringRef,
2664 encoding: CFStringEncoding,
2665 lossByte: UInt8,
2666 ) -> CFDataRef;
2667}
2668extern "C" {
2669pub fn CFStringGetSmallestEncoding(theString: CFStringRef) -> CFStringEncoding;
2671}
2672extern "C" {
2673pub fn CFStringGetFastestEncoding(theString: CFStringRef) -> CFStringEncoding;
2675}
2676extern "C" {
2677pub fn CFStringGetSystemEncoding() -> CFStringEncoding;
2679}
2680extern "C" {
2681pub fn CFStringGetMaximumSizeForEncoding(
2683 length: CFIndex,
2684 encoding: CFStringEncoding,
2685 ) -> CFIndex;
2686}
2687extern "C" {
2688pub fn CFStringGetFileSystemRepresentation(
2690 string: CFStringRef,
2691 buffer: *mut ::core::ffi::c_char,
2692 maxBufLen: CFIndex,
2693 ) -> Boolean;
2694}
2695extern "C" {
2696pub fn CFStringGetMaximumSizeOfFileSystemRepresentation(string: CFStringRef) -> CFIndex;
2698}
2699extern "C" {
2700pub fn CFStringCreateWithFileSystemRepresentation(
2702 alloc: CFAllocatorRef,
2703 buffer: *const ::core::ffi::c_char,
2704 ) -> CFStringRef;
2705}
2706pub type CFStringCompareFlags = CFOptionFlags;
2708pub const kCFCompareCaseInsensitive: _bindgen_ty_16 = 1;
2710pub const kCFCompareBackwards: _bindgen_ty_16 = 4;
2712pub const kCFCompareAnchored: _bindgen_ty_16 = 8;
2714pub const kCFCompareNonliteral: _bindgen_ty_16 = 16;
2716pub const kCFCompareLocalized: _bindgen_ty_16 = 32;
2718pub const kCFCompareNumerically: _bindgen_ty_16 = 64;
2720pub const kCFCompareDiacriticInsensitive: _bindgen_ty_16 = 128;
2722pub const kCFCompareWidthInsensitive: _bindgen_ty_16 = 256;
2724pub const kCFCompareForcedOrdering: _bindgen_ty_16 = 512;
2726pub type _bindgen_ty_16 = ::core::ffi::c_uint;
2728extern "C" {
2729pub fn CFStringCompareWithOptionsAndLocale(
2731 theString1: CFStringRef,
2732 theString2: CFStringRef,
2733 rangeToCompare: CFRange,
2734 compareOptions: CFStringCompareFlags,
2735 locale: CFLocaleRef,
2736 ) -> CFComparisonResult;
2737}
2738extern "C" {
2739pub fn CFStringCompareWithOptions(
2741 theString1: CFStringRef,
2742 theString2: CFStringRef,
2743 rangeToCompare: CFRange,
2744 compareOptions: CFStringCompareFlags,
2745 ) -> CFComparisonResult;
2746}
2747extern "C" {
2748pub fn CFStringCompare(
2750 theString1: CFStringRef,
2751 theString2: CFStringRef,
2752 compareOptions: CFStringCompareFlags,
2753 ) -> CFComparisonResult;
2754}
2755extern "C" {
2756pub fn CFStringFindWithOptionsAndLocale(
2758 theString: CFStringRef,
2759 stringToFind: CFStringRef,
2760 rangeToSearch: CFRange,
2761 searchOptions: CFStringCompareFlags,
2762 locale: CFLocaleRef,
2763 result: *mut CFRange,
2764 ) -> Boolean;
2765}
2766extern "C" {
2767pub fn CFStringFindWithOptions(
2769 theString: CFStringRef,
2770 stringToFind: CFStringRef,
2771 rangeToSearch: CFRange,
2772 searchOptions: CFStringCompareFlags,
2773 result: *mut CFRange,
2774 ) -> Boolean;
2775}
2776extern "C" {
2777pub fn CFStringCreateArrayWithFindResults(
2779 alloc: CFAllocatorRef,
2780 theString: CFStringRef,
2781 stringToFind: CFStringRef,
2782 rangeToSearch: CFRange,
2783 compareOptions: CFStringCompareFlags,
2784 ) -> CFArrayRef;
2785}
2786extern "C" {
2787pub fn CFStringFind(
2789 theString: CFStringRef,
2790 stringToFind: CFStringRef,
2791 compareOptions: CFStringCompareFlags,
2792 ) -> CFRange;
2793}
2794extern "C" {
2795pub fn CFStringHasPrefix(theString: CFStringRef, prefix: CFStringRef) -> Boolean;
2797}
2798extern "C" {
2799pub fn CFStringHasSuffix(theString: CFStringRef, suffix: CFStringRef) -> Boolean;
2801}
2802extern "C" {
2803pub fn CFStringGetRangeOfComposedCharactersAtIndex(
2805 theString: CFStringRef,
2806 theIndex: CFIndex,
2807 ) -> CFRange;
2808}
2809extern "C" {
2810pub fn CFStringFindCharacterFromSet(
2812 theString: CFStringRef,
2813 theSet: CFCharacterSetRef,
2814 rangeToSearch: CFRange,
2815 searchOptions: CFStringCompareFlags,
2816 result: *mut CFRange,
2817 ) -> Boolean;
2818}
2819extern "C" {
2820pub fn CFStringGetLineBounds(
2822 theString: CFStringRef,
2823 range: CFRange,
2824 lineBeginIndex: *mut CFIndex,
2825 lineEndIndex: *mut CFIndex,
2826 contentsEndIndex: *mut CFIndex,
2827 );
2828}
2829extern "C" {
2830pub fn CFStringGetParagraphBounds(
2832 string: CFStringRef,
2833 range: CFRange,
2834 parBeginIndex: *mut CFIndex,
2835 parEndIndex: *mut CFIndex,
2836 contentsEndIndex: *mut CFIndex,
2837 );
2838}
2839extern "C" {
2840pub fn CFStringGetHyphenationLocationBeforeIndex(
2842 string: CFStringRef,
2843 location: CFIndex,
2844 limitRange: CFRange,
2845 options: CFOptionFlags,
2846 locale: CFLocaleRef,
2847 character: *mut UTF32Char,
2848 ) -> CFIndex;
2849}
2850extern "C" {
2851pub fn CFStringIsHyphenationAvailableForLocale(locale: CFLocaleRef) -> Boolean;
2853}
2854extern "C" {
2855pub fn CFStringCreateByCombiningStrings(
2857 alloc: CFAllocatorRef,
2858 theArray: CFArrayRef,
2859 separatorString: CFStringRef,
2860 ) -> CFStringRef;
2861}
2862extern "C" {
2863pub fn CFStringCreateArrayBySeparatingStrings(
2865 alloc: CFAllocatorRef,
2866 theString: CFStringRef,
2867 separatorString: CFStringRef,
2868 ) -> CFArrayRef;
2869}
2870extern "C" {
2871pub fn CFStringGetIntValue(str_: CFStringRef) -> SInt32;
2873}
2874extern "C" {
2875pub fn CFStringGetDoubleValue(str_: CFStringRef) -> f64;
2877}
2878extern "C" {
2879pub fn CFStringAppend(theString: CFMutableStringRef, appendedString: CFStringRef);
2881}
2882extern "C" {
2883pub fn CFStringAppendCharacters(
2885 theString: CFMutableStringRef,
2886 chars: *const UniChar,
2887 numChars: CFIndex,
2888 );
2889}
2890extern "C" {
2891pub fn CFStringAppendPascalString(
2893 theString: CFMutableStringRef,
2894 pStr: ConstStr255Param,
2895 encoding: CFStringEncoding,
2896 );
2897}
2898extern "C" {
2899pub fn CFStringAppendCString(
2901 theString: CFMutableStringRef,
2902 cStr: *const ::core::ffi::c_char,
2903 encoding: CFStringEncoding,
2904 );
2905}
2906extern "C" {
2907pub fn CFStringAppendFormat(
2909 theString: CFMutableStringRef,
2910 formatOptions: CFDictionaryRef,
2911 format: CFStringRef,
2912 ...
2913 );
2914}
2915extern "C" {
2916pub fn CFStringAppendFormatAndArguments(
2918 theString: CFMutableStringRef,
2919 formatOptions: CFDictionaryRef,
2920 format: CFStringRef,
2921 arguments: va_list,
2922 );
2923}
2924extern "C" {
2925pub fn CFStringInsert(str_: CFMutableStringRef, idx: CFIndex, insertedStr: CFStringRef);
2927}
2928extern "C" {
2929pub fn CFStringDelete(theString: CFMutableStringRef, range: CFRange);
2931}
2932extern "C" {
2933pub fn CFStringReplace(theString: CFMutableStringRef, range: CFRange, replacement: CFStringRef);
2935}
2936extern "C" {
2937pub fn CFStringReplaceAll(theString: CFMutableStringRef, replacement: CFStringRef);
2939}
2940extern "C" {
2941pub fn CFStringFindAndReplace(
2943 theString: CFMutableStringRef,
2944 stringToFind: CFStringRef,
2945 replacementString: CFStringRef,
2946 rangeToSearch: CFRange,
2947 compareOptions: CFStringCompareFlags,
2948 ) -> CFIndex;
2949}
2950extern "C" {
2951pub fn CFStringSetExternalCharactersNoCopy(
2953 theString: CFMutableStringRef,
2954 chars: *mut UniChar,
2955 length: CFIndex,
2956 capacity: CFIndex,
2957 );
2958}
2959extern "C" {
2960pub fn CFStringPad(
2962 theString: CFMutableStringRef,
2963 padString: CFStringRef,
2964 length: CFIndex,
2965 indexIntoPad: CFIndex,
2966 );
2967}
2968extern "C" {
2969pub fn CFStringTrim(theString: CFMutableStringRef, trimString: CFStringRef);
2971}
2972extern "C" {
2973pub fn CFStringTrimWhitespace(theString: CFMutableStringRef);
2975}
2976extern "C" {
2977pub fn CFStringLowercase(theString: CFMutableStringRef, locale: CFLocaleRef);
2979}
2980extern "C" {
2981pub fn CFStringUppercase(theString: CFMutableStringRef, locale: CFLocaleRef);
2983}
2984extern "C" {
2985pub fn CFStringCapitalize(theString: CFMutableStringRef, locale: CFLocaleRef);
2987}
2988pub type CFStringNormalizationForm = CFIndex;
2990pub const kCFStringNormalizationFormD: _bindgen_ty_17 = 0;
2992pub const kCFStringNormalizationFormKD: _bindgen_ty_17 = 1;
2994pub const kCFStringNormalizationFormC: _bindgen_ty_17 = 2;
2996pub const kCFStringNormalizationFormKC: _bindgen_ty_17 = 3;
2998pub type _bindgen_ty_17 = ::core::ffi::c_uint;
3000extern "C" {
3001pub fn CFStringNormalize(theString: CFMutableStringRef, theForm: CFStringNormalizationForm);
3003}
3004extern "C" {
3005pub fn CFStringFold(
3007 theString: CFMutableStringRef,
3008 theFlags: CFStringCompareFlags,
3009 theLocale: CFLocaleRef,
3010 );
3011}
3012extern "C" {
3013pub fn CFStringTransform(
3015 string: CFMutableStringRef,
3016 range: *mut CFRange,
3017 transform: CFStringRef,
3018 reverse: Boolean,
3019 ) -> Boolean;
3020}
3021extern "C" {
3022pub static kCFStringTransformStripCombiningMarks: CFStringRef;
3024}
3025extern "C" {
3026pub static kCFStringTransformToLatin: CFStringRef;
3028}
3029extern "C" {
3030pub static kCFStringTransformFullwidthHalfwidth: CFStringRef;
3032}
3033extern "C" {
3034pub static kCFStringTransformLatinKatakana: CFStringRef;
3036}
3037extern "C" {
3038pub static kCFStringTransformLatinHiragana: CFStringRef;
3040}
3041extern "C" {
3042pub static kCFStringTransformHiraganaKatakana: CFStringRef;
3044}
3045extern "C" {
3046pub static kCFStringTransformMandarinLatin: CFStringRef;
3048}
3049extern "C" {
3050pub static kCFStringTransformLatinHangul: CFStringRef;
3052}
3053extern "C" {
3054pub static kCFStringTransformLatinArabic: CFStringRef;
3056}
3057extern "C" {
3058pub static kCFStringTransformLatinHebrew: CFStringRef;
3060}
3061extern "C" {
3062pub static kCFStringTransformLatinThai: CFStringRef;
3064}
3065extern "C" {
3066pub static kCFStringTransformLatinCyrillic: CFStringRef;
3068}
3069extern "C" {
3070pub static kCFStringTransformLatinGreek: CFStringRef;
3072}
3073extern "C" {
3074pub static kCFStringTransformToXMLHex: CFStringRef;
3076}
3077extern "C" {
3078pub static kCFStringTransformToUnicodeName: CFStringRef;
3080}
3081extern "C" {
3082pub static kCFStringTransformStripDiacritics: CFStringRef;
3084}
3085extern "C" {
3086pub fn CFStringIsEncodingAvailable(encoding: CFStringEncoding) -> Boolean;
3088}
3089extern "C" {
3090pub fn CFStringGetListOfAvailableEncodings() -> *const CFStringEncoding;
3092}
3093extern "C" {
3094pub fn CFStringGetNameOfEncoding(encoding: CFStringEncoding) -> CFStringRef;
3096}
3097extern "C" {
3098pub fn CFStringConvertEncodingToNSStringEncoding(
3100 encoding: CFStringEncoding,
3101 ) -> ::core::ffi::c_ulong;
3102}
3103extern "C" {
3104pub fn CFStringConvertNSStringEncodingToEncoding(
3106 encoding: ::core::ffi::c_ulong,
3107 ) -> CFStringEncoding;
3108}
3109extern "C" {
3110pub fn CFStringConvertEncodingToWindowsCodepage(encoding: CFStringEncoding) -> UInt32;
3112}
3113extern "C" {
3114pub fn CFStringConvertWindowsCodepageToEncoding(codepage: UInt32) -> CFStringEncoding;
3116}
3117extern "C" {
3118pub fn CFStringConvertIANACharSetNameToEncoding(theString: CFStringRef) -> CFStringEncoding;
3120}
3121extern "C" {
3122pub fn CFStringConvertEncodingToIANACharSetName(encoding: CFStringEncoding) -> CFStringRef;
3124}
3125extern "C" {
3126pub fn CFStringGetMostCompatibleMacStringEncoding(
3128 encoding: CFStringEncoding,
3129 ) -> CFStringEncoding;
3130}
3131#[repr(C)]
3132#[derive(Debug, Copy, Clone)]
3133pub struct CFStringInlineBuffer {
3135 pub buffer: [UniChar; 64usize],
3136 pub theString: CFStringRef,
3137 pub directUniCharBuffer: *const UniChar,
3138 pub directCStringBuffer: *const ::core::ffi::c_char,
3139 pub rangeToBuffer: CFRange,
3140 pub bufferedRangeStart: CFIndex,
3141 pub bufferedRangeEnd: CFIndex,
3142}
3143extern "C" {
3144pub fn CFShow(obj: CFTypeRef);
3146}
3147extern "C" {
3148pub fn CFShowStr(str_: CFStringRef);
3150}
3151extern "C" {
3152pub fn CFTimeZoneGetTypeID() -> CFTypeID;
3154}
3155extern "C" {
3156pub fn CFTimeZoneCopySystem() -> CFTimeZoneRef;
3158}
3159extern "C" {
3160pub fn CFTimeZoneResetSystem();
3162}
3163extern "C" {
3164pub fn CFTimeZoneCopyDefault() -> CFTimeZoneRef;
3166}
3167extern "C" {
3168pub fn CFTimeZoneSetDefault(tz: CFTimeZoneRef);
3170}
3171extern "C" {
3172pub fn CFTimeZoneCopyKnownNames() -> CFArrayRef;
3174}
3175extern "C" {
3176pub fn CFTimeZoneCopyAbbreviationDictionary() -> CFDictionaryRef;
3178}
3179extern "C" {
3180pub fn CFTimeZoneSetAbbreviationDictionary(dict: CFDictionaryRef);
3182}
3183extern "C" {
3184pub fn CFTimeZoneCreate(
3186 allocator: CFAllocatorRef,
3187 name: CFStringRef,
3188 data: CFDataRef,
3189 ) -> CFTimeZoneRef;
3190}
3191extern "C" {
3192pub fn CFTimeZoneCreateWithTimeIntervalFromGMT(
3194 allocator: CFAllocatorRef,
3195 ti: CFTimeInterval,
3196 ) -> CFTimeZoneRef;
3197}
3198extern "C" {
3199pub fn CFTimeZoneCreateWithName(
3201 allocator: CFAllocatorRef,
3202 name: CFStringRef,
3203 tryAbbrev: Boolean,
3204 ) -> CFTimeZoneRef;
3205}
3206extern "C" {
3207pub fn CFTimeZoneGetName(tz: CFTimeZoneRef) -> CFStringRef;
3209}
3210extern "C" {
3211pub fn CFTimeZoneGetData(tz: CFTimeZoneRef) -> CFDataRef;
3213}
3214extern "C" {
3215pub fn CFTimeZoneGetSecondsFromGMT(tz: CFTimeZoneRef, at: CFAbsoluteTime) -> CFTimeInterval;
3217}
3218extern "C" {
3219pub fn CFTimeZoneCopyAbbreviation(tz: CFTimeZoneRef, at: CFAbsoluteTime) -> CFStringRef;
3221}
3222extern "C" {
3223pub fn CFTimeZoneIsDaylightSavingTime(tz: CFTimeZoneRef, at: CFAbsoluteTime) -> Boolean;
3225}
3226extern "C" {
3227pub fn CFTimeZoneGetDaylightSavingTimeOffset(
3229 tz: CFTimeZoneRef,
3230 at: CFAbsoluteTime,
3231 ) -> CFTimeInterval;
3232}
3233extern "C" {
3234pub fn CFTimeZoneGetNextDaylightSavingTimeTransition(
3236 tz: CFTimeZoneRef,
3237 at: CFAbsoluteTime,
3238 ) -> CFAbsoluteTime;
3239}
3240pub type CFTimeZoneNameStyle = CFIndex;
3242pub const kCFTimeZoneNameStyleStandard: _bindgen_ty_18 = 0;
3244pub const kCFTimeZoneNameStyleShortStandard: _bindgen_ty_18 = 1;
3246pub const kCFTimeZoneNameStyleDaylightSaving: _bindgen_ty_18 = 2;
3248pub const kCFTimeZoneNameStyleShortDaylightSaving: _bindgen_ty_18 = 3;
3250pub const kCFTimeZoneNameStyleGeneric: _bindgen_ty_18 = 4;
3252pub const kCFTimeZoneNameStyleShortGeneric: _bindgen_ty_18 = 5;
3254pub type _bindgen_ty_18 = ::core::ffi::c_uint;
3256extern "C" {
3257pub fn CFTimeZoneCopyLocalizedName(
3259 tz: CFTimeZoneRef,
3260 style: CFTimeZoneNameStyle,
3261 locale: CFLocaleRef,
3262 ) -> CFStringRef;
3263}
3264extern "C" {
3265pub static kCFTimeZoneSystemTimeZoneDidChangeNotification: CFNotificationName;
3267}
3268#[repr(C)]
3269#[derive(Debug, Copy, Clone)]
3270pub struct __CFCalendar {
3272 _unused: [u8; 0],
3273}
3274pub type CFCalendarRef = *mut __CFCalendar;
3276extern "C" {
3277pub fn CFCalendarGetTypeID() -> CFTypeID;
3279}
3280extern "C" {
3281pub fn CFCalendarCopyCurrent() -> CFCalendarRef;
3283}
3284extern "C" {
3285pub fn CFCalendarCreateWithIdentifier(
3287 allocator: CFAllocatorRef,
3288 identifier: CFCalendarIdentifier,
3289 ) -> CFCalendarRef;
3290}
3291extern "C" {
3292pub fn CFCalendarGetIdentifier(calendar: CFCalendarRef) -> CFCalendarIdentifier;
3294}
3295extern "C" {
3296pub fn CFCalendarCopyLocale(calendar: CFCalendarRef) -> CFLocaleRef;
3298}
3299extern "C" {
3300pub fn CFCalendarSetLocale(calendar: CFCalendarRef, locale: CFLocaleRef);
3302}
3303extern "C" {
3304pub fn CFCalendarCopyTimeZone(calendar: CFCalendarRef) -> CFTimeZoneRef;
3306}
3307extern "C" {
3308pub fn CFCalendarSetTimeZone(calendar: CFCalendarRef, tz: CFTimeZoneRef);
3310}
3311extern "C" {
3312pub fn CFCalendarGetFirstWeekday(calendar: CFCalendarRef) -> CFIndex;
3314}
3315extern "C" {
3316pub fn CFCalendarSetFirstWeekday(calendar: CFCalendarRef, wkdy: CFIndex);
3318}
3319extern "C" {
3320pub fn CFCalendarGetMinimumDaysInFirstWeek(calendar: CFCalendarRef) -> CFIndex;
3322}
3323extern "C" {
3324pub fn CFCalendarSetMinimumDaysInFirstWeek(calendar: CFCalendarRef, mwd: CFIndex);
3326}
3327pub type CFCalendarUnit = CFOptionFlags;
3329pub const kCFCalendarUnitEra: _bindgen_ty_19 = 2;
3331pub const kCFCalendarUnitYear: _bindgen_ty_19 = 4;
3333pub const kCFCalendarUnitMonth: _bindgen_ty_19 = 8;
3335pub const kCFCalendarUnitDay: _bindgen_ty_19 = 16;
3337pub const kCFCalendarUnitHour: _bindgen_ty_19 = 32;
3339pub const kCFCalendarUnitMinute: _bindgen_ty_19 = 64;
3341pub const kCFCalendarUnitSecond: _bindgen_ty_19 = 128;
3343pub const kCFCalendarUnitWeek: _bindgen_ty_19 = 256;
3345pub const kCFCalendarUnitWeekday: _bindgen_ty_19 = 512;
3347pub const kCFCalendarUnitWeekdayOrdinal: _bindgen_ty_19 = 1024;
3349pub const kCFCalendarUnitQuarter: _bindgen_ty_19 = 2048;
3351pub const kCFCalendarUnitWeekOfMonth: _bindgen_ty_19 = 4096;
3353pub const kCFCalendarUnitWeekOfYear: _bindgen_ty_19 = 8192;
3355pub const kCFCalendarUnitYearForWeekOfYear: _bindgen_ty_19 = 16384;
3357pub const kCFCalendarUnitDayOfYear: _bindgen_ty_19 = 65536;
3359pub type _bindgen_ty_19 = ::core::ffi::c_uint;
3361extern "C" {
3362pub fn CFCalendarGetMinimumRangeOfUnit(
3364 calendar: CFCalendarRef,
3365 unit: CFCalendarUnit,
3366 ) -> CFRange;
3367}
3368extern "C" {
3369pub fn CFCalendarGetMaximumRangeOfUnit(
3371 calendar: CFCalendarRef,
3372 unit: CFCalendarUnit,
3373 ) -> CFRange;
3374}
3375extern "C" {
3376pub fn CFCalendarGetRangeOfUnit(
3378 calendar: CFCalendarRef,
3379 smallerUnit: CFCalendarUnit,
3380 biggerUnit: CFCalendarUnit,
3381 at: CFAbsoluteTime,
3382 ) -> CFRange;
3383}
3384extern "C" {
3385pub fn CFCalendarGetOrdinalityOfUnit(
3387 calendar: CFCalendarRef,
3388 smallerUnit: CFCalendarUnit,
3389 biggerUnit: CFCalendarUnit,
3390 at: CFAbsoluteTime,
3391 ) -> CFIndex;
3392}
3393extern "C" {
3394pub fn CFCalendarGetTimeRangeOfUnit(
3396 calendar: CFCalendarRef,
3397 unit: CFCalendarUnit,
3398 at: CFAbsoluteTime,
3399 startp: *mut CFAbsoluteTime,
3400 tip: *mut CFTimeInterval,
3401 ) -> Boolean;
3402}
3403extern "C" {
3404pub fn CFCalendarComposeAbsoluteTime(
3406 calendar: CFCalendarRef,
3407 at: *mut CFAbsoluteTime,
3408 componentDesc: *const ::core::ffi::c_char,
3409 ...
3410 ) -> Boolean;
3411}
3412extern "C" {
3413pub fn CFCalendarDecomposeAbsoluteTime(
3415 calendar: CFCalendarRef,
3416 at: CFAbsoluteTime,
3417 componentDesc: *const ::core::ffi::c_char,
3418 ...
3419 ) -> Boolean;
3420}
3421pub const kCFCalendarComponentsWrap: _bindgen_ty_20 = 1;
3423pub type _bindgen_ty_20 = ::core::ffi::c_uint;
3425extern "C" {
3426pub fn CFCalendarAddComponents(
3428 calendar: CFCalendarRef,
3429 at: *mut CFAbsoluteTime,
3430 options: CFOptionFlags,
3431 componentDesc: *const ::core::ffi::c_char,
3432 ...
3433 ) -> Boolean;
3434}
3435extern "C" {
3436pub fn CFCalendarGetComponentDifference(
3438 calendar: CFCalendarRef,
3439 startingAT: CFAbsoluteTime,
3440 resultAT: CFAbsoluteTime,
3441 options: CFOptionFlags,
3442 componentDesc: *const ::core::ffi::c_char,
3443 ...
3444 ) -> Boolean;
3445}
3446pub type CGFloat = f64;
3448#[repr(C)]
3449#[derive(Debug, Copy, Clone)]
3450pub struct CGPoint {
3452 pub x: CGFloat,
3453 pub y: CGFloat,
3454}
3455#[repr(C)]
3456#[derive(Debug, Copy, Clone)]
3457pub struct CGSize {
3459 pub width: CGFloat,
3460 pub height: CGFloat,
3461}
3462#[repr(C)]
3463#[derive(Debug, Copy, Clone)]
3464pub struct CGRect {
3466 pub origin: CGPoint,
3467 pub size: CGSize,
3468}
3469pub type CFDateFormatterKey = CFStringRef;
3471#[repr(C)]
3472#[derive(Debug, Copy, Clone)]
3473pub struct __CFDateFormatter {
3475 _unused: [u8; 0],
3476}
3477pub type CFDateFormatterRef = *mut __CFDateFormatter;
3479extern "C" {
3480pub fn CFDateFormatterCreateDateFormatFromTemplate(
3482 allocator: CFAllocatorRef,
3483 tmplate: CFStringRef,
3484 options: CFOptionFlags,
3485 locale: CFLocaleRef,
3486 ) -> CFStringRef;
3487}
3488extern "C" {
3489pub fn CFDateFormatterGetTypeID() -> CFTypeID;
3491}
3492pub type CFDateFormatterStyle = CFIndex;
3494pub const kCFDateFormatterNoStyle: _bindgen_ty_22 = 0;
3496pub const kCFDateFormatterShortStyle: _bindgen_ty_22 = 1;
3498pub const kCFDateFormatterMediumStyle: _bindgen_ty_22 = 2;
3500pub const kCFDateFormatterLongStyle: _bindgen_ty_22 = 3;
3502pub const kCFDateFormatterFullStyle: _bindgen_ty_22 = 4;
3504pub type _bindgen_ty_22 = ::core::ffi::c_uint;
3506pub type CFISO8601DateFormatOptions = CFOptionFlags;
3508pub const kCFISO8601DateFormatWithYear: _bindgen_ty_23 = 1;
3510pub const kCFISO8601DateFormatWithMonth: _bindgen_ty_23 = 2;
3512pub const kCFISO8601DateFormatWithWeekOfYear: _bindgen_ty_23 = 4;
3514pub const kCFISO8601DateFormatWithDay: _bindgen_ty_23 = 16;
3516pub const kCFISO8601DateFormatWithTime: _bindgen_ty_23 = 32;
3518pub const kCFISO8601DateFormatWithTimeZone: _bindgen_ty_23 = 64;
3520pub const kCFISO8601DateFormatWithSpaceBetweenDateAndTime: _bindgen_ty_23 = 128;
3522pub const kCFISO8601DateFormatWithDashSeparatorInDate: _bindgen_ty_23 = 256;
3524pub const kCFISO8601DateFormatWithColonSeparatorInTime: _bindgen_ty_23 = 512;
3526pub const kCFISO8601DateFormatWithColonSeparatorInTimeZone: _bindgen_ty_23 = 1024;
3528pub const kCFISO8601DateFormatWithFractionalSeconds: _bindgen_ty_23 = 2048;
3530pub const kCFISO8601DateFormatWithFullDate: _bindgen_ty_23 = 275;
3532pub const kCFISO8601DateFormatWithFullTime: _bindgen_ty_23 = 1632;
3534pub const kCFISO8601DateFormatWithInternetDateTime: _bindgen_ty_23 = 1907;
3536pub type _bindgen_ty_23 = ::core::ffi::c_uint;
3538extern "C" {
3539pub fn CFDateFormatterCreateISO8601Formatter(
3541 allocator: CFAllocatorRef,
3542 formatOptions: CFISO8601DateFormatOptions,
3543 ) -> CFDateFormatterRef;
3544}
3545extern "C" {
3546pub fn CFDateFormatterCreate(
3548 allocator: CFAllocatorRef,
3549 locale: CFLocaleRef,
3550 dateStyle: CFDateFormatterStyle,
3551 timeStyle: CFDateFormatterStyle,
3552 ) -> CFDateFormatterRef;
3553}
3554extern "C" {
3555pub fn CFDateFormatterGetLocale(formatter: CFDateFormatterRef) -> CFLocaleRef;
3557}
3558extern "C" {
3559pub fn CFDateFormatterGetDateStyle(formatter: CFDateFormatterRef) -> CFDateFormatterStyle;
3561}
3562extern "C" {
3563pub fn CFDateFormatterGetTimeStyle(formatter: CFDateFormatterRef) -> CFDateFormatterStyle;
3565}
3566extern "C" {
3567pub fn CFDateFormatterGetFormat(formatter: CFDateFormatterRef) -> CFStringRef;
3569}
3570extern "C" {
3571pub fn CFDateFormatterSetFormat(formatter: CFDateFormatterRef, formatString: CFStringRef);
3573}
3574extern "C" {
3575pub fn CFDateFormatterCreateStringWithDate(
3577 allocator: CFAllocatorRef,
3578 formatter: CFDateFormatterRef,
3579 date: CFDateRef,
3580 ) -> CFStringRef;
3581}
3582extern "C" {
3583pub fn CFDateFormatterCreateStringWithAbsoluteTime(
3585 allocator: CFAllocatorRef,
3586 formatter: CFDateFormatterRef,
3587 at: CFAbsoluteTime,
3588 ) -> CFStringRef;
3589}
3590extern "C" {
3591pub fn CFDateFormatterCreateDateFromString(
3593 allocator: CFAllocatorRef,
3594 formatter: CFDateFormatterRef,
3595 string: CFStringRef,
3596 rangep: *mut CFRange,
3597 ) -> CFDateRef;
3598}
3599extern "C" {
3600pub fn CFDateFormatterGetAbsoluteTimeFromString(
3602 formatter: CFDateFormatterRef,
3603 string: CFStringRef,
3604 rangep: *mut CFRange,
3605 atp: *mut CFAbsoluteTime,
3606 ) -> Boolean;
3607}
3608extern "C" {
3609pub fn CFDateFormatterSetProperty(
3611 formatter: CFDateFormatterRef,
3612 key: CFStringRef,
3613 value: CFTypeRef,
3614 );
3615}
3616extern "C" {
3617pub fn CFDateFormatterCopyProperty(
3619 formatter: CFDateFormatterRef,
3620 key: CFDateFormatterKey,
3621 ) -> CFTypeRef;
3622}
3623extern "C" {
3624pub static kCFDateFormatterIsLenient: CFDateFormatterKey;
3626}
3627extern "C" {
3628pub static kCFDateFormatterTimeZone: CFDateFormatterKey;
3630}
3631extern "C" {
3632pub static kCFDateFormatterCalendarName: CFDateFormatterKey;
3634}
3635extern "C" {
3636pub static kCFDateFormatterDefaultFormat: CFDateFormatterKey;
3638}
3639extern "C" {
3640pub static kCFDateFormatterTwoDigitStartDate: CFDateFormatterKey;
3642}
3643extern "C" {
3644pub static kCFDateFormatterDefaultDate: CFDateFormatterKey;
3646}
3647extern "C" {
3648pub static kCFDateFormatterCalendar: CFDateFormatterKey;
3650}
3651extern "C" {
3652pub static kCFDateFormatterEraSymbols: CFDateFormatterKey;
3654}
3655extern "C" {
3656pub static kCFDateFormatterMonthSymbols: CFDateFormatterKey;
3658}
3659extern "C" {
3660pub static kCFDateFormatterShortMonthSymbols: CFDateFormatterKey;
3662}
3663extern "C" {
3664pub static kCFDateFormatterWeekdaySymbols: CFDateFormatterKey;
3666}
3667extern "C" {
3668pub static kCFDateFormatterShortWeekdaySymbols: CFDateFormatterKey;
3670}
3671extern "C" {
3672pub static kCFDateFormatterAMSymbol: CFDateFormatterKey;
3674}
3675extern "C" {
3676pub static kCFDateFormatterPMSymbol: CFDateFormatterKey;
3678}
3679extern "C" {
3680pub static kCFDateFormatterLongEraSymbols: CFDateFormatterKey;
3682}
3683extern "C" {
3684pub static kCFDateFormatterVeryShortMonthSymbols: CFDateFormatterKey;
3686}
3687extern "C" {
3688pub static kCFDateFormatterStandaloneMonthSymbols: CFDateFormatterKey;
3690}
3691extern "C" {
3692pub static kCFDateFormatterShortStandaloneMonthSymbols: CFDateFormatterKey;
3694}
3695extern "C" {
3696pub static kCFDateFormatterVeryShortStandaloneMonthSymbols: CFDateFormatterKey;
3698}
3699extern "C" {
3700pub static kCFDateFormatterVeryShortWeekdaySymbols: CFDateFormatterKey;
3702}
3703extern "C" {
3704pub static kCFDateFormatterStandaloneWeekdaySymbols: CFDateFormatterKey;
3706}
3707extern "C" {
3708pub static kCFDateFormatterShortStandaloneWeekdaySymbols: CFDateFormatterKey;
3710}
3711extern "C" {
3712pub static kCFDateFormatterVeryShortStandaloneWeekdaySymbols: CFDateFormatterKey;
3714}
3715extern "C" {
3716pub static kCFDateFormatterQuarterSymbols: CFDateFormatterKey;
3718}
3719extern "C" {
3720pub static kCFDateFormatterShortQuarterSymbols: CFDateFormatterKey;
3722}
3723extern "C" {
3724pub static kCFDateFormatterStandaloneQuarterSymbols: CFDateFormatterKey;
3726}
3727extern "C" {
3728pub static kCFDateFormatterShortStandaloneQuarterSymbols: CFDateFormatterKey;
3730}
3731extern "C" {
3732pub static kCFDateFormatterGregorianStartDate: CFDateFormatterKey;
3734}
3735extern "C" {
3736pub static kCFDateFormatterDoesRelativeDateFormattingKey: CFDateFormatterKey;
3738}
3739#[repr(C)]
3740#[derive(Debug, Copy, Clone)]
3741pub struct __CFBoolean {
3743 _unused: [u8; 0],
3744}
3745pub type CFBooleanRef = *const __CFBoolean;
3747extern "C" {
3748pub static kCFBooleanTrue: CFBooleanRef;
3750}
3751extern "C" {
3752pub static kCFBooleanFalse: CFBooleanRef;
3754}
3755extern "C" {
3756pub fn CFBooleanGetTypeID() -> CFTypeID;
3758}
3759extern "C" {
3760pub fn CFBooleanGetValue(boolean: CFBooleanRef) -> Boolean;
3762}
3763pub type CFNumberType = CFIndex;
3765pub const kCFNumberSInt8Type: _bindgen_ty_24 = 1;
3767pub const kCFNumberSInt16Type: _bindgen_ty_24 = 2;
3769pub const kCFNumberSInt32Type: _bindgen_ty_24 = 3;
3771pub const kCFNumberSInt64Type: _bindgen_ty_24 = 4;
3773pub const kCFNumberFloat32Type: _bindgen_ty_24 = 5;
3775pub const kCFNumberFloat64Type: _bindgen_ty_24 = 6;
3777pub const kCFNumberCharType: _bindgen_ty_24 = 7;
3779pub const kCFNumberShortType: _bindgen_ty_24 = 8;
3781pub const kCFNumberIntType: _bindgen_ty_24 = 9;
3783pub const kCFNumberLongType: _bindgen_ty_24 = 10;
3785pub const kCFNumberLongLongType: _bindgen_ty_24 = 11;
3787pub const kCFNumberFloatType: _bindgen_ty_24 = 12;
3789pub const kCFNumberDoubleType: _bindgen_ty_24 = 13;
3791pub const kCFNumberCFIndexType: _bindgen_ty_24 = 14;
3793pub const kCFNumberNSIntegerType: _bindgen_ty_24 = 15;
3795pub const kCFNumberCGFloatType: _bindgen_ty_24 = 16;
3797pub const kCFNumberMaxType: _bindgen_ty_24 = 16;
3799pub type _bindgen_ty_24 = ::core::ffi::c_uint;
3801#[repr(C)]
3802#[derive(Debug, Copy, Clone)]
3803pub struct __CFNumber {
3805 _unused: [u8; 0],
3806}
3807pub type CFNumberRef = *const __CFNumber;
3809extern "C" {
3810pub static kCFNumberPositiveInfinity: CFNumberRef;
3812}
3813extern "C" {
3814pub static kCFNumberNegativeInfinity: CFNumberRef;
3816}
3817extern "C" {
3818pub static kCFNumberNaN: CFNumberRef;
3820}
3821extern "C" {
3822pub fn CFNumberGetTypeID() -> CFTypeID;
3824}
3825extern "C" {
3826pub fn CFNumberCreate(
3828 allocator: CFAllocatorRef,
3829 theType: CFNumberType,
3830 valuePtr: *const ::core::ffi::c_void,
3831 ) -> CFNumberRef;
3832}
3833extern "C" {
3834pub fn CFNumberGetType(number: CFNumberRef) -> CFNumberType;
3836}
3837extern "C" {
3838pub fn CFNumberGetByteSize(number: CFNumberRef) -> CFIndex;
3840}
3841extern "C" {
3842pub fn CFNumberIsFloatType(number: CFNumberRef) -> Boolean;
3844}
3845extern "C" {
3846pub fn CFNumberGetValue(
3848 number: CFNumberRef,
3849 theType: CFNumberType,
3850 valuePtr: *mut ::core::ffi::c_void,
3851 ) -> Boolean;
3852}
3853extern "C" {
3854pub fn CFNumberCompare(
3856 number: CFNumberRef,
3857 otherNumber: CFNumberRef,
3858 context: *mut ::core::ffi::c_void,
3859 ) -> CFComparisonResult;
3860}
3861pub type CFNumberFormatterKey = CFStringRef;
3863#[repr(C)]
3864#[derive(Debug, Copy, Clone)]
3865pub struct __CFNumberFormatter {
3867 _unused: [u8; 0],
3868}
3869pub type CFNumberFormatterRef = *mut __CFNumberFormatter;
3871extern "C" {
3872pub fn CFNumberFormatterGetTypeID() -> CFTypeID;
3874}
3875pub type CFNumberFormatterStyle = CFIndex;
3877pub const kCFNumberFormatterNoStyle: _bindgen_ty_25 = 0;
3879pub const kCFNumberFormatterDecimalStyle: _bindgen_ty_25 = 1;
3881pub const kCFNumberFormatterCurrencyStyle: _bindgen_ty_25 = 2;
3883pub const kCFNumberFormatterPercentStyle: _bindgen_ty_25 = 3;
3885pub const kCFNumberFormatterScientificStyle: _bindgen_ty_25 = 4;
3887pub const kCFNumberFormatterSpellOutStyle: _bindgen_ty_25 = 5;
3889pub const kCFNumberFormatterOrdinalStyle: _bindgen_ty_25 = 6;
3891pub const kCFNumberFormatterCurrencyISOCodeStyle: _bindgen_ty_25 = 8;
3893pub const kCFNumberFormatterCurrencyPluralStyle: _bindgen_ty_25 = 9;
3895pub const kCFNumberFormatterCurrencyAccountingStyle: _bindgen_ty_25 = 10;
3897pub type _bindgen_ty_25 = ::core::ffi::c_uint;
3899extern "C" {
3900pub fn CFNumberFormatterCreate(
3902 allocator: CFAllocatorRef,
3903 locale: CFLocaleRef,
3904 style: CFNumberFormatterStyle,
3905 ) -> CFNumberFormatterRef;
3906}
3907extern "C" {
3908pub fn CFNumberFormatterGetLocale(formatter: CFNumberFormatterRef) -> CFLocaleRef;
3910}
3911extern "C" {
3912pub fn CFNumberFormatterGetStyle(formatter: CFNumberFormatterRef) -> CFNumberFormatterStyle;
3914}
3915extern "C" {
3916pub fn CFNumberFormatterGetFormat(formatter: CFNumberFormatterRef) -> CFStringRef;
3918}
3919extern "C" {
3920pub fn CFNumberFormatterSetFormat(formatter: CFNumberFormatterRef, formatString: CFStringRef);
3922}
3923extern "C" {
3924pub fn CFNumberFormatterCreateStringWithNumber(
3926 allocator: CFAllocatorRef,
3927 formatter: CFNumberFormatterRef,
3928 number: CFNumberRef,
3929 ) -> CFStringRef;
3930}
3931extern "C" {
3932pub fn CFNumberFormatterCreateStringWithValue(
3934 allocator: CFAllocatorRef,
3935 formatter: CFNumberFormatterRef,
3936 numberType: CFNumberType,
3937 valuePtr: *const ::core::ffi::c_void,
3938 ) -> CFStringRef;
3939}
3940pub type CFNumberFormatterOptionFlags = CFOptionFlags;
3942pub const kCFNumberFormatterParseIntegersOnly: _bindgen_ty_26 = 1;
3944pub type _bindgen_ty_26 = ::core::ffi::c_uint;
3946extern "C" {
3947pub fn CFNumberFormatterCreateNumberFromString(
3949 allocator: CFAllocatorRef,
3950 formatter: CFNumberFormatterRef,
3951 string: CFStringRef,
3952 rangep: *mut CFRange,
3953 options: CFOptionFlags,
3954 ) -> CFNumberRef;
3955}
3956extern "C" {
3957pub fn CFNumberFormatterGetValueFromString(
3959 formatter: CFNumberFormatterRef,
3960 string: CFStringRef,
3961 rangep: *mut CFRange,
3962 numberType: CFNumberType,
3963 valuePtr: *mut ::core::ffi::c_void,
3964 ) -> Boolean;
3965}
3966extern "C" {
3967pub fn CFNumberFormatterSetProperty(
3969 formatter: CFNumberFormatterRef,
3970 key: CFNumberFormatterKey,
3971 value: CFTypeRef,
3972 );
3973}
3974extern "C" {
3975pub fn CFNumberFormatterCopyProperty(
3977 formatter: CFNumberFormatterRef,
3978 key: CFNumberFormatterKey,
3979 ) -> CFTypeRef;
3980}
3981extern "C" {
3982pub static kCFNumberFormatterCurrencyCode: CFNumberFormatterKey;
3984}
3985extern "C" {
3986pub static kCFNumberFormatterDecimalSeparator: CFNumberFormatterKey;
3988}
3989extern "C" {
3990pub static kCFNumberFormatterCurrencyDecimalSeparator: CFNumberFormatterKey;
3992}
3993extern "C" {
3994pub static kCFNumberFormatterAlwaysShowDecimalSeparator: CFNumberFormatterKey;
3996}
3997extern "C" {
3998pub static kCFNumberFormatterGroupingSeparator: CFNumberFormatterKey;
4000}
4001extern "C" {
4002pub static kCFNumberFormatterUseGroupingSeparator: CFNumberFormatterKey;
4004}
4005extern "C" {
4006pub static kCFNumberFormatterPercentSymbol: CFNumberFormatterKey;
4008}
4009extern "C" {
4010pub static kCFNumberFormatterZeroSymbol: CFNumberFormatterKey;
4012}
4013extern "C" {
4014pub static kCFNumberFormatterNaNSymbol: CFNumberFormatterKey;
4016}
4017extern "C" {
4018pub static kCFNumberFormatterInfinitySymbol: CFNumberFormatterKey;
4020}
4021extern "C" {
4022pub static kCFNumberFormatterMinusSign: CFNumberFormatterKey;
4024}
4025extern "C" {
4026pub static kCFNumberFormatterPlusSign: CFNumberFormatterKey;
4028}
4029extern "C" {
4030pub static kCFNumberFormatterCurrencySymbol: CFNumberFormatterKey;
4032}
4033extern "C" {
4034pub static kCFNumberFormatterExponentSymbol: CFNumberFormatterKey;
4036}
4037extern "C" {
4038pub static kCFNumberFormatterMinIntegerDigits: CFNumberFormatterKey;
4040}
4041extern "C" {
4042pub static kCFNumberFormatterMaxIntegerDigits: CFNumberFormatterKey;
4044}
4045extern "C" {
4046pub static kCFNumberFormatterMinFractionDigits: CFNumberFormatterKey;
4048}
4049extern "C" {
4050pub static kCFNumberFormatterMaxFractionDigits: CFNumberFormatterKey;
4052}
4053extern "C" {
4054pub static kCFNumberFormatterGroupingSize: CFNumberFormatterKey;
4056}
4057extern "C" {
4058pub static kCFNumberFormatterSecondaryGroupingSize: CFNumberFormatterKey;
4060}
4061extern "C" {
4062pub static kCFNumberFormatterRoundingMode: CFNumberFormatterKey;
4064}
4065extern "C" {
4066pub static kCFNumberFormatterRoundingIncrement: CFNumberFormatterKey;
4068}
4069extern "C" {
4070pub static kCFNumberFormatterFormatWidth: CFNumberFormatterKey;
4072}
4073extern "C" {
4074pub static kCFNumberFormatterPaddingPosition: CFNumberFormatterKey;
4076}
4077extern "C" {
4078pub static kCFNumberFormatterPaddingCharacter: CFNumberFormatterKey;
4080}
4081extern "C" {
4082pub static kCFNumberFormatterDefaultFormat: CFNumberFormatterKey;
4084}
4085extern "C" {
4086pub static kCFNumberFormatterMultiplier: CFNumberFormatterKey;
4088}
4089extern "C" {
4090pub static kCFNumberFormatterPositivePrefix: CFNumberFormatterKey;
4092}
4093extern "C" {
4094pub static kCFNumberFormatterPositiveSuffix: CFNumberFormatterKey;
4096}
4097extern "C" {
4098pub static kCFNumberFormatterNegativePrefix: CFNumberFormatterKey;
4100}
4101extern "C" {
4102pub static kCFNumberFormatterNegativeSuffix: CFNumberFormatterKey;
4104}
4105extern "C" {
4106pub static kCFNumberFormatterPerMillSymbol: CFNumberFormatterKey;
4108}
4109extern "C" {
4110pub static kCFNumberFormatterInternationalCurrencySymbol: CFNumberFormatterKey;
4112}
4113extern "C" {
4114pub static kCFNumberFormatterCurrencyGroupingSeparator: CFNumberFormatterKey;
4116}
4117extern "C" {
4118pub static kCFNumberFormatterIsLenient: CFNumberFormatterKey;
4120}
4121extern "C" {
4122pub static kCFNumberFormatterUseSignificantDigits: CFNumberFormatterKey;
4124}
4125extern "C" {
4126pub static kCFNumberFormatterMinSignificantDigits: CFNumberFormatterKey;
4128}
4129extern "C" {
4130pub static kCFNumberFormatterMaxSignificantDigits: CFNumberFormatterKey;
4132}
4133extern "C" {
4134pub static kCFNumberFormatterMinGroupingDigits: CFNumberFormatterKey;
4136}
4137pub type CFNumberFormatterRoundingMode = CFIndex;
4139pub const kCFNumberFormatterRoundCeiling: _bindgen_ty_27 = 0;
4141pub const kCFNumberFormatterRoundFloor: _bindgen_ty_27 = 1;
4143pub const kCFNumberFormatterRoundDown: _bindgen_ty_27 = 2;
4145pub const kCFNumberFormatterRoundUp: _bindgen_ty_27 = 3;
4147pub const kCFNumberFormatterRoundHalfEven: _bindgen_ty_27 = 4;
4149pub const kCFNumberFormatterRoundHalfDown: _bindgen_ty_27 = 5;
4151pub const kCFNumberFormatterRoundHalfUp: _bindgen_ty_27 = 6;
4153pub type _bindgen_ty_27 = ::core::ffi::c_uint;
4155pub type CFNumberFormatterPadPosition = CFIndex;
4157pub const kCFNumberFormatterPadBeforePrefix: _bindgen_ty_28 = 0;
4159pub const kCFNumberFormatterPadAfterPrefix: _bindgen_ty_28 = 1;
4161pub const kCFNumberFormatterPadBeforeSuffix: _bindgen_ty_28 = 2;
4163pub const kCFNumberFormatterPadAfterSuffix: _bindgen_ty_28 = 3;
4165pub type _bindgen_ty_28 = ::core::ffi::c_uint;
4167extern "C" {
4168pub fn CFNumberFormatterGetDecimalInfoForCurrencyCode(
4170 currencyCode: CFStringRef,
4171 defaultFractionDigits: *mut i32,
4172 roundingIncrement: *mut f64,
4173 ) -> Boolean;
4174}
4175extern "C" {
4176pub static kCFPreferencesAnyApplication: CFStringRef;
4178}
4179extern "C" {
4180pub static kCFPreferencesCurrentApplication: CFStringRef;
4182}
4183extern "C" {
4184pub static kCFPreferencesAnyHost: CFStringRef;
4186}
4187extern "C" {
4188pub static kCFPreferencesCurrentHost: CFStringRef;
4190}
4191extern "C" {
4192pub static kCFPreferencesAnyUser: CFStringRef;
4194}
4195extern "C" {
4196pub static kCFPreferencesCurrentUser: CFStringRef;
4198}
4199extern "C" {
4200pub fn CFPreferencesCopyAppValue(
4202 key: CFStringRef,
4203 applicationID: CFStringRef,
4204 ) -> CFPropertyListRef;
4205}
4206extern "C" {
4207pub fn CFPreferencesGetAppBooleanValue(
4209 key: CFStringRef,
4210 applicationID: CFStringRef,
4211 keyExistsAndHasValidFormat: *mut Boolean,
4212 ) -> Boolean;
4213}
4214extern "C" {
4215pub fn CFPreferencesGetAppIntegerValue(
4217 key: CFStringRef,
4218 applicationID: CFStringRef,
4219 keyExistsAndHasValidFormat: *mut Boolean,
4220 ) -> CFIndex;
4221}
4222extern "C" {
4223pub fn CFPreferencesSetAppValue(
4225 key: CFStringRef,
4226 value: CFPropertyListRef,
4227 applicationID: CFStringRef,
4228 );
4229}
4230extern "C" {
4231pub fn CFPreferencesAddSuitePreferencesToApp(applicationID: CFStringRef, suiteID: CFStringRef);
4233}
4234extern "C" {
4235pub fn CFPreferencesRemoveSuitePreferencesFromApp(
4237 applicationID: CFStringRef,
4238 suiteID: CFStringRef,
4239 );
4240}
4241extern "C" {
4242pub fn CFPreferencesAppSynchronize(applicationID: CFStringRef) -> Boolean;
4244}
4245extern "C" {
4246pub fn CFPreferencesCopyValue(
4248 key: CFStringRef,
4249 applicationID: CFStringRef,
4250 userName: CFStringRef,
4251 hostName: CFStringRef,
4252 ) -> CFPropertyListRef;
4253}
4254extern "C" {
4255pub fn CFPreferencesCopyMultiple(
4257 keysToFetch: CFArrayRef,
4258 applicationID: CFStringRef,
4259 userName: CFStringRef,
4260 hostName: CFStringRef,
4261 ) -> CFDictionaryRef;
4262}
4263extern "C" {
4264pub fn CFPreferencesSetValue(
4266 key: CFStringRef,
4267 value: CFPropertyListRef,
4268 applicationID: CFStringRef,
4269 userName: CFStringRef,
4270 hostName: CFStringRef,
4271 );
4272}
4273extern "C" {
4274pub fn CFPreferencesSetMultiple(
4276 keysToSet: CFDictionaryRef,
4277 keysToRemove: CFArrayRef,
4278 applicationID: CFStringRef,
4279 userName: CFStringRef,
4280 hostName: CFStringRef,
4281 );
4282}
4283extern "C" {
4284pub fn CFPreferencesSynchronize(
4286 applicationID: CFStringRef,
4287 userName: CFStringRef,
4288 hostName: CFStringRef,
4289 ) -> Boolean;
4290}
4291extern "C" {
4292pub fn CFPreferencesCopyApplicationList(
4294 userName: CFStringRef,
4295 hostName: CFStringRef,
4296 ) -> CFArrayRef;
4297}
4298extern "C" {
4299pub fn CFPreferencesCopyKeyList(
4301 applicationID: CFStringRef,
4302 userName: CFStringRef,
4303 hostName: CFStringRef,
4304 ) -> CFArrayRef;
4305}
4306extern "C" {
4307pub fn CFPreferencesAppValueIsForced(key: CFStringRef, applicationID: CFStringRef) -> Boolean;
4309}
4310pub type CFURLPathStyle = CFIndex;
4312pub const kCFURLPOSIXPathStyle: _bindgen_ty_29 = 0;
4314pub const kCFURLHFSPathStyle: _bindgen_ty_29 = 1;
4316pub const kCFURLWindowsPathStyle: _bindgen_ty_29 = 2;
4318pub type _bindgen_ty_29 = ::core::ffi::c_uint;
4320#[repr(C)]
4321#[derive(Debug, Copy, Clone)]
4322pub struct __CFURL {
4324 _unused: [u8; 0],
4325}
4326pub type CFURLRef = *const __CFURL;
4328extern "C" {
4329pub fn CFURLGetTypeID() -> CFTypeID;
4331}
4332extern "C" {
4333pub fn CFURLCreateWithBytes(
4335 allocator: CFAllocatorRef,
4336 URLBytes: *const UInt8,
4337 length: CFIndex,
4338 encoding: CFStringEncoding,
4339 baseURL: CFURLRef,
4340 ) -> CFURLRef;
4341}
4342extern "C" {
4343pub fn CFURLCreateData(
4345 allocator: CFAllocatorRef,
4346 url: CFURLRef,
4347 encoding: CFStringEncoding,
4348 escapeWhitespace: Boolean,
4349 ) -> CFDataRef;
4350}
4351extern "C" {
4352pub fn CFURLCreateWithString(
4354 allocator: CFAllocatorRef,
4355 URLString: CFStringRef,
4356 baseURL: CFURLRef,
4357 ) -> CFURLRef;
4358}
4359extern "C" {
4360pub fn CFURLCreateAbsoluteURLWithBytes(
4362 alloc: CFAllocatorRef,
4363 relativeURLBytes: *const UInt8,
4364 length: CFIndex,
4365 encoding: CFStringEncoding,
4366 baseURL: CFURLRef,
4367 useCompatibilityMode: Boolean,
4368 ) -> CFURLRef;
4369}
4370extern "C" {
4371pub fn CFURLCreateWithFileSystemPath(
4373 allocator: CFAllocatorRef,
4374 filePath: CFStringRef,
4375 pathStyle: CFURLPathStyle,
4376 isDirectory: Boolean,
4377 ) -> CFURLRef;
4378}
4379extern "C" {
4380pub fn CFURLCreateFromFileSystemRepresentation(
4382 allocator: CFAllocatorRef,
4383 buffer: *const UInt8,
4384 bufLen: CFIndex,
4385 isDirectory: Boolean,
4386 ) -> CFURLRef;
4387}
4388extern "C" {
4389pub fn CFURLCreateWithFileSystemPathRelativeToBase(
4391 allocator: CFAllocatorRef,
4392 filePath: CFStringRef,
4393 pathStyle: CFURLPathStyle,
4394 isDirectory: Boolean,
4395 baseURL: CFURLRef,
4396 ) -> CFURLRef;
4397}
4398extern "C" {
4399pub fn CFURLCreateFromFileSystemRepresentationRelativeToBase(
4401 allocator: CFAllocatorRef,
4402 buffer: *const UInt8,
4403 bufLen: CFIndex,
4404 isDirectory: Boolean,
4405 baseURL: CFURLRef,
4406 ) -> CFURLRef;
4407}
4408extern "C" {
4409pub fn CFURLGetFileSystemRepresentation(
4411 url: CFURLRef,
4412 resolveAgainstBase: Boolean,
4413 buffer: *mut UInt8,
4414 maxBufLen: CFIndex,
4415 ) -> Boolean;
4416}
4417extern "C" {
4418pub fn CFURLCopyAbsoluteURL(relativeURL: CFURLRef) -> CFURLRef;
4420}
4421extern "C" {
4422pub fn CFURLGetString(anURL: CFURLRef) -> CFStringRef;
4424}
4425extern "C" {
4426pub fn CFURLGetBaseURL(anURL: CFURLRef) -> CFURLRef;
4428}
4429extern "C" {
4430pub fn CFURLCanBeDecomposed(anURL: CFURLRef) -> Boolean;
4432}
4433extern "C" {
4434pub fn CFURLCopyScheme(anURL: CFURLRef) -> CFStringRef;
4436}
4437extern "C" {
4438pub fn CFURLCopyNetLocation(anURL: CFURLRef) -> CFStringRef;
4440}
4441extern "C" {
4442pub fn CFURLCopyPath(anURL: CFURLRef) -> CFStringRef;
4444}
4445extern "C" {
4446pub fn CFURLCopyStrictPath(anURL: CFURLRef, isAbsolute: *mut Boolean) -> CFStringRef;
4448}
4449extern "C" {
4450pub fn CFURLCopyFileSystemPath(anURL: CFURLRef, pathStyle: CFURLPathStyle) -> CFStringRef;
4452}
4453extern "C" {
4454pub fn CFURLHasDirectoryPath(anURL: CFURLRef) -> Boolean;
4456}
4457extern "C" {
4458pub fn CFURLCopyResourceSpecifier(anURL: CFURLRef) -> CFStringRef;
4460}
4461extern "C" {
4462pub fn CFURLCopyHostName(anURL: CFURLRef) -> CFStringRef;
4464}
4465extern "C" {
4466pub fn CFURLGetPortNumber(anURL: CFURLRef) -> SInt32;
4468}
4469extern "C" {
4470pub fn CFURLCopyUserName(anURL: CFURLRef) -> CFStringRef;
4472}
4473extern "C" {
4474pub fn CFURLCopyPassword(anURL: CFURLRef) -> CFStringRef;
4476}
4477extern "C" {
4478pub fn CFURLCopyParameterString(
4480 anURL: CFURLRef,
4481 charactersToLeaveEscaped: CFStringRef,
4482 ) -> CFStringRef;
4483}
4484extern "C" {
4485pub fn CFURLCopyQueryString(
4487 anURL: CFURLRef,
4488 charactersToLeaveEscaped: CFStringRef,
4489 ) -> CFStringRef;
4490}
4491extern "C" {
4492pub fn CFURLCopyFragment(anURL: CFURLRef, charactersToLeaveEscaped: CFStringRef)
4494 -> CFStringRef;
4495}
4496extern "C" {
4497pub fn CFURLCopyLastPathComponent(url: CFURLRef) -> CFStringRef;
4499}
4500extern "C" {
4501pub fn CFURLCopyPathExtension(url: CFURLRef) -> CFStringRef;
4503}
4504extern "C" {
4505pub fn CFURLCreateCopyAppendingPathComponent(
4507 allocator: CFAllocatorRef,
4508 url: CFURLRef,
4509 pathComponent: CFStringRef,
4510 isDirectory: Boolean,
4511 ) -> CFURLRef;
4512}
4513extern "C" {
4514pub fn CFURLCreateCopyDeletingLastPathComponent(
4516 allocator: CFAllocatorRef,
4517 url: CFURLRef,
4518 ) -> CFURLRef;
4519}
4520extern "C" {
4521pub fn CFURLCreateCopyAppendingPathExtension(
4523 allocator: CFAllocatorRef,
4524 url: CFURLRef,
4525 extension: CFStringRef,
4526 ) -> CFURLRef;
4527}
4528extern "C" {
4529pub fn CFURLCreateCopyDeletingPathExtension(
4531 allocator: CFAllocatorRef,
4532 url: CFURLRef,
4533 ) -> CFURLRef;
4534}
4535extern "C" {
4536pub fn CFURLGetBytes(url: CFURLRef, buffer: *mut UInt8, bufferLength: CFIndex) -> CFIndex;
4538}
4539pub type CFURLComponentType = CFIndex;
4541pub const kCFURLComponentScheme: _bindgen_ty_30 = 1;
4543pub const kCFURLComponentNetLocation: _bindgen_ty_30 = 2;
4545pub const kCFURLComponentPath: _bindgen_ty_30 = 3;
4547pub const kCFURLComponentResourceSpecifier: _bindgen_ty_30 = 4;
4549pub const kCFURLComponentUser: _bindgen_ty_30 = 5;
4551pub const kCFURLComponentPassword: _bindgen_ty_30 = 6;
4553pub const kCFURLComponentUserInfo: _bindgen_ty_30 = 7;
4555pub const kCFURLComponentHost: _bindgen_ty_30 = 8;
4557pub const kCFURLComponentPort: _bindgen_ty_30 = 9;
4559pub const kCFURLComponentParameterString: _bindgen_ty_30 = 10;
4561pub const kCFURLComponentQuery: _bindgen_ty_30 = 11;
4563pub const kCFURLComponentFragment: _bindgen_ty_30 = 12;
4565pub type _bindgen_ty_30 = ::core::ffi::c_uint;
4567extern "C" {
4568pub fn CFURLGetByteRangeForComponent(
4570 url: CFURLRef,
4571 component: CFURLComponentType,
4572 rangeIncludingSeparators: *mut CFRange,
4573 ) -> CFRange;
4574}
4575extern "C" {
4576pub fn CFURLCreateStringByReplacingPercentEscapes(
4578 allocator: CFAllocatorRef,
4579 originalString: CFStringRef,
4580 charactersToLeaveEscaped: CFStringRef,
4581 ) -> CFStringRef;
4582}
4583extern "C" {
4584pub fn CFURLCreateStringByReplacingPercentEscapesUsingEncoding(
4586 allocator: CFAllocatorRef,
4587 origString: CFStringRef,
4588 charsToLeaveEscaped: CFStringRef,
4589 encoding: CFStringEncoding,
4590 ) -> CFStringRef;
4591}
4592extern "C" {
4593pub fn CFURLCreateStringByAddingPercentEscapes(
4595 allocator: CFAllocatorRef,
4596 originalString: CFStringRef,
4597 charactersToLeaveUnescaped: CFStringRef,
4598 legalURLCharactersToBeEscaped: CFStringRef,
4599 encoding: CFStringEncoding,
4600 ) -> CFStringRef;
4601}
4602extern "C" {
4603pub fn CFURLIsFileReferenceURL(url: CFURLRef) -> Boolean;
4605}
4606extern "C" {
4607pub fn CFURLCreateFileReferenceURL(
4609 allocator: CFAllocatorRef,
4610 url: CFURLRef,
4611 error: *mut CFErrorRef,
4612 ) -> CFURLRef;
4613}
4614extern "C" {
4615pub fn CFURLCreateFilePathURL(
4617 allocator: CFAllocatorRef,
4618 url: CFURLRef,
4619 error: *mut CFErrorRef,
4620 ) -> CFURLRef;
4621}
4622extern "C" {
4623pub fn CFURLCreateFromFSRef(allocator: CFAllocatorRef, fsRef: *const FSRef) -> CFURLRef;
4625}
4626extern "C" {
4627pub fn CFURLGetFSRef(url: CFURLRef, fsRef: *mut FSRef) -> Boolean;
4629}
4630extern "C" {
4631pub fn CFURLCopyResourcePropertyForKey(
4633 url: CFURLRef,
4634 key: CFStringRef,
4635 propertyValueTypeRefPtr: *mut ::core::ffi::c_void,
4636 error: *mut CFErrorRef,
4637 ) -> Boolean;
4638}
4639extern "C" {
4640pub fn CFURLCopyResourcePropertiesForKeys(
4642 url: CFURLRef,
4643 keys: CFArrayRef,
4644 error: *mut CFErrorRef,
4645 ) -> CFDictionaryRef;
4646}
4647extern "C" {
4648pub fn CFURLSetResourcePropertyForKey(
4650 url: CFURLRef,
4651 key: CFStringRef,
4652 propertyValue: CFTypeRef,
4653 error: *mut CFErrorRef,
4654 ) -> Boolean;
4655}
4656extern "C" {
4657pub fn CFURLSetResourcePropertiesForKeys(
4659 url: CFURLRef,
4660 keyedPropertyValues: CFDictionaryRef,
4661 error: *mut CFErrorRef,
4662 ) -> Boolean;
4663}
4664extern "C" {
4665pub static kCFURLKeysOfUnsetValuesKey: CFStringRef;
4667}
4668extern "C" {
4669pub fn CFURLClearResourcePropertyCacheForKey(url: CFURLRef, key: CFStringRef);
4671}
4672extern "C" {
4673pub fn CFURLClearResourcePropertyCache(url: CFURLRef);
4675}
4676extern "C" {
4677pub fn CFURLSetTemporaryResourcePropertyForKey(
4679 url: CFURLRef,
4680 key: CFStringRef,
4681 propertyValue: CFTypeRef,
4682 );
4683}
4684extern "C" {
4685pub fn CFURLResourceIsReachable(url: CFURLRef, error: *mut CFErrorRef) -> Boolean;
4687}
4688extern "C" {
4689pub static kCFURLNameKey: CFStringRef;
4691}
4692extern "C" {
4693pub static kCFURLLocalizedNameKey: CFStringRef;
4695}
4696extern "C" {
4697pub static kCFURLIsRegularFileKey: CFStringRef;
4699}
4700extern "C" {
4701pub static kCFURLIsDirectoryKey: CFStringRef;
4703}
4704extern "C" {
4705pub static kCFURLIsSymbolicLinkKey: CFStringRef;
4707}
4708extern "C" {
4709pub static kCFURLIsVolumeKey: CFStringRef;
4711}
4712extern "C" {
4713pub static kCFURLIsPackageKey: CFStringRef;
4715}
4716extern "C" {
4717pub static kCFURLIsApplicationKey: CFStringRef;
4719}
4720extern "C" {
4721pub static kCFURLApplicationIsScriptableKey: CFStringRef;
4723}
4724extern "C" {
4725pub static kCFURLIsSystemImmutableKey: CFStringRef;
4727}
4728extern "C" {
4729pub static kCFURLIsUserImmutableKey: CFStringRef;
4731}
4732extern "C" {
4733pub static kCFURLIsHiddenKey: CFStringRef;
4735}
4736extern "C" {
4737pub static kCFURLHasHiddenExtensionKey: CFStringRef;
4739}
4740extern "C" {
4741pub static kCFURLCreationDateKey: CFStringRef;
4743}
4744extern "C" {
4745pub static kCFURLContentAccessDateKey: CFStringRef;
4747}
4748extern "C" {
4749pub static kCFURLContentModificationDateKey: CFStringRef;
4751}
4752extern "C" {
4753pub static kCFURLAttributeModificationDateKey: CFStringRef;
4755}
4756extern "C" {
4757pub static kCFURLFileIdentifierKey: CFStringRef;
4759}
4760extern "C" {
4761pub static kCFURLFileContentIdentifierKey: CFStringRef;
4763}
4764extern "C" {
4765pub static kCFURLMayShareFileContentKey: CFStringRef;
4767}
4768extern "C" {
4769pub static kCFURLMayHaveExtendedAttributesKey: CFStringRef;
4771}
4772extern "C" {
4773pub static kCFURLIsPurgeableKey: CFStringRef;
4775}
4776extern "C" {
4777pub static kCFURLIsSparseKey: CFStringRef;
4779}
4780extern "C" {
4781pub static kCFURLLinkCountKey: CFStringRef;
4783}
4784extern "C" {
4785pub static kCFURLParentDirectoryURLKey: CFStringRef;
4787}
4788extern "C" {
4789pub static kCFURLVolumeURLKey: CFStringRef;
4791}
4792extern "C" {
4793pub static kCFURLTypeIdentifierKey: CFStringRef;
4795}
4796extern "C" {
4797pub static kCFURLLocalizedTypeDescriptionKey: CFStringRef;
4799}
4800extern "C" {
4801pub static kCFURLLabelNumberKey: CFStringRef;
4803}
4804extern "C" {
4805pub static kCFURLLabelColorKey: CFStringRef;
4807}
4808extern "C" {
4809pub static kCFURLLocalizedLabelKey: CFStringRef;
4811}
4812extern "C" {
4813pub static kCFURLEffectiveIconKey: CFStringRef;
4815}
4816extern "C" {
4817pub static kCFURLCustomIconKey: CFStringRef;
4819}
4820extern "C" {
4821pub static kCFURLFileResourceIdentifierKey: CFStringRef;
4823}
4824extern "C" {
4825pub static kCFURLVolumeIdentifierKey: CFStringRef;
4827}
4828extern "C" {
4829pub static kCFURLPreferredIOBlockSizeKey: CFStringRef;
4831}
4832extern "C" {
4833pub static kCFURLIsReadableKey: CFStringRef;
4835}
4836extern "C" {
4837pub static kCFURLIsWritableKey: CFStringRef;
4839}
4840extern "C" {
4841pub static kCFURLIsExecutableKey: CFStringRef;
4843}
4844extern "C" {
4845pub static kCFURLFileSecurityKey: CFStringRef;
4847}
4848extern "C" {
4849pub static kCFURLIsExcludedFromBackupKey: CFStringRef;
4851}
4852extern "C" {
4853pub static kCFURLTagNamesKey: CFStringRef;
4855}
4856extern "C" {
4857pub static kCFURLPathKey: CFStringRef;
4859}
4860extern "C" {
4861pub static kCFURLCanonicalPathKey: CFStringRef;
4863}
4864extern "C" {
4865pub static kCFURLIsMountTriggerKey: CFStringRef;
4867}
4868extern "C" {
4869pub static kCFURLGenerationIdentifierKey: CFStringRef;
4871}
4872extern "C" {
4873pub static kCFURLDocumentIdentifierKey: CFStringRef;
4875}
4876extern "C" {
4877pub static kCFURLAddedToDirectoryDateKey: CFStringRef;
4879}
4880extern "C" {
4881pub static kCFURLQuarantinePropertiesKey: CFStringRef;
4883}
4884extern "C" {
4885pub static kCFURLFileResourceTypeKey: CFStringRef;
4887}
4888extern "C" {
4889pub static kCFURLFileResourceTypeNamedPipe: CFStringRef;
4891}
4892extern "C" {
4893pub static kCFURLFileResourceTypeCharacterSpecial: CFStringRef;
4895}
4896extern "C" {
4897pub static kCFURLFileResourceTypeDirectory: CFStringRef;
4899}
4900extern "C" {
4901pub static kCFURLFileResourceTypeBlockSpecial: CFStringRef;
4903}
4904extern "C" {
4905pub static kCFURLFileResourceTypeRegular: CFStringRef;
4907}
4908extern "C" {
4909pub static kCFURLFileResourceTypeSymbolicLink: CFStringRef;
4911}
4912extern "C" {
4913pub static kCFURLFileResourceTypeSocket: CFStringRef;
4915}
4916extern "C" {
4917pub static kCFURLFileResourceTypeUnknown: CFStringRef;
4919}
4920extern "C" {
4921pub static kCFURLFileSizeKey: CFStringRef;
4923}
4924extern "C" {
4925pub static kCFURLFileAllocatedSizeKey: CFStringRef;
4927}
4928extern "C" {
4929pub static kCFURLTotalFileSizeKey: CFStringRef;
4931}
4932extern "C" {
4933pub static kCFURLTotalFileAllocatedSizeKey: CFStringRef;
4935}
4936extern "C" {
4937pub static kCFURLIsAliasFileKey: CFStringRef;
4939}
4940extern "C" {
4941pub static kCFURLFileProtectionKey: CFStringRef;
4943}
4944extern "C" {
4945pub static kCFURLFileProtectionNone: CFStringRef;
4947}
4948extern "C" {
4949pub static kCFURLFileProtectionComplete: CFStringRef;
4951}
4952extern "C" {
4953pub static kCFURLFileProtectionCompleteUnlessOpen: CFStringRef;
4955}
4956extern "C" {
4957pub static kCFURLFileProtectionCompleteUntilFirstUserAuthentication: CFStringRef;
4959}
4960extern "C" {
4961pub static kCFURLFileProtectionCompleteWhenUserInactive: CFStringRef;
4963}
4964extern "C" {
4965pub static kCFURLDirectoryEntryCountKey: CFStringRef;
4967}
4968extern "C" {
4969pub static kCFURLVolumeLocalizedFormatDescriptionKey: CFStringRef;
4971}
4972extern "C" {
4973pub static kCFURLVolumeTotalCapacityKey: CFStringRef;
4975}
4976extern "C" {
4977pub static kCFURLVolumeAvailableCapacityKey: CFStringRef;
4979}
4980extern "C" {
4981pub static kCFURLVolumeAvailableCapacityForImportantUsageKey: CFStringRef;
4983}
4984extern "C" {
4985pub static kCFURLVolumeAvailableCapacityForOpportunisticUsageKey: CFStringRef;
4987}
4988extern "C" {
4989pub static kCFURLVolumeResourceCountKey: CFStringRef;
4991}
4992extern "C" {
4993pub static kCFURLVolumeSupportsPersistentIDsKey: CFStringRef;
4995}
4996extern "C" {
4997pub static kCFURLVolumeSupportsSymbolicLinksKey: CFStringRef;
4999}
5000extern "C" {
5001pub static kCFURLVolumeSupportsHardLinksKey: CFStringRef;
5003}
5004extern "C" {
5005pub static kCFURLVolumeSupportsJournalingKey: CFStringRef;
5007}
5008extern "C" {
5009pub static kCFURLVolumeIsJournalingKey: CFStringRef;
5011}
5012extern "C" {
5013pub static kCFURLVolumeSupportsSparseFilesKey: CFStringRef;
5015}
5016extern "C" {
5017pub static kCFURLVolumeSupportsZeroRunsKey: CFStringRef;
5019}
5020extern "C" {
5021pub static kCFURLVolumeSupportsCaseSensitiveNamesKey: CFStringRef;
5023}
5024extern "C" {
5025pub static kCFURLVolumeSupportsCasePreservedNamesKey: CFStringRef;
5027}
5028extern "C" {
5029pub static kCFURLVolumeSupportsRootDirectoryDatesKey: CFStringRef;
5031}
5032extern "C" {
5033pub static kCFURLVolumeSupportsVolumeSizesKey: CFStringRef;
5035}
5036extern "C" {
5037pub static kCFURLVolumeSupportsRenamingKey: CFStringRef;
5039}
5040extern "C" {
5041pub static kCFURLVolumeSupportsAdvisoryFileLockingKey: CFStringRef;
5043}
5044extern "C" {
5045pub static kCFURLVolumeSupportsExtendedSecurityKey: CFStringRef;
5047}
5048extern "C" {
5049pub static kCFURLVolumeIsBrowsableKey: CFStringRef;
5051}
5052extern "C" {
5053pub static kCFURLVolumeMaximumFileSizeKey: CFStringRef;
5055}
5056extern "C" {
5057pub static kCFURLVolumeIsEjectableKey: CFStringRef;
5059}
5060extern "C" {
5061pub static kCFURLVolumeIsRemovableKey: CFStringRef;
5063}
5064extern "C" {
5065pub static kCFURLVolumeIsInternalKey: CFStringRef;
5067}
5068extern "C" {
5069pub static kCFURLVolumeIsAutomountedKey: CFStringRef;
5071}
5072extern "C" {
5073pub static kCFURLVolumeIsLocalKey: CFStringRef;
5075}
5076extern "C" {
5077pub static kCFURLVolumeIsReadOnlyKey: CFStringRef;
5079}
5080extern "C" {
5081pub static kCFURLVolumeCreationDateKey: CFStringRef;
5083}
5084extern "C" {
5085pub static kCFURLVolumeURLForRemountingKey: CFStringRef;
5087}
5088extern "C" {
5089pub static kCFURLVolumeUUIDStringKey: CFStringRef;
5091}
5092extern "C" {
5093pub static kCFURLVolumeNameKey: CFStringRef;
5095}
5096extern "C" {
5097pub static kCFURLVolumeLocalizedNameKey: CFStringRef;
5099}
5100extern "C" {
5101pub static kCFURLVolumeIsEncryptedKey: CFStringRef;
5103}
5104extern "C" {
5105pub static kCFURLVolumeIsRootFileSystemKey: CFStringRef;
5107}
5108extern "C" {
5109pub static kCFURLVolumeSupportsCompressionKey: CFStringRef;
5111}
5112extern "C" {
5113pub static kCFURLVolumeSupportsFileCloningKey: CFStringRef;
5115}
5116extern "C" {
5117pub static kCFURLVolumeSupportsSwapRenamingKey: CFStringRef;
5119}
5120extern "C" {
5121pub static kCFURLVolumeSupportsExclusiveRenamingKey: CFStringRef;
5123}
5124extern "C" {
5125pub static kCFURLVolumeSupportsImmutableFilesKey: CFStringRef;
5127}
5128extern "C" {
5129pub static kCFURLVolumeSupportsAccessPermissionsKey: CFStringRef;
5131}
5132extern "C" {
5133pub static kCFURLVolumeSupportsFileProtectionKey: CFStringRef;
5135}
5136extern "C" {
5137pub static kCFURLVolumeTypeNameKey: CFStringRef;
5139}
5140extern "C" {
5141pub static kCFURLVolumeSubtypeKey: CFStringRef;
5143}
5144extern "C" {
5145pub static kCFURLVolumeMountFromLocationKey: CFStringRef;
5147}
5148extern "C" {
5149pub static kCFURLIsUbiquitousItemKey: CFStringRef;
5151}
5152extern "C" {
5153pub static kCFURLUbiquitousItemHasUnresolvedConflictsKey: CFStringRef;
5155}
5156extern "C" {
5157pub static kCFURLUbiquitousItemIsDownloadedKey: CFStringRef;
5159}
5160extern "C" {
5161pub static kCFURLUbiquitousItemIsDownloadingKey: CFStringRef;
5163}
5164extern "C" {
5165pub static kCFURLUbiquitousItemIsUploadedKey: CFStringRef;
5167}
5168extern "C" {
5169pub static kCFURLUbiquitousItemIsUploadingKey: CFStringRef;
5171}
5172extern "C" {
5173pub static kCFURLUbiquitousItemPercentDownloadedKey: CFStringRef;
5175}
5176extern "C" {
5177pub static kCFURLUbiquitousItemPercentUploadedKey: CFStringRef;
5179}
5180extern "C" {
5181pub static kCFURLUbiquitousItemDownloadingStatusKey: CFStringRef;
5183}
5184extern "C" {
5185pub static kCFURLUbiquitousItemDownloadingErrorKey: CFStringRef;
5187}
5188extern "C" {
5189pub static kCFURLUbiquitousItemUploadingErrorKey: CFStringRef;
5191}
5192extern "C" {
5193pub static kCFURLUbiquitousItemIsExcludedFromSyncKey: CFStringRef;
5195}
5196extern "C" {
5197pub static kCFURLUbiquitousItemDownloadingStatusNotDownloaded: CFStringRef;
5199}
5200extern "C" {
5201pub static kCFURLUbiquitousItemDownloadingStatusDownloaded: CFStringRef;
5203}
5204extern "C" {
5205pub static kCFURLUbiquitousItemDownloadingStatusCurrent: CFStringRef;
5207}
5208extern "C" {
5209pub static kCFURLUbiquitousItemSupportedSyncControlsKey: CFStringRef;
5211}
5212extern "C" {
5213pub static kCFURLUbiquitousItemIsSyncPausedKey: CFStringRef;
5215}
5216pub type CFURLBookmarkCreationOptions = CFOptionFlags;
5218pub const kCFURLBookmarkCreationMinimalBookmarkMask: _bindgen_ty_31 = 512;
5220pub const kCFURLBookmarkCreationSuitableForBookmarkFile: _bindgen_ty_31 = 1024;
5222pub const kCFURLBookmarkCreationWithSecurityScope: _bindgen_ty_31 = 2048;
5224pub const kCFURLBookmarkCreationSecurityScopeAllowOnlyReadAccess: _bindgen_ty_31 = 4096;
5226pub const kCFURLBookmarkCreationWithoutImplicitSecurityScope: _bindgen_ty_31 = 536870912;
5228pub const kCFURLBookmarkCreationPreferFileIDResolutionMask: _bindgen_ty_31 = 256;
5230pub type _bindgen_ty_31 = ::core::ffi::c_uint;
5232pub type CFURLBookmarkResolutionOptions = CFOptionFlags;
5234pub const kCFURLBookmarkResolutionWithoutUIMask: _bindgen_ty_32 = 256;
5236pub const kCFURLBookmarkResolutionWithoutMountingMask: _bindgen_ty_32 = 512;
5238pub const kCFURLBookmarkResolutionWithSecurityScope: _bindgen_ty_32 = 1024;
5240pub const kCFURLBookmarkResolutionWithoutImplicitStartAccessing: _bindgen_ty_32 = 32768;
5242pub const kCFBookmarkResolutionWithoutUIMask: _bindgen_ty_32 = 256;
5244pub const kCFBookmarkResolutionWithoutMountingMask: _bindgen_ty_32 = 512;
5246pub type _bindgen_ty_32 = ::core::ffi::c_uint;
5248pub type CFURLBookmarkFileCreationOptions = CFOptionFlags;
5250extern "C" {
5251pub fn CFURLCreateBookmarkData(
5253 allocator: CFAllocatorRef,
5254 url: CFURLRef,
5255 options: CFURLBookmarkCreationOptions,
5256 resourcePropertiesToInclude: CFArrayRef,
5257 relativeToURL: CFURLRef,
5258 error: *mut CFErrorRef,
5259 ) -> CFDataRef;
5260}
5261extern "C" {
5262pub fn CFURLCreateByResolvingBookmarkData(
5264 allocator: CFAllocatorRef,
5265 bookmark: CFDataRef,
5266 options: CFURLBookmarkResolutionOptions,
5267 relativeToURL: CFURLRef,
5268 resourcePropertiesToInclude: CFArrayRef,
5269 isStale: *mut Boolean,
5270 error: *mut CFErrorRef,
5271 ) -> CFURLRef;
5272}
5273extern "C" {
5274pub fn CFURLCreateResourcePropertiesForKeysFromBookmarkData(
5276 allocator: CFAllocatorRef,
5277 resourcePropertiesToReturn: CFArrayRef,
5278 bookmark: CFDataRef,
5279 ) -> CFDictionaryRef;
5280}
5281extern "C" {
5282pub fn CFURLCreateResourcePropertyForKeyFromBookmarkData(
5284 allocator: CFAllocatorRef,
5285 resourcePropertyKey: CFStringRef,
5286 bookmark: CFDataRef,
5287 ) -> CFTypeRef;
5288}
5289extern "C" {
5290pub fn CFURLCreateBookmarkDataFromFile(
5292 allocator: CFAllocatorRef,
5293 fileURL: CFURLRef,
5294 errorRef: *mut CFErrorRef,
5295 ) -> CFDataRef;
5296}
5297extern "C" {
5298pub fn CFURLWriteBookmarkDataToFile(
5300 bookmarkRef: CFDataRef,
5301 fileURL: CFURLRef,
5302 options: CFURLBookmarkFileCreationOptions,
5303 errorRef: *mut CFErrorRef,
5304 ) -> Boolean;
5305}
5306extern "C" {
5307pub fn CFURLCreateBookmarkDataFromAliasRecord(
5309 allocatorRef: CFAllocatorRef,
5310 aliasRecordDataRef: CFDataRef,
5311 ) -> CFDataRef;
5312}
5313extern "C" {
5314pub fn CFURLStartAccessingSecurityScopedResource(url: CFURLRef) -> Boolean;
5316}
5317extern "C" {
5318pub fn CFURLStopAccessingSecurityScopedResource(url: CFURLRef);
5320}
5321pub type integer_t = ::core::ffi::c_int;
5323pub type mach_port_t = __darwin_mach_port_t;
5325pub type CFRunLoopMode = CFStringRef;
5327#[repr(C)]
5328#[derive(Debug, Copy, Clone)]
5329pub struct __CFRunLoop {
5331 _unused: [u8; 0],
5332}
5333pub type CFRunLoopRef = *mut __CFRunLoop;
5335#[repr(C)]
5336#[derive(Debug, Copy, Clone)]
5337pub struct __CFRunLoopSource {
5339 _unused: [u8; 0],
5340}
5341pub type CFRunLoopSourceRef = *mut __CFRunLoopSource;
5343#[repr(C)]
5344#[derive(Debug, Copy, Clone)]
5345pub struct __CFRunLoopObserver {
5347 _unused: [u8; 0],
5348}
5349pub type CFRunLoopObserverRef = *mut __CFRunLoopObserver;
5351#[repr(C)]
5352#[derive(Debug, Copy, Clone)]
5353pub struct __CFRunLoopTimer {
5355 _unused: [u8; 0],
5356}
5357pub type CFRunLoopTimerRef = *mut __CFRunLoopTimer;
5359pub type CFRunLoopRunResult = SInt32;
5361pub const kCFRunLoopRunFinished: _bindgen_ty_33 = 1;
5363pub const kCFRunLoopRunStopped: _bindgen_ty_33 = 2;
5365pub const kCFRunLoopRunTimedOut: _bindgen_ty_33 = 3;
5367pub const kCFRunLoopRunHandledSource: _bindgen_ty_33 = 4;
5369pub type _bindgen_ty_33 = ::core::ffi::c_uint;
5371pub type CFRunLoopActivity = CFOptionFlags;
5373pub const kCFRunLoopEntry: _bindgen_ty_34 = 1;
5375pub const kCFRunLoopBeforeTimers: _bindgen_ty_34 = 2;
5377pub const kCFRunLoopBeforeSources: _bindgen_ty_34 = 4;
5379pub const kCFRunLoopBeforeWaiting: _bindgen_ty_34 = 32;
5381pub const kCFRunLoopAfterWaiting: _bindgen_ty_34 = 64;
5383pub const kCFRunLoopExit: _bindgen_ty_34 = 128;
5385pub const kCFRunLoopAllActivities: _bindgen_ty_34 = 268435455;
5387pub type _bindgen_ty_34 = ::core::ffi::c_uint;
5389extern "C" {
5390pub static kCFRunLoopDefaultMode: CFRunLoopMode;
5392}
5393extern "C" {
5394pub static kCFRunLoopCommonModes: CFRunLoopMode;
5396}
5397extern "C" {
5398pub fn CFRunLoopGetTypeID() -> CFTypeID;
5400}
5401extern "C" {
5402pub fn CFRunLoopGetCurrent() -> CFRunLoopRef;
5404}
5405extern "C" {
5406pub fn CFRunLoopGetMain() -> CFRunLoopRef;
5408}
5409extern "C" {
5410pub fn CFRunLoopCopyCurrentMode(rl: CFRunLoopRef) -> CFRunLoopMode;
5412}
5413extern "C" {
5414pub fn CFRunLoopCopyAllModes(rl: CFRunLoopRef) -> CFArrayRef;
5416}
5417extern "C" {
5418pub fn CFRunLoopAddCommonMode(rl: CFRunLoopRef, mode: CFRunLoopMode);
5420}
5421extern "C" {
5422pub fn CFRunLoopGetNextTimerFireDate(rl: CFRunLoopRef, mode: CFRunLoopMode) -> CFAbsoluteTime;
5424}
5425extern "C" {
5426pub fn CFRunLoopRun();
5428}
5429extern "C" {
5430pub fn CFRunLoopRunInMode(
5432 mode: CFRunLoopMode,
5433 seconds: CFTimeInterval,
5434 returnAfterSourceHandled: Boolean,
5435 ) -> CFRunLoopRunResult;
5436}
5437extern "C" {
5438pub fn CFRunLoopIsWaiting(rl: CFRunLoopRef) -> Boolean;
5440}
5441extern "C" {
5442pub fn CFRunLoopWakeUp(rl: CFRunLoopRef);
5444}
5445extern "C" {
5446pub fn CFRunLoopStop(rl: CFRunLoopRef);
5448}
5449extern "C" {
5450pub fn CFRunLoopPerformBlock(
5452 rl: CFRunLoopRef,
5453 mode: CFTypeRef,
5454 block: *mut ::core::ffi::c_void,
5455 );
5456}
5457extern "C" {
5458pub fn CFRunLoopContainsSource(
5460 rl: CFRunLoopRef,
5461 source: CFRunLoopSourceRef,
5462 mode: CFRunLoopMode,
5463 ) -> Boolean;
5464}
5465extern "C" {
5466pub fn CFRunLoopAddSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFRunLoopMode);
5468}
5469extern "C" {
5470pub fn CFRunLoopRemoveSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFRunLoopMode);
5472}
5473extern "C" {
5474pub fn CFRunLoopContainsObserver(
5476 rl: CFRunLoopRef,
5477 observer: CFRunLoopObserverRef,
5478 mode: CFRunLoopMode,
5479 ) -> Boolean;
5480}
5481extern "C" {
5482pub fn CFRunLoopAddObserver(
5484 rl: CFRunLoopRef,
5485 observer: CFRunLoopObserverRef,
5486 mode: CFRunLoopMode,
5487 );
5488}
5489extern "C" {
5490pub fn CFRunLoopRemoveObserver(
5492 rl: CFRunLoopRef,
5493 observer: CFRunLoopObserverRef,
5494 mode: CFRunLoopMode,
5495 );
5496}
5497extern "C" {
5498pub fn CFRunLoopContainsTimer(
5500 rl: CFRunLoopRef,
5501 timer: CFRunLoopTimerRef,
5502 mode: CFRunLoopMode,
5503 ) -> Boolean;
5504}
5505extern "C" {
5506pub fn CFRunLoopAddTimer(rl: CFRunLoopRef, timer: CFRunLoopTimerRef, mode: CFRunLoopMode);
5508}
5509extern "C" {
5510pub fn CFRunLoopRemoveTimer(rl: CFRunLoopRef, timer: CFRunLoopTimerRef, mode: CFRunLoopMode);
5512}
5513#[repr(C)]
5514#[derive(Debug, Copy, Clone)]
5515pub struct CFRunLoopSourceContext {
5517 pub version: CFIndex,
5518 pub info: *mut ::core::ffi::c_void,
5519 pub retain: ::core::option::Option<
5520 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> *const ::core::ffi::c_void,
5521 >,
5522 pub release: ::core::option::Option<unsafe extern "C" fn(info: *const ::core::ffi::c_void)>,
5523 pub copyDescription: ::core::option::Option<
5524 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> CFStringRef,
5525 >,
5526 pub equal: ::core::option::Option<
5527 unsafe extern "C" fn(
5528 info1: *const ::core::ffi::c_void,
5529 info2: *const ::core::ffi::c_void,
5530 ) -> Boolean,
5531 >,
5532 pub hash: ::core::option::Option<
5533 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> CFHashCode,
5534 >,
5535 pub schedule: ::core::option::Option<
5536 unsafe extern "C" fn(info: *mut ::core::ffi::c_void, rl: CFRunLoopRef, mode: CFRunLoopMode),
5537 >,
5538 pub cancel: ::core::option::Option<
5539 unsafe extern "C" fn(info: *mut ::core::ffi::c_void, rl: CFRunLoopRef, mode: CFRunLoopMode),
5540 >,
5541 pub perform: ::core::option::Option<unsafe extern "C" fn(info: *mut ::core::ffi::c_void)>,
5542}
5543#[repr(C)]
5544#[derive(Debug, Copy, Clone)]
5545pub struct CFRunLoopSourceContext1 {
5547 pub version: CFIndex,
5548 pub info: *mut ::core::ffi::c_void,
5549 pub retain: ::core::option::Option<
5550 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> *const ::core::ffi::c_void,
5551 >,
5552 pub release: ::core::option::Option<unsafe extern "C" fn(info: *const ::core::ffi::c_void)>,
5553 pub copyDescription: ::core::option::Option<
5554 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> CFStringRef,
5555 >,
5556 pub equal: ::core::option::Option<
5557 unsafe extern "C" fn(
5558 info1: *const ::core::ffi::c_void,
5559 info2: *const ::core::ffi::c_void,
5560 ) -> Boolean,
5561 >,
5562 pub hash: ::core::option::Option<
5563 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> CFHashCode,
5564 >,
5565 pub getPort:
5566 ::core::option::Option<unsafe extern "C" fn(info: *mut ::core::ffi::c_void) -> mach_port_t>,
5567 pub perform: ::core::option::Option<
5568 unsafe extern "C" fn(
5569 msg: *mut ::core::ffi::c_void,
5570 size: CFIndex,
5571 allocator: CFAllocatorRef,
5572 info: *mut ::core::ffi::c_void,
5573 ) -> *mut ::core::ffi::c_void,
5574 >,
5575}
5576extern "C" {
5577pub fn CFRunLoopSourceGetTypeID() -> CFTypeID;
5579}
5580extern "C" {
5581pub fn CFRunLoopSourceCreate(
5583 allocator: CFAllocatorRef,
5584 order: CFIndex,
5585 context: *mut CFRunLoopSourceContext,
5586 ) -> CFRunLoopSourceRef;
5587}
5588extern "C" {
5589pub fn CFRunLoopSourceGetOrder(source: CFRunLoopSourceRef) -> CFIndex;
5591}
5592extern "C" {
5593pub fn CFRunLoopSourceInvalidate(source: CFRunLoopSourceRef);
5595}
5596extern "C" {
5597pub fn CFRunLoopSourceIsValid(source: CFRunLoopSourceRef) -> Boolean;
5599}
5600extern "C" {
5601pub fn CFRunLoopSourceGetContext(
5603 source: CFRunLoopSourceRef,
5604 context: *mut CFRunLoopSourceContext,
5605 );
5606}
5607extern "C" {
5608pub fn CFRunLoopSourceSignal(source: CFRunLoopSourceRef);
5610}
5611#[repr(C)]
5612#[derive(Debug, Copy, Clone)]
5613pub struct CFRunLoopObserverContext {
5615 pub version: CFIndex,
5616 pub info: *mut ::core::ffi::c_void,
5617 pub retain: ::core::option::Option<
5618 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> *const ::core::ffi::c_void,
5619 >,
5620 pub release: ::core::option::Option<unsafe extern "C" fn(info: *const ::core::ffi::c_void)>,
5621 pub copyDescription: ::core::option::Option<
5622 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> CFStringRef,
5623 >,
5624}
5625pub type CFRunLoopObserverCallBack = ::core::option::Option<
5627 unsafe extern "C" fn(
5628 observer: CFRunLoopObserverRef,
5629 activity: CFRunLoopActivity,
5630 info: *mut ::core::ffi::c_void,
5631 ),
5632>;
5633extern "C" {
5634pub fn CFRunLoopObserverGetTypeID() -> CFTypeID;
5636}
5637extern "C" {
5638pub fn CFRunLoopObserverCreate(
5640 allocator: CFAllocatorRef,
5641 activities: CFOptionFlags,
5642 repeats: Boolean,
5643 order: CFIndex,
5644 callout: CFRunLoopObserverCallBack,
5645 context: *mut CFRunLoopObserverContext,
5646 ) -> CFRunLoopObserverRef;
5647}
5648extern "C" {
5649pub fn CFRunLoopObserverCreateWithHandler(
5651 allocator: CFAllocatorRef,
5652 activities: CFOptionFlags,
5653 repeats: Boolean,
5654 order: CFIndex,
5655 block: *mut ::core::ffi::c_void,
5656 ) -> CFRunLoopObserverRef;
5657}
5658extern "C" {
5659pub fn CFRunLoopObserverGetActivities(observer: CFRunLoopObserverRef) -> CFOptionFlags;
5661}
5662extern "C" {
5663pub fn CFRunLoopObserverDoesRepeat(observer: CFRunLoopObserverRef) -> Boolean;
5665}
5666extern "C" {
5667pub fn CFRunLoopObserverGetOrder(observer: CFRunLoopObserverRef) -> CFIndex;
5669}
5670extern "C" {
5671pub fn CFRunLoopObserverInvalidate(observer: CFRunLoopObserverRef);
5673}
5674extern "C" {
5675pub fn CFRunLoopObserverIsValid(observer: CFRunLoopObserverRef) -> Boolean;
5677}
5678extern "C" {
5679pub fn CFRunLoopObserverGetContext(
5681 observer: CFRunLoopObserverRef,
5682 context: *mut CFRunLoopObserverContext,
5683 );
5684}
5685#[repr(C)]
5686#[derive(Debug, Copy, Clone)]
5687pub struct CFRunLoopTimerContext {
5689 pub version: CFIndex,
5690 pub info: *mut ::core::ffi::c_void,
5691 pub retain: ::core::option::Option<
5692 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> *const ::core::ffi::c_void,
5693 >,
5694 pub release: ::core::option::Option<unsafe extern "C" fn(info: *const ::core::ffi::c_void)>,
5695 pub copyDescription: ::core::option::Option<
5696 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> CFStringRef,
5697 >,
5698}
5699pub type CFRunLoopTimerCallBack = ::core::option::Option<
5701 unsafe extern "C" fn(timer: CFRunLoopTimerRef, info: *mut ::core::ffi::c_void),
5702>;
5703extern "C" {
5704pub fn CFRunLoopTimerGetTypeID() -> CFTypeID;
5706}
5707extern "C" {
5708pub fn CFRunLoopTimerCreate(
5710 allocator: CFAllocatorRef,
5711 fireDate: CFAbsoluteTime,
5712 interval: CFTimeInterval,
5713 flags: CFOptionFlags,
5714 order: CFIndex,
5715 callout: CFRunLoopTimerCallBack,
5716 context: *mut CFRunLoopTimerContext,
5717 ) -> CFRunLoopTimerRef;
5718}
5719extern "C" {
5720pub fn CFRunLoopTimerCreateWithHandler(
5722 allocator: CFAllocatorRef,
5723 fireDate: CFAbsoluteTime,
5724 interval: CFTimeInterval,
5725 flags: CFOptionFlags,
5726 order: CFIndex,
5727 block: *mut ::core::ffi::c_void,
5728 ) -> CFRunLoopTimerRef;
5729}
5730extern "C" {
5731pub fn CFRunLoopTimerGetNextFireDate(timer: CFRunLoopTimerRef) -> CFAbsoluteTime;
5733}
5734extern "C" {
5735pub fn CFRunLoopTimerSetNextFireDate(timer: CFRunLoopTimerRef, fireDate: CFAbsoluteTime);
5737}
5738extern "C" {
5739pub fn CFRunLoopTimerGetInterval(timer: CFRunLoopTimerRef) -> CFTimeInterval;
5741}
5742extern "C" {
5743pub fn CFRunLoopTimerDoesRepeat(timer: CFRunLoopTimerRef) -> Boolean;
5745}
5746extern "C" {
5747pub fn CFRunLoopTimerGetOrder(timer: CFRunLoopTimerRef) -> CFIndex;
5749}
5750extern "C" {
5751pub fn CFRunLoopTimerInvalidate(timer: CFRunLoopTimerRef);
5753}
5754extern "C" {
5755pub fn CFRunLoopTimerIsValid(timer: CFRunLoopTimerRef) -> Boolean;
5757}
5758extern "C" {
5759pub fn CFRunLoopTimerGetContext(timer: CFRunLoopTimerRef, context: *mut CFRunLoopTimerContext);
5761}
5762extern "C" {
5763pub fn CFRunLoopTimerGetTolerance(timer: CFRunLoopTimerRef) -> CFTimeInterval;
5765}
5766extern "C" {
5767pub fn CFRunLoopTimerSetTolerance(timer: CFRunLoopTimerRef, tolerance: CFTimeInterval);
5769}
5770#[repr(C)]
5771#[derive(Debug, Copy, Clone)]
5772pub struct __CFSocket {
5774 _unused: [u8; 0],
5775}
5776pub type CFSocketRef = *mut __CFSocket;
5778pub type CFSocketError = CFIndex;
5780pub const kCFSocketSuccess: _bindgen_ty_35 = 0;
5782pub const kCFSocketError: _bindgen_ty_35 = -1;
5784pub const kCFSocketTimeout: _bindgen_ty_35 = -2;
5786pub type _bindgen_ty_35 = ::core::ffi::c_int;
5788#[repr(C)]
5789#[derive(Debug, Copy, Clone)]
5790pub struct CFSocketSignature {
5792 pub protocolFamily: SInt32,
5793 pub socketType: SInt32,
5794 pub protocol: SInt32,
5795 pub address: CFDataRef,
5796}
5797pub type CFSocketCallBackType = CFOptionFlags;
5799pub const kCFSocketNoCallBack: _bindgen_ty_36 = 0;
5801pub const kCFSocketReadCallBack: _bindgen_ty_36 = 1;
5803pub const kCFSocketAcceptCallBack: _bindgen_ty_36 = 2;
5805pub const kCFSocketDataCallBack: _bindgen_ty_36 = 3;
5807pub const kCFSocketConnectCallBack: _bindgen_ty_36 = 4;
5809pub const kCFSocketWriteCallBack: _bindgen_ty_36 = 8;
5811pub type _bindgen_ty_36 = ::core::ffi::c_uint;
5813pub const kCFSocketAutomaticallyReenableReadCallBack: _bindgen_ty_37 = 1;
5815pub const kCFSocketAutomaticallyReenableAcceptCallBack: _bindgen_ty_37 = 2;
5817pub const kCFSocketAutomaticallyReenableDataCallBack: _bindgen_ty_37 = 3;
5819pub const kCFSocketAutomaticallyReenableWriteCallBack: _bindgen_ty_37 = 8;
5821pub const kCFSocketLeaveErrors: _bindgen_ty_37 = 64;
5823pub const kCFSocketCloseOnInvalidate: _bindgen_ty_37 = 128;
5825pub type _bindgen_ty_37 = ::core::ffi::c_uint;
5827pub type CFSocketCallBack = ::core::option::Option<
5829 unsafe extern "C" fn(
5830 s: CFSocketRef,
5831 type_: CFSocketCallBackType,
5832 address: CFDataRef,
5833 data: *const ::core::ffi::c_void,
5834 info: *mut ::core::ffi::c_void,
5835 ),
5836>;
5837#[repr(C)]
5838#[derive(Debug, Copy, Clone)]
5839pub struct CFSocketContext {
5841 pub version: CFIndex,
5842 pub info: *mut ::core::ffi::c_void,
5843 pub retain: ::core::option::Option<
5844 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> *const ::core::ffi::c_void,
5845 >,
5846 pub release: ::core::option::Option<unsafe extern "C" fn(info: *const ::core::ffi::c_void)>,
5847 pub copyDescription: ::core::option::Option<
5848 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> CFStringRef,
5849 >,
5850}
5851pub type CFSocketNativeHandle = ::core::ffi::c_int;
5853extern "C" {
5854pub fn CFSocketGetTypeID() -> CFTypeID;
5856}
5857extern "C" {
5858pub fn CFSocketCreate(
5860 allocator: CFAllocatorRef,
5861 protocolFamily: SInt32,
5862 socketType: SInt32,
5863 protocol: SInt32,
5864 callBackTypes: CFOptionFlags,
5865 callout: CFSocketCallBack,
5866 context: *const CFSocketContext,
5867 ) -> CFSocketRef;
5868}
5869extern "C" {
5870pub fn CFSocketCreateWithNative(
5872 allocator: CFAllocatorRef,
5873 sock: CFSocketNativeHandle,
5874 callBackTypes: CFOptionFlags,
5875 callout: CFSocketCallBack,
5876 context: *const CFSocketContext,
5877 ) -> CFSocketRef;
5878}
5879extern "C" {
5880pub fn CFSocketCreateWithSocketSignature(
5882 allocator: CFAllocatorRef,
5883 signature: *const CFSocketSignature,
5884 callBackTypes: CFOptionFlags,
5885 callout: CFSocketCallBack,
5886 context: *const CFSocketContext,
5887 ) -> CFSocketRef;
5888}
5889extern "C" {
5890pub fn CFSocketCreateConnectedToSocketSignature(
5892 allocator: CFAllocatorRef,
5893 signature: *const CFSocketSignature,
5894 callBackTypes: CFOptionFlags,
5895 callout: CFSocketCallBack,
5896 context: *const CFSocketContext,
5897 timeout: CFTimeInterval,
5898 ) -> CFSocketRef;
5899}
5900extern "C" {
5901pub fn CFSocketSetAddress(s: CFSocketRef, address: CFDataRef) -> CFSocketError;
5903}
5904extern "C" {
5905pub fn CFSocketConnectToAddress(
5907 s: CFSocketRef,
5908 address: CFDataRef,
5909 timeout: CFTimeInterval,
5910 ) -> CFSocketError;
5911}
5912extern "C" {
5913pub fn CFSocketInvalidate(s: CFSocketRef);
5915}
5916extern "C" {
5917pub fn CFSocketIsValid(s: CFSocketRef) -> Boolean;
5919}
5920extern "C" {
5921pub fn CFSocketCopyAddress(s: CFSocketRef) -> CFDataRef;
5923}
5924extern "C" {
5925pub fn CFSocketCopyPeerAddress(s: CFSocketRef) -> CFDataRef;
5927}
5928extern "C" {
5929pub fn CFSocketGetContext(s: CFSocketRef, context: *mut CFSocketContext);
5931}
5932extern "C" {
5933pub fn CFSocketGetNative(s: CFSocketRef) -> CFSocketNativeHandle;
5935}
5936extern "C" {
5937pub fn CFSocketCreateRunLoopSource(
5939 allocator: CFAllocatorRef,
5940 s: CFSocketRef,
5941 order: CFIndex,
5942 ) -> CFRunLoopSourceRef;
5943}
5944extern "C" {
5945pub fn CFSocketGetSocketFlags(s: CFSocketRef) -> CFOptionFlags;
5947}
5948extern "C" {
5949pub fn CFSocketSetSocketFlags(s: CFSocketRef, flags: CFOptionFlags);
5951}
5952extern "C" {
5953pub fn CFSocketDisableCallBacks(s: CFSocketRef, callBackTypes: CFOptionFlags);
5955}
5956extern "C" {
5957pub fn CFSocketEnableCallBacks(s: CFSocketRef, callBackTypes: CFOptionFlags);
5959}
5960extern "C" {
5961pub fn CFSocketSendData(
5963 s: CFSocketRef,
5964 address: CFDataRef,
5965 data: CFDataRef,
5966 timeout: CFTimeInterval,
5967 ) -> CFSocketError;
5968}
5969extern "C" {
5970pub fn CFSocketRegisterValue(
5972 nameServerSignature: *const CFSocketSignature,
5973 timeout: CFTimeInterval,
5974 name: CFStringRef,
5975 value: CFPropertyListRef,
5976 ) -> CFSocketError;
5977}
5978extern "C" {
5979pub fn CFSocketCopyRegisteredValue(
5981 nameServerSignature: *const CFSocketSignature,
5982 timeout: CFTimeInterval,
5983 name: CFStringRef,
5984 value: *mut CFPropertyListRef,
5985 nameServerAddress: *mut CFDataRef,
5986 ) -> CFSocketError;
5987}
5988extern "C" {
5989pub fn CFSocketRegisterSocketSignature(
5991 nameServerSignature: *const CFSocketSignature,
5992 timeout: CFTimeInterval,
5993 name: CFStringRef,
5994 signature: *const CFSocketSignature,
5995 ) -> CFSocketError;
5996}
5997extern "C" {
5998pub fn CFSocketCopyRegisteredSocketSignature(
6000 nameServerSignature: *const CFSocketSignature,
6001 timeout: CFTimeInterval,
6002 name: CFStringRef,
6003 signature: *mut CFSocketSignature,
6004 nameServerAddress: *mut CFDataRef,
6005 ) -> CFSocketError;
6006}
6007extern "C" {
6008pub fn CFSocketUnregister(
6010 nameServerSignature: *const CFSocketSignature,
6011 timeout: CFTimeInterval,
6012 name: CFStringRef,
6013 ) -> CFSocketError;
6014}
6015extern "C" {
6016pub fn CFSocketSetDefaultNameRegistryPortNumber(port: UInt16);
6018}
6019extern "C" {
6020pub fn CFSocketGetDefaultNameRegistryPortNumber() -> UInt16;
6022}
6023extern "C" {
6024pub static kCFSocketCommandKey: CFStringRef;
6026}
6027extern "C" {
6028pub static kCFSocketNameKey: CFStringRef;
6030}
6031extern "C" {
6032pub static kCFSocketValueKey: CFStringRef;
6034}
6035extern "C" {
6036pub static kCFSocketResultKey: CFStringRef;
6038}
6039extern "C" {
6040pub static kCFSocketErrorKey: CFStringRef;
6042}
6043extern "C" {
6044pub static kCFSocketRegisterCommand: CFStringRef;
6046}
6047extern "C" {
6048pub static kCFSocketRetrieveCommand: CFStringRef;
6050}
6051#[repr(C)]
6052#[derive(Debug, Copy, Clone)]
6053pub struct os_workgroup_s {
6055 _unused: [u8; 0],
6056}
6057pub type os_workgroup_t = *mut os_workgroup_s;
6059pub type dispatch_function_t =
6061 ::core::option::Option<unsafe extern "C" fn(arg1: *mut ::core::ffi::c_void)>;
6062pub type dispatch_time_t = u64;
6064pub const DISPATCH_WALLTIME_NOW: _bindgen_ty_1801 = 18446744073709551614;
6066pub type _bindgen_ty_1801 = ::core::ffi::c_ulong;
6068extern "C" {
6069pub fn dispatch_time(when: dispatch_time_t, delta: i64) -> dispatch_time_t;
6071}
6072extern "C" {
6073pub fn dispatch_walltime(when: *const timespec, delta: i64) -> dispatch_time_t;
6075}
6076pub type qos_class_t = ::core::ffi::c_uint;
6078#[repr(C)]
6079#[derive(Copy, Clone)]
6080pub union dispatch_object_t {
6081 pub _os_obj: *mut _os_object_s,
6082 pub _do: *mut dispatch_object_s,
6083 pub _dq: *mut dispatch_queue_s,
6084 pub _dqa: *mut dispatch_queue_attr_s,
6085 pub _dg: *mut dispatch_group_s,
6086 pub _ds: *mut dispatch_source_s,
6087 pub _dch: *mut dispatch_channel_s,
6088 pub _dm: *mut dispatch_mach_s,
6089 pub _dmsg: *mut dispatch_mach_msg_s,
6090 pub _dsema: *mut dispatch_semaphore_s,
6091 pub _ddata: *mut dispatch_data_s,
6092 pub _dchannel: *mut dispatch_io_s,
6093}
6094pub type dispatch_block_t = *mut ::core::ffi::c_void;
6096pub type dispatch_qos_class_t = qos_class_t;
6098extern "C" {
6099pub fn dispatch_retain(object: dispatch_object_t);
6101}
6102extern "C" {
6103pub fn dispatch_release(object: dispatch_object_t);
6105}
6106extern "C" {
6107pub fn dispatch_get_context(object: dispatch_object_t) -> *mut ::core::ffi::c_void;
6109}
6110extern "C" {
6111pub fn dispatch_set_context(object: dispatch_object_t, context: *mut ::core::ffi::c_void);
6113}
6114extern "C" {
6115pub fn dispatch_set_finalizer_f(object: dispatch_object_t, finalizer: dispatch_function_t);
6117}
6118extern "C" {
6119pub fn dispatch_activate(object: dispatch_object_t);
6121}
6122extern "C" {
6123pub fn dispatch_suspend(object: dispatch_object_t);
6125}
6126extern "C" {
6127pub fn dispatch_resume(object: dispatch_object_t);
6129}
6130extern "C" {
6131pub fn dispatch_set_qos_class_floor(
6133 object: dispatch_object_t,
6134 qos_class: dispatch_qos_class_t,
6135 relative_priority: ::core::ffi::c_int,
6136 );
6137}
6138extern "C" {
6139pub fn dispatch_wait(object: *mut ::core::ffi::c_void, timeout: dispatch_time_t) -> isize;
6141}
6142extern "C" {
6143pub fn dispatch_notify(
6145 object: *mut ::core::ffi::c_void,
6146 queue: dispatch_object_t,
6147 notification_block: dispatch_block_t,
6148 );
6149}
6150extern "C" {
6151pub fn dispatch_cancel(object: *mut ::core::ffi::c_void);
6153}
6154extern "C" {
6155pub fn dispatch_testcancel(object: *mut ::core::ffi::c_void) -> isize;
6157}
6158extern "C" {
6159pub fn dispatch_debug(object: dispatch_object_t, message: *const ::core::ffi::c_char, ...);
6161}
6162extern "C" {
6163pub fn dispatch_debugv(
6165 object: dispatch_object_t,
6166 message: *const ::core::ffi::c_char,
6167 ap: va_list,
6168 );
6169}
6170pub type dispatch_queue_t = *mut dispatch_queue_s;
6172pub type dispatch_queue_global_t = dispatch_queue_t;
6174pub type dispatch_queue_serial_executor_t = dispatch_queue_t;
6176pub type dispatch_queue_serial_t = dispatch_queue_t;
6178pub type dispatch_queue_main_t = dispatch_queue_serial_t;
6180pub type dispatch_queue_concurrent_t = dispatch_queue_t;
6182extern "C" {
6183pub fn dispatch_async(queue: dispatch_queue_t, block: dispatch_block_t);
6185}
6186extern "C" {
6187pub fn dispatch_async_f(
6189 queue: dispatch_queue_t,
6190 context: *mut ::core::ffi::c_void,
6191 work: dispatch_function_t,
6192 );
6193}
6194extern "C" {
6195pub fn dispatch_sync(queue: dispatch_queue_t, block: dispatch_block_t);
6197}
6198extern "C" {
6199pub fn dispatch_sync_f(
6201 queue: dispatch_queue_t,
6202 context: *mut ::core::ffi::c_void,
6203 work: dispatch_function_t,
6204 );
6205}
6206extern "C" {
6207pub fn dispatch_async_and_wait(queue: dispatch_queue_t, block: dispatch_block_t);
6209}
6210extern "C" {
6211pub fn dispatch_async_and_wait_f(
6213 queue: dispatch_queue_t,
6214 context: *mut ::core::ffi::c_void,
6215 work: dispatch_function_t,
6216 );
6217}
6218extern "C" {
6219pub fn dispatch_apply(
6221 iterations: usize,
6222 queue: dispatch_queue_t,
6223 block: *mut ::core::ffi::c_void,
6224 );
6225}
6226extern "C" {
6227pub fn dispatch_apply_f(
6229 iterations: usize,
6230 queue: dispatch_queue_t,
6231 context: *mut ::core::ffi::c_void,
6232 work: ::core::option::Option<
6233 unsafe extern "C" fn(context: *mut ::core::ffi::c_void, iteration: usize),
6234 >,
6235 );
6236}
6237extern "C" {
6238pub fn dispatch_get_current_queue() -> dispatch_queue_t;
6240}
6241#[repr(C)]
6242#[derive(Debug, Copy, Clone)]
6243pub struct dispatch_queue_s {
6245 pub _address: u8,
6246}
6247extern "C" {
6248pub static mut _dispatch_main_q: dispatch_queue_s;
6250}
6251pub type dispatch_queue_priority_t = ::core::ffi::c_long;
6253extern "C" {
6254pub fn dispatch_get_global_queue(identifier: isize, flags: usize) -> dispatch_queue_global_t;
6256}
6257pub type dispatch_queue_attr_t = *mut dispatch_queue_attr_s;
6259#[repr(C)]
6260#[derive(Debug, Copy, Clone)]
6261pub struct dispatch_queue_attr_s {
6263 pub _address: u8,
6264}
6265extern "C" {
6266pub static mut _dispatch_queue_attr_concurrent: dispatch_queue_attr_s;
6268}
6269extern "C" {
6270pub fn dispatch_queue_attr_make_initially_inactive(
6272 attr: dispatch_queue_attr_t,
6273 ) -> dispatch_queue_attr_t;
6274}
6275pub const dispatch_autorelease_frequency_t_DISPATCH_AUTORELEASE_FREQUENCY_INHERIT:
6277 dispatch_autorelease_frequency_t = 0;
6278pub const dispatch_autorelease_frequency_t_DISPATCH_AUTORELEASE_FREQUENCY_WORK_ITEM:
6280 dispatch_autorelease_frequency_t = 1;
6281pub const dispatch_autorelease_frequency_t_DISPATCH_AUTORELEASE_FREQUENCY_NEVER:
6283 dispatch_autorelease_frequency_t = 2;
6284pub type dispatch_autorelease_frequency_t = ::core::ffi::c_ulong;
6286extern "C" {
6287pub fn dispatch_queue_attr_make_with_autorelease_frequency(
6289 attr: dispatch_queue_attr_t,
6290 frequency: dispatch_autorelease_frequency_t,
6291 ) -> dispatch_queue_attr_t;
6292}
6293extern "C" {
6294pub fn dispatch_queue_attr_make_with_qos_class(
6296 attr: dispatch_queue_attr_t,
6297 qos_class: dispatch_qos_class_t,
6298 relative_priority: ::core::ffi::c_int,
6299 ) -> dispatch_queue_attr_t;
6300}
6301extern "C" {
6302 #[link_name = "\u{1}_dispatch_queue_create_with_target$V2"]
6303pub fn dispatch_queue_create_with_target(
6305 label: *const ::core::ffi::c_char,
6306 attr: dispatch_queue_attr_t,
6307 target: dispatch_queue_t,
6308 ) -> dispatch_queue_t;
6309}
6310extern "C" {
6311pub fn dispatch_queue_create(
6313 label: *const ::core::ffi::c_char,
6314 attr: dispatch_queue_attr_t,
6315 ) -> dispatch_queue_t;
6316}
6317extern "C" {
6318pub fn dispatch_queue_get_label(queue: dispatch_queue_t) -> *const ::core::ffi::c_char;
6320}
6321extern "C" {
6322pub fn dispatch_queue_get_qos_class(
6324 queue: dispatch_queue_t,
6325 relative_priority_ptr: *mut ::core::ffi::c_int,
6326 ) -> dispatch_qos_class_t;
6327}
6328extern "C" {
6329pub fn dispatch_set_target_queue(object: dispatch_object_t, queue: dispatch_queue_t);
6331}
6332extern "C" {
6333pub fn dispatch_main() -> !;
6335}
6336extern "C" {
6337pub fn dispatch_after(when: dispatch_time_t, queue: dispatch_queue_t, block: dispatch_block_t);
6339}
6340extern "C" {
6341pub fn dispatch_after_f(
6343 when: dispatch_time_t,
6344 queue: dispatch_queue_t,
6345 context: *mut ::core::ffi::c_void,
6346 work: dispatch_function_t,
6347 );
6348}
6349extern "C" {
6350pub fn dispatch_barrier_async(queue: dispatch_queue_t, block: dispatch_block_t);
6352}
6353extern "C" {
6354pub fn dispatch_barrier_async_f(
6356 queue: dispatch_queue_t,
6357 context: *mut ::core::ffi::c_void,
6358 work: dispatch_function_t,
6359 );
6360}
6361extern "C" {
6362pub fn dispatch_barrier_sync(queue: dispatch_queue_t, block: dispatch_block_t);
6364}
6365extern "C" {
6366pub fn dispatch_barrier_sync_f(
6368 queue: dispatch_queue_t,
6369 context: *mut ::core::ffi::c_void,
6370 work: dispatch_function_t,
6371 );
6372}
6373extern "C" {
6374pub fn dispatch_barrier_async_and_wait(queue: dispatch_queue_t, block: dispatch_block_t);
6376}
6377extern "C" {
6378pub fn dispatch_barrier_async_and_wait_f(
6380 queue: dispatch_queue_t,
6381 context: *mut ::core::ffi::c_void,
6382 work: dispatch_function_t,
6383 );
6384}
6385extern "C" {
6386pub fn dispatch_queue_set_specific(
6388 queue: dispatch_queue_t,
6389 key: *const ::core::ffi::c_void,
6390 context: *mut ::core::ffi::c_void,
6391 destructor: dispatch_function_t,
6392 );
6393}
6394extern "C" {
6395pub fn dispatch_queue_get_specific(
6397 queue: dispatch_queue_t,
6398 key: *const ::core::ffi::c_void,
6399 ) -> *mut ::core::ffi::c_void;
6400}
6401extern "C" {
6402pub fn dispatch_get_specific(key: *const ::core::ffi::c_void) -> *mut ::core::ffi::c_void;
6404}
6405extern "C" {
6406 #[link_name = "\u{1}_dispatch_assert_queue$V2"]
6407pub fn dispatch_assert_queue(queue: dispatch_queue_t);
6409}
6410extern "C" {
6411pub fn dispatch_assert_queue_barrier(queue: dispatch_queue_t);
6413}
6414extern "C" {
6415 #[link_name = "\u{1}_dispatch_assert_queue_not$V2"]
6416pub fn dispatch_assert_queue_not(queue: dispatch_queue_t);
6418}
6419extern "C" {
6420pub fn dispatch_allow_send_signals(preserve_signum: ::core::ffi::c_int) -> ::core::ffi::c_int;
6422}
6423pub const dispatch_block_flags_t_DISPATCH_BLOCK_BARRIER: dispatch_block_flags_t = 1;
6425pub const dispatch_block_flags_t_DISPATCH_BLOCK_DETACHED: dispatch_block_flags_t = 2;
6427pub const dispatch_block_flags_t_DISPATCH_BLOCK_ASSIGN_CURRENT: dispatch_block_flags_t = 4;
6429pub const dispatch_block_flags_t_DISPATCH_BLOCK_NO_QOS_CLASS: dispatch_block_flags_t = 8;
6431pub const dispatch_block_flags_t_DISPATCH_BLOCK_INHERIT_QOS_CLASS: dispatch_block_flags_t = 16;
6433pub const dispatch_block_flags_t_DISPATCH_BLOCK_ENFORCE_QOS_CLASS: dispatch_block_flags_t = 32;
6435pub type dispatch_block_flags_t = ::core::ffi::c_ulong;
6437extern "C" {
6438pub fn dispatch_block_create(
6440 flags: dispatch_block_flags_t,
6441 block: dispatch_block_t,
6442 ) -> dispatch_block_t;
6443}
6444extern "C" {
6445pub fn dispatch_block_create_with_qos_class(
6447 flags: dispatch_block_flags_t,
6448 qos_class: dispatch_qos_class_t,
6449 relative_priority: ::core::ffi::c_int,
6450 block: dispatch_block_t,
6451 ) -> dispatch_block_t;
6452}
6453extern "C" {
6454pub fn dispatch_block_perform(flags: dispatch_block_flags_t, block: dispatch_block_t);
6456}
6457extern "C" {
6458pub fn dispatch_block_wait(block: dispatch_block_t, timeout: dispatch_time_t) -> isize;
6460}
6461extern "C" {
6462pub fn dispatch_block_notify(
6464 block: dispatch_block_t,
6465 queue: dispatch_queue_t,
6466 notification_block: dispatch_block_t,
6467 );
6468}
6469extern "C" {
6470pub fn dispatch_block_cancel(block: dispatch_block_t);
6472}
6473extern "C" {
6474pub fn dispatch_block_testcancel(block: dispatch_block_t) -> isize;
6476}
6477pub type kern_return_t = ::core::ffi::c_int;
6479pub type dispatch_source_t = *mut dispatch_source_s;
6481#[repr(C)]
6482#[derive(Debug, Copy, Clone)]
6483pub struct dispatch_source_type_s {
6485 _unused: [u8; 0],
6486}
6487pub type dispatch_source_type_t = *const dispatch_source_type_s;
6489extern "C" {
6490pub static _dispatch_source_type_data_add: dispatch_source_type_s;
6492}
6493extern "C" {
6494pub static _dispatch_source_type_data_or: dispatch_source_type_s;
6496}
6497extern "C" {
6498pub static _dispatch_source_type_data_replace: dispatch_source_type_s;
6500}
6501extern "C" {
6502pub static _dispatch_source_type_mach_send: dispatch_source_type_s;
6504}
6505extern "C" {
6506pub static _dispatch_source_type_mach_recv: dispatch_source_type_s;
6508}
6509extern "C" {
6510pub static _dispatch_source_type_memorypressure: dispatch_source_type_s;
6512}
6513extern "C" {
6514pub static _dispatch_source_type_proc: dispatch_source_type_s;
6516}
6517extern "C" {
6518pub static _dispatch_source_type_read: dispatch_source_type_s;
6520}
6521extern "C" {
6522pub static _dispatch_source_type_signal: dispatch_source_type_s;
6524}
6525extern "C" {
6526pub static _dispatch_source_type_timer: dispatch_source_type_s;
6528}
6529extern "C" {
6530pub static _dispatch_source_type_vnode: dispatch_source_type_s;
6532}
6533extern "C" {
6534pub static _dispatch_source_type_write: dispatch_source_type_s;
6536}
6537pub type dispatch_source_mach_send_flags_t = ::core::ffi::c_ulong;
6539pub type dispatch_source_mach_recv_flags_t = ::core::ffi::c_ulong;
6541pub type dispatch_source_memorypressure_flags_t = ::core::ffi::c_ulong;
6543pub type dispatch_source_proc_flags_t = ::core::ffi::c_ulong;
6545pub type dispatch_source_vnode_flags_t = ::core::ffi::c_ulong;
6547pub type dispatch_source_timer_flags_t = ::core::ffi::c_ulong;
6549extern "C" {
6550pub fn dispatch_source_create(
6552 type_: dispatch_source_type_t,
6553 handle: usize,
6554 mask: usize,
6555 queue: dispatch_queue_t,
6556 ) -> dispatch_source_t;
6557}
6558extern "C" {
6559pub fn dispatch_source_set_event_handler(source: dispatch_source_t, handler: dispatch_block_t);
6561}
6562extern "C" {
6563pub fn dispatch_source_set_event_handler_f(
6565 source: dispatch_source_t,
6566 handler: dispatch_function_t,
6567 );
6568}
6569extern "C" {
6570pub fn dispatch_source_set_cancel_handler(source: dispatch_source_t, handler: dispatch_block_t);
6572}
6573extern "C" {
6574pub fn dispatch_source_set_cancel_handler_f(
6576 source: dispatch_source_t,
6577 handler: dispatch_function_t,
6578 );
6579}
6580extern "C" {
6581pub fn dispatch_source_cancel(source: dispatch_source_t);
6583}
6584extern "C" {
6585pub fn dispatch_source_testcancel(source: dispatch_source_t) -> isize;
6587}
6588extern "C" {
6589pub fn dispatch_source_get_handle(source: dispatch_source_t) -> usize;
6591}
6592extern "C" {
6593pub fn dispatch_source_get_mask(source: dispatch_source_t) -> usize;
6595}
6596extern "C" {
6597pub fn dispatch_source_get_data(source: dispatch_source_t) -> usize;
6599}
6600extern "C" {
6601pub fn dispatch_source_merge_data(source: dispatch_source_t, value: usize);
6603}
6604extern "C" {
6605pub fn dispatch_source_set_timer(
6607 source: dispatch_source_t,
6608 start: dispatch_time_t,
6609 interval: u64,
6610 leeway: u64,
6611 );
6612}
6613extern "C" {
6614pub fn dispatch_source_set_registration_handler(
6616 source: dispatch_source_t,
6617 handler: dispatch_block_t,
6618 );
6619}
6620extern "C" {
6621pub fn dispatch_source_set_registration_handler_f(
6623 source: dispatch_source_t,
6624 handler: dispatch_function_t,
6625 );
6626}
6627pub type dispatch_group_t = *mut dispatch_group_s;
6629extern "C" {
6630pub fn dispatch_group_create() -> dispatch_group_t;
6632}
6633extern "C" {
6634pub fn dispatch_group_async(
6636 group: dispatch_group_t,
6637 queue: dispatch_queue_t,
6638 block: dispatch_block_t,
6639 );
6640}
6641extern "C" {
6642pub fn dispatch_group_async_f(
6644 group: dispatch_group_t,
6645 queue: dispatch_queue_t,
6646 context: *mut ::core::ffi::c_void,
6647 work: dispatch_function_t,
6648 );
6649}
6650extern "C" {
6651pub fn dispatch_group_wait(group: dispatch_group_t, timeout: dispatch_time_t) -> isize;
6653}
6654extern "C" {
6655pub fn dispatch_group_notify(
6657 group: dispatch_group_t,
6658 queue: dispatch_queue_t,
6659 block: dispatch_block_t,
6660 );
6661}
6662extern "C" {
6663pub fn dispatch_group_notify_f(
6665 group: dispatch_group_t,
6666 queue: dispatch_queue_t,
6667 context: *mut ::core::ffi::c_void,
6668 work: dispatch_function_t,
6669 );
6670}
6671extern "C" {
6672pub fn dispatch_group_enter(group: dispatch_group_t);
6674}
6675extern "C" {
6676pub fn dispatch_group_leave(group: dispatch_group_t);
6678}
6679pub type dispatch_semaphore_t = *mut dispatch_semaphore_s;
6681extern "C" {
6682pub fn dispatch_semaphore_create(value: isize) -> dispatch_semaphore_t;
6684}
6685extern "C" {
6686pub fn dispatch_semaphore_wait(dsema: dispatch_semaphore_t, timeout: dispatch_time_t) -> isize;
6688}
6689extern "C" {
6690pub fn dispatch_semaphore_signal(dsema: dispatch_semaphore_t) -> isize;
6692}
6693pub type dispatch_once_t = isize;
6695extern "C" {
6696pub fn dispatch_once(predicate: *mut dispatch_once_t, block: dispatch_block_t);
6698}
6699extern "C" {
6700pub fn dispatch_once_f(
6702 predicate: *mut dispatch_once_t,
6703 context: *mut ::core::ffi::c_void,
6704 function: dispatch_function_t,
6705 );
6706}
6707pub type dispatch_data_t = *mut dispatch_data_s;
6709#[repr(C)]
6710#[derive(Debug, Copy, Clone)]
6711pub struct dispatch_data_s {
6713 pub _address: u8,
6714}
6715extern "C" {
6716pub static mut _dispatch_data_empty: dispatch_data_s;
6718}
6719extern "C" {
6720pub static _dispatch_data_destructor_free: dispatch_block_t;
6722}
6723extern "C" {
6724pub static _dispatch_data_destructor_munmap: dispatch_block_t;
6726}
6727extern "C" {
6728pub fn dispatch_data_create(
6730 buffer: *const ::core::ffi::c_void,
6731 size: usize,
6732 queue: dispatch_queue_t,
6733 destructor: dispatch_block_t,
6734 ) -> dispatch_data_t;
6735}
6736extern "C" {
6737pub fn dispatch_data_get_size(data: dispatch_data_t) -> usize;
6739}
6740extern "C" {
6741pub fn dispatch_data_create_map(
6743 data: dispatch_data_t,
6744 buffer_ptr: *mut *const ::core::ffi::c_void,
6745 size_ptr: *mut usize,
6746 ) -> dispatch_data_t;
6747}
6748extern "C" {
6749pub fn dispatch_data_create_concat(
6751 data1: dispatch_data_t,
6752 data2: dispatch_data_t,
6753 ) -> dispatch_data_t;
6754}
6755extern "C" {
6756pub fn dispatch_data_create_subrange(
6758 data: dispatch_data_t,
6759 offset: usize,
6760 length: usize,
6761 ) -> dispatch_data_t;
6762}
6763pub type dispatch_data_applier_t = *mut ::core::ffi::c_void;
6765extern "C" {
6766pub fn dispatch_data_apply(data: dispatch_data_t, applier: dispatch_data_applier_t) -> bool;
6768}
6769extern "C" {
6770pub fn dispatch_data_copy_region(
6772 data: dispatch_data_t,
6773 location: usize,
6774 offset_ptr: *mut usize,
6775 ) -> dispatch_data_t;
6776}
6777pub type dispatch_fd_t = ::core::ffi::c_int;
6779extern "C" {
6780pub fn dispatch_read(
6782 fd: dispatch_fd_t,
6783 length: usize,
6784 queue: dispatch_queue_t,
6785 handler: *mut ::core::ffi::c_void,
6786 );
6787}
6788extern "C" {
6789pub fn dispatch_write(
6791 fd: dispatch_fd_t,
6792 data: dispatch_data_t,
6793 queue: dispatch_queue_t,
6794 handler: *mut ::core::ffi::c_void,
6795 );
6796}
6797pub type dispatch_io_t = *mut dispatch_io_s;
6799pub type dispatch_io_type_t = ::core::ffi::c_ulong;
6801extern "C" {
6802pub fn dispatch_io_create(
6804 type_: dispatch_io_type_t,
6805 fd: dispatch_fd_t,
6806 queue: dispatch_queue_t,
6807 cleanup_handler: *mut ::core::ffi::c_void,
6808 ) -> dispatch_io_t;
6809}
6810extern "C" {
6811pub fn dispatch_io_create_with_path(
6813 type_: dispatch_io_type_t,
6814 path: *const ::core::ffi::c_char,
6815 oflag: ::core::ffi::c_int,
6816 mode: mode_t,
6817 queue: dispatch_queue_t,
6818 cleanup_handler: *mut ::core::ffi::c_void,
6819 ) -> dispatch_io_t;
6820}
6821extern "C" {
6822pub fn dispatch_io_create_with_io(
6824 type_: dispatch_io_type_t,
6825 io: dispatch_io_t,
6826 queue: dispatch_queue_t,
6827 cleanup_handler: *mut ::core::ffi::c_void,
6828 ) -> dispatch_io_t;
6829}
6830pub type dispatch_io_handler_t = *mut ::core::ffi::c_void;
6832extern "C" {
6833pub fn dispatch_io_read(
6835 channel: dispatch_io_t,
6836 offset: off_t,
6837 length: usize,
6838 queue: dispatch_queue_t,
6839 io_handler: dispatch_io_handler_t,
6840 );
6841}
6842extern "C" {
6843pub fn dispatch_io_write(
6845 channel: dispatch_io_t,
6846 offset: off_t,
6847 data: dispatch_data_t,
6848 queue: dispatch_queue_t,
6849 io_handler: dispatch_io_handler_t,
6850 );
6851}
6852pub type dispatch_io_close_flags_t = ::core::ffi::c_ulong;
6854extern "C" {
6855pub fn dispatch_io_close(channel: dispatch_io_t, flags: dispatch_io_close_flags_t);
6857}
6858extern "C" {
6859pub fn dispatch_io_barrier(channel: dispatch_io_t, barrier: dispatch_block_t);
6861}
6862extern "C" {
6863pub fn dispatch_io_get_descriptor(channel: dispatch_io_t) -> dispatch_fd_t;
6865}
6866extern "C" {
6867pub fn dispatch_io_set_high_water(channel: dispatch_io_t, high_water: usize);
6869}
6870extern "C" {
6871pub fn dispatch_io_set_low_water(channel: dispatch_io_t, low_water: usize);
6873}
6874pub type dispatch_io_interval_flags_t = ::core::ffi::c_ulong;
6876extern "C" {
6877pub fn dispatch_io_set_interval(
6879 channel: dispatch_io_t,
6880 interval: u64,
6881 flags: dispatch_io_interval_flags_t,
6882 );
6883}
6884pub type dispatch_workloop_t = dispatch_queue_t;
6886extern "C" {
6887pub fn dispatch_workloop_create(label: *const ::core::ffi::c_char) -> dispatch_workloop_t;
6889}
6890extern "C" {
6891pub fn dispatch_workloop_create_inactive(
6893 label: *const ::core::ffi::c_char,
6894 ) -> dispatch_workloop_t;
6895}
6896extern "C" {
6897pub fn dispatch_workloop_set_autorelease_frequency(
6899 workloop: dispatch_workloop_t,
6900 frequency: dispatch_autorelease_frequency_t,
6901 );
6902}
6903extern "C" {
6904pub fn dispatch_workloop_set_os_workgroup(
6906 workloop: dispatch_workloop_t,
6907 workgroup: os_workgroup_t,
6908 );
6909}
6910#[repr(C)]
6911#[derive(Debug, Copy, Clone)]
6912pub struct CFStreamError {
6914 pub domain: CFIndex,
6915 pub error: SInt32,
6916}
6917pub type CFStreamPropertyKey = CFStringRef;
6919pub type CFStreamStatus = CFIndex;
6921pub const kCFStreamStatusNotOpen: _bindgen_ty_39 = 0;
6923pub const kCFStreamStatusOpening: _bindgen_ty_39 = 1;
6925pub const kCFStreamStatusOpen: _bindgen_ty_39 = 2;
6927pub const kCFStreamStatusReading: _bindgen_ty_39 = 3;
6929pub const kCFStreamStatusWriting: _bindgen_ty_39 = 4;
6931pub const kCFStreamStatusAtEnd: _bindgen_ty_39 = 5;
6933pub const kCFStreamStatusClosed: _bindgen_ty_39 = 6;
6935pub const kCFStreamStatusError: _bindgen_ty_39 = 7;
6937pub type _bindgen_ty_39 = ::core::ffi::c_uint;
6939pub type CFStreamEventType = CFOptionFlags;
6941pub const kCFStreamEventNone: _bindgen_ty_40 = 0;
6943pub const kCFStreamEventOpenCompleted: _bindgen_ty_40 = 1;
6945pub const kCFStreamEventHasBytesAvailable: _bindgen_ty_40 = 2;
6947pub const kCFStreamEventCanAcceptBytes: _bindgen_ty_40 = 4;
6949pub const kCFStreamEventErrorOccurred: _bindgen_ty_40 = 8;
6951pub const kCFStreamEventEndEncountered: _bindgen_ty_40 = 16;
6953pub type _bindgen_ty_40 = ::core::ffi::c_uint;
6955#[repr(C)]
6956#[derive(Debug, Copy, Clone)]
6957pub struct CFStreamClientContext {
6959 pub version: CFIndex,
6960 pub info: *mut ::core::ffi::c_void,
6961 pub retain: ::core::option::Option<
6962 unsafe extern "C" fn(info: *mut ::core::ffi::c_void) -> *mut ::core::ffi::c_void,
6963 >,
6964 pub release: ::core::option::Option<unsafe extern "C" fn(info: *mut ::core::ffi::c_void)>,
6965 pub copyDescription:
6966 ::core::option::Option<unsafe extern "C" fn(info: *mut ::core::ffi::c_void) -> CFStringRef>,
6967}
6968#[repr(C)]
6969#[derive(Debug, Copy, Clone)]
6970pub struct __CFReadStream {
6972 _unused: [u8; 0],
6973}
6974pub type CFReadStreamRef = *mut __CFReadStream;
6976#[repr(C)]
6977#[derive(Debug, Copy, Clone)]
6978pub struct __CFWriteStream {
6980 _unused: [u8; 0],
6981}
6982pub type CFWriteStreamRef = *mut __CFWriteStream;
6984pub type CFReadStreamClientCallBack = ::core::option::Option<
6986 unsafe extern "C" fn(
6987 stream: CFReadStreamRef,
6988 type_: CFStreamEventType,
6989 clientCallBackInfo: *mut ::core::ffi::c_void,
6990 ),
6991>;
6992pub type CFWriteStreamClientCallBack = ::core::option::Option<
6994 unsafe extern "C" fn(
6995 stream: CFWriteStreamRef,
6996 type_: CFStreamEventType,
6997 clientCallBackInfo: *mut ::core::ffi::c_void,
6998 ),
6999>;
7000extern "C" {
7001pub fn CFReadStreamGetTypeID() -> CFTypeID;
7003}
7004extern "C" {
7005pub fn CFWriteStreamGetTypeID() -> CFTypeID;
7007}
7008extern "C" {
7009pub static mut kCFStreamPropertyDataWritten: CFStreamPropertyKey;
7011}
7012extern "C" {
7013pub fn CFReadStreamCreateWithBytesNoCopy(
7015 alloc: CFAllocatorRef,
7016 bytes: *const UInt8,
7017 length: CFIndex,
7018 bytesDeallocator: CFAllocatorRef,
7019 ) -> CFReadStreamRef;
7020}
7021extern "C" {
7022pub fn CFWriteStreamCreateWithBuffer(
7024 alloc: CFAllocatorRef,
7025 buffer: *mut UInt8,
7026 bufferCapacity: CFIndex,
7027 ) -> CFWriteStreamRef;
7028}
7029extern "C" {
7030pub fn CFWriteStreamCreateWithAllocatedBuffers(
7032 alloc: CFAllocatorRef,
7033 bufferAllocator: CFAllocatorRef,
7034 ) -> CFWriteStreamRef;
7035}
7036extern "C" {
7037pub fn CFReadStreamCreateWithFile(alloc: CFAllocatorRef, fileURL: CFURLRef) -> CFReadStreamRef;
7039}
7040extern "C" {
7041pub fn CFWriteStreamCreateWithFile(
7043 alloc: CFAllocatorRef,
7044 fileURL: CFURLRef,
7045 ) -> CFWriteStreamRef;
7046}
7047extern "C" {
7048pub fn CFStreamCreateBoundPair(
7050 alloc: CFAllocatorRef,
7051 readStream: *mut CFReadStreamRef,
7052 writeStream: *mut CFWriteStreamRef,
7053 transferBufferSize: CFIndex,
7054 );
7055}
7056extern "C" {
7057pub static mut kCFStreamPropertyAppendToFile: CFStreamPropertyKey;
7059}
7060extern "C" {
7061pub static mut kCFStreamPropertyFileCurrentOffset: CFStreamPropertyKey;
7063}
7064extern "C" {
7065pub static mut kCFStreamPropertySocketNativeHandle: CFStreamPropertyKey;
7067}
7068extern "C" {
7069pub static mut kCFStreamPropertySocketRemoteHostName: CFStreamPropertyKey;
7071}
7072extern "C" {
7073pub static mut kCFStreamPropertySocketRemotePortNumber: CFStreamPropertyKey;
7075}
7076extern "C" {
7077pub static kCFStreamErrorDomainSOCKS: ::core::ffi::c_int;
7079}
7080extern "C" {
7081pub static mut kCFStreamPropertySOCKSProxy: CFStringRef;
7083}
7084extern "C" {
7085pub static mut kCFStreamPropertySOCKSProxyHost: CFStringRef;
7087}
7088extern "C" {
7089pub static mut kCFStreamPropertySOCKSProxyPort: CFStringRef;
7091}
7092extern "C" {
7093pub static mut kCFStreamPropertySOCKSVersion: CFStringRef;
7095}
7096extern "C" {
7097pub static mut kCFStreamSocketSOCKSVersion4: CFStringRef;
7099}
7100extern "C" {
7101pub static mut kCFStreamSocketSOCKSVersion5: CFStringRef;
7103}
7104extern "C" {
7105pub static mut kCFStreamPropertySOCKSUser: CFStringRef;
7107}
7108extern "C" {
7109pub static mut kCFStreamPropertySOCKSPassword: CFStringRef;
7111}
7112extern "C" {
7113pub static kCFStreamErrorDomainSSL: ::core::ffi::c_int;
7115}
7116extern "C" {
7117pub static mut kCFStreamPropertySocketSecurityLevel: CFStringRef;
7119}
7120extern "C" {
7121pub static mut kCFStreamSocketSecurityLevelNone: CFStringRef;
7123}
7124extern "C" {
7125pub static mut kCFStreamSocketSecurityLevelSSLv2: CFStringRef;
7127}
7128extern "C" {
7129pub static mut kCFStreamSocketSecurityLevelSSLv3: CFStringRef;
7131}
7132extern "C" {
7133pub static mut kCFStreamSocketSecurityLevelTLSv1: CFStringRef;
7135}
7136extern "C" {
7137pub static mut kCFStreamSocketSecurityLevelNegotiatedSSL: CFStringRef;
7139}
7140extern "C" {
7141pub static mut kCFStreamPropertyShouldCloseNativeSocket: CFStringRef;
7143}
7144extern "C" {
7145pub fn CFStreamCreatePairWithSocket(
7147 alloc: CFAllocatorRef,
7148 sock: CFSocketNativeHandle,
7149 readStream: *mut CFReadStreamRef,
7150 writeStream: *mut CFWriteStreamRef,
7151 );
7152}
7153extern "C" {
7154pub fn CFStreamCreatePairWithSocketToHost(
7156 alloc: CFAllocatorRef,
7157 host: CFStringRef,
7158 port: UInt32,
7159 readStream: *mut CFReadStreamRef,
7160 writeStream: *mut CFWriteStreamRef,
7161 );
7162}
7163extern "C" {
7164pub fn CFStreamCreatePairWithPeerSocketSignature(
7166 alloc: CFAllocatorRef,
7167 signature: *const CFSocketSignature,
7168 readStream: *mut CFReadStreamRef,
7169 writeStream: *mut CFWriteStreamRef,
7170 );
7171}
7172extern "C" {
7173pub fn CFReadStreamGetStatus(stream: CFReadStreamRef) -> CFStreamStatus;
7175}
7176extern "C" {
7177pub fn CFWriteStreamGetStatus(stream: CFWriteStreamRef) -> CFStreamStatus;
7179}
7180extern "C" {
7181pub fn CFReadStreamCopyError(stream: CFReadStreamRef) -> CFErrorRef;
7183}
7184extern "C" {
7185pub fn CFWriteStreamCopyError(stream: CFWriteStreamRef) -> CFErrorRef;
7187}
7188extern "C" {
7189pub fn CFReadStreamOpen(stream: CFReadStreamRef) -> Boolean;
7191}
7192extern "C" {
7193pub fn CFWriteStreamOpen(stream: CFWriteStreamRef) -> Boolean;
7195}
7196extern "C" {
7197pub fn CFReadStreamClose(stream: CFReadStreamRef);
7199}
7200extern "C" {
7201pub fn CFWriteStreamClose(stream: CFWriteStreamRef);
7203}
7204extern "C" {
7205pub fn CFReadStreamHasBytesAvailable(stream: CFReadStreamRef) -> Boolean;
7207}
7208extern "C" {
7209pub fn CFReadStreamRead(
7211 stream: CFReadStreamRef,
7212 buffer: *mut UInt8,
7213 bufferLength: CFIndex,
7214 ) -> CFIndex;
7215}
7216extern "C" {
7217pub fn CFReadStreamGetBuffer(
7219 stream: CFReadStreamRef,
7220 maxBytesToRead: CFIndex,
7221 numBytesRead: *mut CFIndex,
7222 ) -> *const UInt8;
7223}
7224extern "C" {
7225pub fn CFWriteStreamCanAcceptBytes(stream: CFWriteStreamRef) -> Boolean;
7227}
7228extern "C" {
7229pub fn CFWriteStreamWrite(
7231 stream: CFWriteStreamRef,
7232 buffer: *const UInt8,
7233 bufferLength: CFIndex,
7234 ) -> CFIndex;
7235}
7236extern "C" {
7237pub fn CFReadStreamCopyProperty(
7239 stream: CFReadStreamRef,
7240 propertyName: CFStreamPropertyKey,
7241 ) -> CFTypeRef;
7242}
7243extern "C" {
7244pub fn CFWriteStreamCopyProperty(
7246 stream: CFWriteStreamRef,
7247 propertyName: CFStreamPropertyKey,
7248 ) -> CFTypeRef;
7249}
7250extern "C" {
7251pub fn CFReadStreamSetProperty(
7253 stream: CFReadStreamRef,
7254 propertyName: CFStreamPropertyKey,
7255 propertyValue: CFTypeRef,
7256 ) -> Boolean;
7257}
7258extern "C" {
7259pub fn CFWriteStreamSetProperty(
7261 stream: CFWriteStreamRef,
7262 propertyName: CFStreamPropertyKey,
7263 propertyValue: CFTypeRef,
7264 ) -> Boolean;
7265}
7266extern "C" {
7267pub fn CFReadStreamSetClient(
7269 stream: CFReadStreamRef,
7270 streamEvents: CFOptionFlags,
7271 clientCB: CFReadStreamClientCallBack,
7272 clientContext: *mut CFStreamClientContext,
7273 ) -> Boolean;
7274}
7275extern "C" {
7276pub fn CFWriteStreamSetClient(
7278 stream: CFWriteStreamRef,
7279 streamEvents: CFOptionFlags,
7280 clientCB: CFWriteStreamClientCallBack,
7281 clientContext: *mut CFStreamClientContext,
7282 ) -> Boolean;
7283}
7284extern "C" {
7285pub fn CFReadStreamScheduleWithRunLoop(
7287 stream: CFReadStreamRef,
7288 runLoop: CFRunLoopRef,
7289 runLoopMode: CFRunLoopMode,
7290 );
7291}
7292extern "C" {
7293pub fn CFWriteStreamScheduleWithRunLoop(
7295 stream: CFWriteStreamRef,
7296 runLoop: CFRunLoopRef,
7297 runLoopMode: CFRunLoopMode,
7298 );
7299}
7300extern "C" {
7301pub fn CFReadStreamUnscheduleFromRunLoop(
7303 stream: CFReadStreamRef,
7304 runLoop: CFRunLoopRef,
7305 runLoopMode: CFRunLoopMode,
7306 );
7307}
7308extern "C" {
7309pub fn CFWriteStreamUnscheduleFromRunLoop(
7311 stream: CFWriteStreamRef,
7312 runLoop: CFRunLoopRef,
7313 runLoopMode: CFRunLoopMode,
7314 );
7315}
7316extern "C" {
7317pub fn CFReadStreamSetDispatchQueue(stream: CFReadStreamRef, q: dispatch_queue_t);
7319}
7320extern "C" {
7321pub fn CFWriteStreamSetDispatchQueue(stream: CFWriteStreamRef, q: dispatch_queue_t);
7323}
7324extern "C" {
7325pub fn CFReadStreamCopyDispatchQueue(stream: CFReadStreamRef) -> dispatch_queue_t;
7327}
7328extern "C" {
7329pub fn CFWriteStreamCopyDispatchQueue(stream: CFWriteStreamRef) -> dispatch_queue_t;
7331}
7332pub type CFStreamErrorDomain = CFIndex;
7334pub const kCFStreamErrorDomainCustom: _bindgen_ty_41 = -1;
7336pub const kCFStreamErrorDomainPOSIX: _bindgen_ty_41 = 1;
7338pub const kCFStreamErrorDomainMacOSStatus: _bindgen_ty_41 = 2;
7340pub type _bindgen_ty_41 = ::core::ffi::c_int;
7342extern "C" {
7343pub fn CFReadStreamGetError(stream: CFReadStreamRef) -> CFStreamError;
7345}
7346extern "C" {
7347pub fn CFWriteStreamGetError(stream: CFWriteStreamRef) -> CFStreamError;
7349}
7350pub type CFPropertyListMutabilityOptions = CFOptionFlags;
7352pub const kCFPropertyListImmutable: _bindgen_ty_42 = 0;
7354pub const kCFPropertyListMutableContainers: _bindgen_ty_42 = 1;
7356pub const kCFPropertyListMutableContainersAndLeaves: _bindgen_ty_42 = 2;
7358pub type _bindgen_ty_42 = ::core::ffi::c_uint;
7360extern "C" {
7361pub fn CFPropertyListCreateFromXMLData(
7363 allocator: CFAllocatorRef,
7364 xmlData: CFDataRef,
7365 mutabilityOption: CFOptionFlags,
7366 errorString: *mut CFStringRef,
7367 ) -> CFPropertyListRef;
7368}
7369extern "C" {
7370pub fn CFPropertyListCreateXMLData(
7372 allocator: CFAllocatorRef,
7373 propertyList: CFPropertyListRef,
7374 ) -> CFDataRef;
7375}
7376extern "C" {
7377pub fn CFPropertyListCreateDeepCopy(
7379 allocator: CFAllocatorRef,
7380 propertyList: CFPropertyListRef,
7381 mutabilityOption: CFOptionFlags,
7382 ) -> CFPropertyListRef;
7383}
7384pub type CFPropertyListFormat = CFIndex;
7386pub const kCFPropertyListOpenStepFormat: _bindgen_ty_43 = 1;
7388pub const kCFPropertyListXMLFormat_v1_0: _bindgen_ty_43 = 100;
7390pub const kCFPropertyListBinaryFormat_v1_0: _bindgen_ty_43 = 200;
7392pub type _bindgen_ty_43 = ::core::ffi::c_uint;
7394extern "C" {
7395pub fn CFPropertyListIsValid(plist: CFPropertyListRef, format: CFPropertyListFormat)
7397 -> Boolean;
7398}
7399extern "C" {
7400pub fn CFPropertyListWriteToStream(
7402 propertyList: CFPropertyListRef,
7403 stream: CFWriteStreamRef,
7404 format: CFPropertyListFormat,
7405 errorString: *mut CFStringRef,
7406 ) -> CFIndex;
7407}
7408extern "C" {
7409pub fn CFPropertyListCreateFromStream(
7411 allocator: CFAllocatorRef,
7412 stream: CFReadStreamRef,
7413 streamLength: CFIndex,
7414 mutabilityOption: CFOptionFlags,
7415 format: *mut CFPropertyListFormat,
7416 errorString: *mut CFStringRef,
7417 ) -> CFPropertyListRef;
7418}
7419pub const kCFPropertyListReadCorruptError: _bindgen_ty_44 = 3840;
7421pub const kCFPropertyListReadUnknownVersionError: _bindgen_ty_44 = 3841;
7423pub const kCFPropertyListReadStreamError: _bindgen_ty_44 = 3842;
7425pub const kCFPropertyListWriteStreamError: _bindgen_ty_44 = 3851;
7427pub type _bindgen_ty_44 = ::core::ffi::c_uint;
7429extern "C" {
7430pub fn CFPropertyListCreateWithData(
7432 allocator: CFAllocatorRef,
7433 data: CFDataRef,
7434 options: CFOptionFlags,
7435 format: *mut CFPropertyListFormat,
7436 error: *mut CFErrorRef,
7437 ) -> CFPropertyListRef;
7438}
7439extern "C" {
7440pub fn CFPropertyListCreateWithStream(
7442 allocator: CFAllocatorRef,
7443 stream: CFReadStreamRef,
7444 streamLength: CFIndex,
7445 options: CFOptionFlags,
7446 format: *mut CFPropertyListFormat,
7447 error: *mut CFErrorRef,
7448 ) -> CFPropertyListRef;
7449}
7450extern "C" {
7451pub fn CFPropertyListWrite(
7453 propertyList: CFPropertyListRef,
7454 stream: CFWriteStreamRef,
7455 format: CFPropertyListFormat,
7456 options: CFOptionFlags,
7457 error: *mut CFErrorRef,
7458 ) -> CFIndex;
7459}
7460extern "C" {
7461pub fn CFPropertyListCreateData(
7463 allocator: CFAllocatorRef,
7464 propertyList: CFPropertyListRef,
7465 format: CFPropertyListFormat,
7466 options: CFOptionFlags,
7467 error: *mut CFErrorRef,
7468 ) -> CFDataRef;
7469}
7470pub type CFSetRetainCallBack = ::core::option::Option<
7472 unsafe extern "C" fn(
7473 allocator: CFAllocatorRef,
7474 value: *const ::core::ffi::c_void,
7475 ) -> *const ::core::ffi::c_void,
7476>;
7477pub type CFSetReleaseCallBack = ::core::option::Option<
7479 unsafe extern "C" fn(allocator: CFAllocatorRef, value: *const ::core::ffi::c_void),
7480>;
7481pub type CFSetCopyDescriptionCallBack =
7483 ::core::option::Option<unsafe extern "C" fn(value: *const ::core::ffi::c_void) -> CFStringRef>;
7484pub type CFSetEqualCallBack = ::core::option::Option<
7486 unsafe extern "C" fn(
7487 value1: *const ::core::ffi::c_void,
7488 value2: *const ::core::ffi::c_void,
7489 ) -> Boolean,
7490>;
7491pub type CFSetHashCallBack =
7493 ::core::option::Option<unsafe extern "C" fn(value: *const ::core::ffi::c_void) -> CFHashCode>;
7494#[repr(C)]
7495#[derive(Debug, Copy, Clone)]
7496pub struct CFSetCallBacks {
7498 pub version: CFIndex,
7499 pub retain: CFSetRetainCallBack,
7500 pub release: CFSetReleaseCallBack,
7501 pub copyDescription: CFSetCopyDescriptionCallBack,
7502 pub equal: CFSetEqualCallBack,
7503 pub hash: CFSetHashCallBack,
7504}
7505extern "C" {
7506pub static kCFTypeSetCallBacks: CFSetCallBacks;
7508}
7509extern "C" {
7510pub static kCFCopyStringSetCallBacks: CFSetCallBacks;
7512}
7513pub type CFSetApplierFunction = ::core::option::Option<
7515 unsafe extern "C" fn(value: *const ::core::ffi::c_void, context: *mut ::core::ffi::c_void),
7516>;
7517#[repr(C)]
7518#[derive(Debug, Copy, Clone)]
7519pub struct __CFSet {
7521 _unused: [u8; 0],
7522}
7523pub type CFSetRef = *const __CFSet;
7525pub type CFMutableSetRef = *mut __CFSet;
7527extern "C" {
7528pub fn CFSetGetTypeID() -> CFTypeID;
7530}
7531extern "C" {
7532pub fn CFSetCreate(
7534 allocator: CFAllocatorRef,
7535 values: *mut *const ::core::ffi::c_void,
7536 numValues: CFIndex,
7537 callBacks: *const CFSetCallBacks,
7538 ) -> CFSetRef;
7539}
7540extern "C" {
7541pub fn CFSetCreateCopy(allocator: CFAllocatorRef, theSet: CFSetRef) -> CFSetRef;
7543}
7544extern "C" {
7545pub fn CFSetCreateMutable(
7547 allocator: CFAllocatorRef,
7548 capacity: CFIndex,
7549 callBacks: *const CFSetCallBacks,
7550 ) -> CFMutableSetRef;
7551}
7552extern "C" {
7553pub fn CFSetCreateMutableCopy(
7555 allocator: CFAllocatorRef,
7556 capacity: CFIndex,
7557 theSet: CFSetRef,
7558 ) -> CFMutableSetRef;
7559}
7560extern "C" {
7561pub fn CFSetGetCount(theSet: CFSetRef) -> CFIndex;
7563}
7564extern "C" {
7565pub fn CFSetGetCountOfValue(theSet: CFSetRef, value: *const ::core::ffi::c_void) -> CFIndex;
7567}
7568extern "C" {
7569pub fn CFSetContainsValue(theSet: CFSetRef, value: *const ::core::ffi::c_void) -> Boolean;
7571}
7572extern "C" {
7573pub fn CFSetGetValue(
7575 theSet: CFSetRef,
7576 value: *const ::core::ffi::c_void,
7577 ) -> *const ::core::ffi::c_void;
7578}
7579extern "C" {
7580pub fn CFSetGetValueIfPresent(
7582 theSet: CFSetRef,
7583 candidate: *const ::core::ffi::c_void,
7584 value: *mut *const ::core::ffi::c_void,
7585 ) -> Boolean;
7586}
7587extern "C" {
7588pub fn CFSetGetValues(theSet: CFSetRef, values: *mut *const ::core::ffi::c_void);
7590}
7591extern "C" {
7592pub fn CFSetApplyFunction(
7594 theSet: CFSetRef,
7595 applier: CFSetApplierFunction,
7596 context: *mut ::core::ffi::c_void,
7597 );
7598}
7599extern "C" {
7600pub fn CFSetAddValue(theSet: CFMutableSetRef, value: *const ::core::ffi::c_void);
7602}
7603extern "C" {
7604pub fn CFSetReplaceValue(theSet: CFMutableSetRef, value: *const ::core::ffi::c_void);
7606}
7607extern "C" {
7608pub fn CFSetSetValue(theSet: CFMutableSetRef, value: *const ::core::ffi::c_void);
7610}
7611extern "C" {
7612pub fn CFSetRemoveValue(theSet: CFMutableSetRef, value: *const ::core::ffi::c_void);
7614}
7615extern "C" {
7616pub fn CFSetRemoveAllValues(theSet: CFMutableSetRef);
7618}
7619pub type CFStringEncodings = CFIndex;
7621pub const kCFStringEncodingMacJapanese: _bindgen_ty_45 = 1;
7623pub const kCFStringEncodingMacChineseTrad: _bindgen_ty_45 = 2;
7625pub const kCFStringEncodingMacKorean: _bindgen_ty_45 = 3;
7627pub const kCFStringEncodingMacArabic: _bindgen_ty_45 = 4;
7629pub const kCFStringEncodingMacHebrew: _bindgen_ty_45 = 5;
7631pub const kCFStringEncodingMacGreek: _bindgen_ty_45 = 6;
7633pub const kCFStringEncodingMacCyrillic: _bindgen_ty_45 = 7;
7635pub const kCFStringEncodingMacDevanagari: _bindgen_ty_45 = 9;
7637pub const kCFStringEncodingMacGurmukhi: _bindgen_ty_45 = 10;
7639pub const kCFStringEncodingMacGujarati: _bindgen_ty_45 = 11;
7641pub const kCFStringEncodingMacOriya: _bindgen_ty_45 = 12;
7643pub const kCFStringEncodingMacBengali: _bindgen_ty_45 = 13;
7645pub const kCFStringEncodingMacTamil: _bindgen_ty_45 = 14;
7647pub const kCFStringEncodingMacTelugu: _bindgen_ty_45 = 15;
7649pub const kCFStringEncodingMacKannada: _bindgen_ty_45 = 16;
7651pub const kCFStringEncodingMacMalayalam: _bindgen_ty_45 = 17;
7653pub const kCFStringEncodingMacSinhalese: _bindgen_ty_45 = 18;
7655pub const kCFStringEncodingMacBurmese: _bindgen_ty_45 = 19;
7657pub const kCFStringEncodingMacKhmer: _bindgen_ty_45 = 20;
7659pub const kCFStringEncodingMacThai: _bindgen_ty_45 = 21;
7661pub const kCFStringEncodingMacLaotian: _bindgen_ty_45 = 22;
7663pub const kCFStringEncodingMacGeorgian: _bindgen_ty_45 = 23;
7665pub const kCFStringEncodingMacArmenian: _bindgen_ty_45 = 24;
7667pub const kCFStringEncodingMacChineseSimp: _bindgen_ty_45 = 25;
7669pub const kCFStringEncodingMacTibetan: _bindgen_ty_45 = 26;
7671pub const kCFStringEncodingMacMongolian: _bindgen_ty_45 = 27;
7673pub const kCFStringEncodingMacEthiopic: _bindgen_ty_45 = 28;
7675pub const kCFStringEncodingMacCentralEurRoman: _bindgen_ty_45 = 29;
7677pub const kCFStringEncodingMacVietnamese: _bindgen_ty_45 = 30;
7679pub const kCFStringEncodingMacExtArabic: _bindgen_ty_45 = 31;
7681pub const kCFStringEncodingMacSymbol: _bindgen_ty_45 = 33;
7683pub const kCFStringEncodingMacDingbats: _bindgen_ty_45 = 34;
7685pub const kCFStringEncodingMacTurkish: _bindgen_ty_45 = 35;
7687pub const kCFStringEncodingMacCroatian: _bindgen_ty_45 = 36;
7689pub const kCFStringEncodingMacIcelandic: _bindgen_ty_45 = 37;
7691pub const kCFStringEncodingMacRomanian: _bindgen_ty_45 = 38;
7693pub const kCFStringEncodingMacCeltic: _bindgen_ty_45 = 39;
7695pub const kCFStringEncodingMacGaelic: _bindgen_ty_45 = 40;
7697pub const kCFStringEncodingMacFarsi: _bindgen_ty_45 = 140;
7699pub const kCFStringEncodingMacUkrainian: _bindgen_ty_45 = 152;
7701pub const kCFStringEncodingMacInuit: _bindgen_ty_45 = 236;
7703pub const kCFStringEncodingMacVT100: _bindgen_ty_45 = 252;
7705pub const kCFStringEncodingMacHFS: _bindgen_ty_45 = 255;
7707pub const kCFStringEncodingISOLatin2: _bindgen_ty_45 = 514;
7709pub const kCFStringEncodingISOLatin3: _bindgen_ty_45 = 515;
7711pub const kCFStringEncodingISOLatin4: _bindgen_ty_45 = 516;
7713pub const kCFStringEncodingISOLatinCyrillic: _bindgen_ty_45 = 517;
7715pub const kCFStringEncodingISOLatinArabic: _bindgen_ty_45 = 518;
7717pub const kCFStringEncodingISOLatinGreek: _bindgen_ty_45 = 519;
7719pub const kCFStringEncodingISOLatinHebrew: _bindgen_ty_45 = 520;
7721pub const kCFStringEncodingISOLatin5: _bindgen_ty_45 = 521;
7723pub const kCFStringEncodingISOLatin6: _bindgen_ty_45 = 522;
7725pub const kCFStringEncodingISOLatinThai: _bindgen_ty_45 = 523;
7727pub const kCFStringEncodingISOLatin7: _bindgen_ty_45 = 525;
7729pub const kCFStringEncodingISOLatin8: _bindgen_ty_45 = 526;
7731pub const kCFStringEncodingISOLatin9: _bindgen_ty_45 = 527;
7733pub const kCFStringEncodingISOLatin10: _bindgen_ty_45 = 528;
7735pub const kCFStringEncodingDOSLatinUS: _bindgen_ty_45 = 1024;
7737pub const kCFStringEncodingDOSGreek: _bindgen_ty_45 = 1029;
7739pub const kCFStringEncodingDOSBalticRim: _bindgen_ty_45 = 1030;
7741pub const kCFStringEncodingDOSLatin1: _bindgen_ty_45 = 1040;
7743pub const kCFStringEncodingDOSGreek1: _bindgen_ty_45 = 1041;
7745pub const kCFStringEncodingDOSLatin2: _bindgen_ty_45 = 1042;
7747pub const kCFStringEncodingDOSCyrillic: _bindgen_ty_45 = 1043;
7749pub const kCFStringEncodingDOSTurkish: _bindgen_ty_45 = 1044;
7751pub const kCFStringEncodingDOSPortuguese: _bindgen_ty_45 = 1045;
7753pub const kCFStringEncodingDOSIcelandic: _bindgen_ty_45 = 1046;
7755pub const kCFStringEncodingDOSHebrew: _bindgen_ty_45 = 1047;
7757pub const kCFStringEncodingDOSCanadianFrench: _bindgen_ty_45 = 1048;
7759pub const kCFStringEncodingDOSArabic: _bindgen_ty_45 = 1049;
7761pub const kCFStringEncodingDOSNordic: _bindgen_ty_45 = 1050;
7763pub const kCFStringEncodingDOSRussian: _bindgen_ty_45 = 1051;
7765pub const kCFStringEncodingDOSGreek2: _bindgen_ty_45 = 1052;
7767pub const kCFStringEncodingDOSThai: _bindgen_ty_45 = 1053;
7769pub const kCFStringEncodingDOSJapanese: _bindgen_ty_45 = 1056;
7771pub const kCFStringEncodingDOSChineseSimplif: _bindgen_ty_45 = 1057;
7773pub const kCFStringEncodingDOSKorean: _bindgen_ty_45 = 1058;
7775pub const kCFStringEncodingDOSChineseTrad: _bindgen_ty_45 = 1059;
7777pub const kCFStringEncodingWindowsLatin2: _bindgen_ty_45 = 1281;
7779pub const kCFStringEncodingWindowsCyrillic: _bindgen_ty_45 = 1282;
7781pub const kCFStringEncodingWindowsGreek: _bindgen_ty_45 = 1283;
7783pub const kCFStringEncodingWindowsLatin5: _bindgen_ty_45 = 1284;
7785pub const kCFStringEncodingWindowsHebrew: _bindgen_ty_45 = 1285;
7787pub const kCFStringEncodingWindowsArabic: _bindgen_ty_45 = 1286;
7789pub const kCFStringEncodingWindowsBalticRim: _bindgen_ty_45 = 1287;
7791pub const kCFStringEncodingWindowsVietnamese: _bindgen_ty_45 = 1288;
7793pub const kCFStringEncodingWindowsKoreanJohab: _bindgen_ty_45 = 1296;
7795pub const kCFStringEncodingANSEL: _bindgen_ty_45 = 1537;
7797pub const kCFStringEncodingJIS_X0201_76: _bindgen_ty_45 = 1568;
7799pub const kCFStringEncodingJIS_X0208_83: _bindgen_ty_45 = 1569;
7801pub const kCFStringEncodingJIS_X0208_90: _bindgen_ty_45 = 1570;
7803pub const kCFStringEncodingJIS_X0212_90: _bindgen_ty_45 = 1571;
7805pub const kCFStringEncodingJIS_C6226_78: _bindgen_ty_45 = 1572;
7807pub const kCFStringEncodingShiftJIS_X0213: _bindgen_ty_45 = 1576;
7809pub const kCFStringEncodingShiftJIS_X0213_MenKuTen: _bindgen_ty_45 = 1577;
7811pub const kCFStringEncodingGB_2312_80: _bindgen_ty_45 = 1584;
7813pub const kCFStringEncodingGBK_95: _bindgen_ty_45 = 1585;
7815pub const kCFStringEncodingGB_18030_2000: _bindgen_ty_45 = 1586;
7817pub const kCFStringEncodingKSC_5601_87: _bindgen_ty_45 = 1600;
7819pub const kCFStringEncodingKSC_5601_92_Johab: _bindgen_ty_45 = 1601;
7821pub const kCFStringEncodingCNS_11643_92_P1: _bindgen_ty_45 = 1617;
7823pub const kCFStringEncodingCNS_11643_92_P2: _bindgen_ty_45 = 1618;
7825pub const kCFStringEncodingCNS_11643_92_P3: _bindgen_ty_45 = 1619;
7827pub const kCFStringEncodingISO_2022_JP: _bindgen_ty_45 = 2080;
7829pub const kCFStringEncodingISO_2022_JP_2: _bindgen_ty_45 = 2081;
7831pub const kCFStringEncodingISO_2022_JP_1: _bindgen_ty_45 = 2082;
7833pub const kCFStringEncodingISO_2022_JP_3: _bindgen_ty_45 = 2083;
7835pub const kCFStringEncodingISO_2022_CN: _bindgen_ty_45 = 2096;
7837pub const kCFStringEncodingISO_2022_CN_EXT: _bindgen_ty_45 = 2097;
7839pub const kCFStringEncodingISO_2022_KR: _bindgen_ty_45 = 2112;
7841pub const kCFStringEncodingEUC_JP: _bindgen_ty_45 = 2336;
7843pub const kCFStringEncodingEUC_CN: _bindgen_ty_45 = 2352;
7845pub const kCFStringEncodingEUC_TW: _bindgen_ty_45 = 2353;
7847pub const kCFStringEncodingEUC_KR: _bindgen_ty_45 = 2368;
7849pub const kCFStringEncodingShiftJIS: _bindgen_ty_45 = 2561;
7851pub const kCFStringEncodingKOI8_R: _bindgen_ty_45 = 2562;
7853pub const kCFStringEncodingBig5: _bindgen_ty_45 = 2563;
7855pub const kCFStringEncodingMacRomanLatin1: _bindgen_ty_45 = 2564;
7857pub const kCFStringEncodingHZ_GB_2312: _bindgen_ty_45 = 2565;
7859pub const kCFStringEncodingBig5_HKSCS_1999: _bindgen_ty_45 = 2566;
7861pub const kCFStringEncodingVISCII: _bindgen_ty_45 = 2567;
7863pub const kCFStringEncodingKOI8_U: _bindgen_ty_45 = 2568;
7865pub const kCFStringEncodingBig5_E: _bindgen_ty_45 = 2569;
7867pub const kCFStringEncodingNextStepJapanese: _bindgen_ty_45 = 2818;
7869pub const kCFStringEncodingEBCDIC_US: _bindgen_ty_45 = 3073;
7871pub const kCFStringEncodingEBCDIC_CP037: _bindgen_ty_45 = 3074;
7873pub const kCFStringEncodingUTF7: _bindgen_ty_45 = 67109120;
7875pub const kCFStringEncodingUTF7_IMAP: _bindgen_ty_45 = 2576;
7877pub const kCFStringEncodingShiftJIS_X0213_00: _bindgen_ty_45 = 1576;
7879pub type _bindgen_ty_45 = ::core::ffi::c_uint;
7881pub type CFTreeRetainCallBack = ::core::option::Option<
7883 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> *const ::core::ffi::c_void,
7884>;
7885pub type CFTreeReleaseCallBack =
7887 ::core::option::Option<unsafe extern "C" fn(info: *const ::core::ffi::c_void)>;
7888pub type CFTreeCopyDescriptionCallBack =
7890 ::core::option::Option<unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> CFStringRef>;
7891#[repr(C)]
7892#[derive(Debug, Copy, Clone)]
7893pub struct CFTreeContext {
7895 pub version: CFIndex,
7896 pub info: *mut ::core::ffi::c_void,
7897 pub retain: CFTreeRetainCallBack,
7898 pub release: CFTreeReleaseCallBack,
7899 pub copyDescription: CFTreeCopyDescriptionCallBack,
7900}
7901pub type CFTreeApplierFunction = ::core::option::Option<
7903 unsafe extern "C" fn(value: *const ::core::ffi::c_void, context: *mut ::core::ffi::c_void),
7904>;
7905#[repr(C)]
7906#[derive(Debug, Copy, Clone)]
7907pub struct __CFTree {
7909 _unused: [u8; 0],
7910}
7911pub type CFTreeRef = *mut __CFTree;
7913extern "C" {
7914pub fn CFTreeGetTypeID() -> CFTypeID;
7916}
7917extern "C" {
7918pub fn CFTreeCreate(allocator: CFAllocatorRef, context: *const CFTreeContext) -> CFTreeRef;
7920}
7921extern "C" {
7922pub fn CFTreeGetParent(tree: CFTreeRef) -> CFTreeRef;
7924}
7925extern "C" {
7926pub fn CFTreeGetNextSibling(tree: CFTreeRef) -> CFTreeRef;
7928}
7929extern "C" {
7930pub fn CFTreeGetFirstChild(tree: CFTreeRef) -> CFTreeRef;
7932}
7933extern "C" {
7934pub fn CFTreeGetContext(tree: CFTreeRef, context: *mut CFTreeContext);
7936}
7937extern "C" {
7938pub fn CFTreeGetChildCount(tree: CFTreeRef) -> CFIndex;
7940}
7941extern "C" {
7942pub fn CFTreeGetChildAtIndex(tree: CFTreeRef, idx: CFIndex) -> CFTreeRef;
7944}
7945extern "C" {
7946pub fn CFTreeGetChildren(tree: CFTreeRef, children: *mut CFTreeRef);
7948}
7949extern "C" {
7950pub fn CFTreeApplyFunctionToChildren(
7952 tree: CFTreeRef,
7953 applier: CFTreeApplierFunction,
7954 context: *mut ::core::ffi::c_void,
7955 );
7956}
7957extern "C" {
7958pub fn CFTreeFindRoot(tree: CFTreeRef) -> CFTreeRef;
7960}
7961extern "C" {
7962pub fn CFTreeSetContext(tree: CFTreeRef, context: *const CFTreeContext);
7964}
7965extern "C" {
7966pub fn CFTreePrependChild(tree: CFTreeRef, newChild: CFTreeRef);
7968}
7969extern "C" {
7970pub fn CFTreeAppendChild(tree: CFTreeRef, newChild: CFTreeRef);
7972}
7973extern "C" {
7974pub fn CFTreeInsertSibling(tree: CFTreeRef, newSibling: CFTreeRef);
7976}
7977extern "C" {
7978pub fn CFTreeRemove(tree: CFTreeRef);
7980}
7981extern "C" {
7982pub fn CFTreeRemoveAllChildren(tree: CFTreeRef);
7984}
7985extern "C" {
7986pub fn CFTreeSortChildren(
7988 tree: CFTreeRef,
7989 comparator: CFComparatorFunction,
7990 context: *mut ::core::ffi::c_void,
7991 );
7992}
7993extern "C" {
7994pub fn CFURLCreateDataAndPropertiesFromResource(
7996 alloc: CFAllocatorRef,
7997 url: CFURLRef,
7998 resourceData: *mut CFDataRef,
7999 properties: *mut CFDictionaryRef,
8000 desiredProperties: CFArrayRef,
8001 errorCode: *mut SInt32,
8002 ) -> Boolean;
8003}
8004extern "C" {
8005pub fn CFURLWriteDataAndPropertiesToResource(
8007 url: CFURLRef,
8008 dataToWrite: CFDataRef,
8009 propertiesToWrite: CFDictionaryRef,
8010 errorCode: *mut SInt32,
8011 ) -> Boolean;
8012}
8013extern "C" {
8014pub fn CFURLDestroyResource(url: CFURLRef, errorCode: *mut SInt32) -> Boolean;
8016}
8017extern "C" {
8018pub fn CFURLCreatePropertyFromResource(
8020 alloc: CFAllocatorRef,
8021 url: CFURLRef,
8022 property: CFStringRef,
8023 errorCode: *mut SInt32,
8024 ) -> CFTypeRef;
8025}
8026pub type CFURLError = CFIndex;
8028pub const kCFURLUnknownError: _bindgen_ty_46 = -10;
8030pub const kCFURLUnknownSchemeError: _bindgen_ty_46 = -11;
8032pub const kCFURLResourceNotFoundError: _bindgen_ty_46 = -12;
8034pub const kCFURLResourceAccessViolationError: _bindgen_ty_46 = -13;
8036pub const kCFURLRemoteHostUnavailableError: _bindgen_ty_46 = -14;
8038pub const kCFURLImproperArgumentsError: _bindgen_ty_46 = -15;
8040pub const kCFURLUnknownPropertyKeyError: _bindgen_ty_46 = -16;
8042pub const kCFURLPropertyKeyUnavailableError: _bindgen_ty_46 = -17;
8044pub const kCFURLTimeoutError: _bindgen_ty_46 = -18;
8046pub type _bindgen_ty_46 = ::core::ffi::c_int;
8048extern "C" {
8049pub static kCFURLFileExists: CFStringRef;
8051}
8052extern "C" {
8053pub static kCFURLFileDirectoryContents: CFStringRef;
8055}
8056extern "C" {
8057pub static kCFURLFileLength: CFStringRef;
8059}
8060extern "C" {
8061pub static kCFURLFileLastModificationTime: CFStringRef;
8063}
8064extern "C" {
8065pub static kCFURLFilePOSIXMode: CFStringRef;
8067}
8068extern "C" {
8069pub static kCFURLFileOwnerID: CFStringRef;
8071}
8072extern "C" {
8073pub static kCFURLHTTPStatusCode: CFStringRef;
8075}
8076extern "C" {
8077pub static kCFURLHTTPStatusLine: CFStringRef;
8079}
8080#[repr(C)]
8081#[derive(Debug, Copy, Clone)]
8082pub struct __CFUUID {
8084 _unused: [u8; 0],
8085}
8086pub type CFUUIDRef = *const __CFUUID;
8088#[repr(C)]
8089#[derive(Debug, Copy, Clone)]
8090pub struct CFUUIDBytes {
8092 pub byte0: UInt8,
8093 pub byte1: UInt8,
8094 pub byte2: UInt8,
8095 pub byte3: UInt8,
8096 pub byte4: UInt8,
8097 pub byte5: UInt8,
8098 pub byte6: UInt8,
8099 pub byte7: UInt8,
8100 pub byte8: UInt8,
8101 pub byte9: UInt8,
8102 pub byte10: UInt8,
8103 pub byte11: UInt8,
8104 pub byte12: UInt8,
8105 pub byte13: UInt8,
8106 pub byte14: UInt8,
8107 pub byte15: UInt8,
8108}
8109extern "C" {
8110pub fn CFUUIDGetTypeID() -> CFTypeID;
8112}
8113extern "C" {
8114pub fn CFUUIDCreate(alloc: CFAllocatorRef) -> CFUUIDRef;
8116}
8117extern "C" {
8118pub fn CFUUIDCreateWithBytes(
8120 alloc: CFAllocatorRef,
8121 byte0: UInt8,
8122 byte1: UInt8,
8123 byte2: UInt8,
8124 byte3: UInt8,
8125 byte4: UInt8,
8126 byte5: UInt8,
8127 byte6: UInt8,
8128 byte7: UInt8,
8129 byte8: UInt8,
8130 byte9: UInt8,
8131 byte10: UInt8,
8132 byte11: UInt8,
8133 byte12: UInt8,
8134 byte13: UInt8,
8135 byte14: UInt8,
8136 byte15: UInt8,
8137 ) -> CFUUIDRef;
8138}
8139extern "C" {
8140pub fn CFUUIDCreateFromString(alloc: CFAllocatorRef, uuidStr: CFStringRef) -> CFUUIDRef;
8142}
8143extern "C" {
8144pub fn CFUUIDCreateString(alloc: CFAllocatorRef, uuid: CFUUIDRef) -> CFStringRef;
8146}
8147extern "C" {
8148pub fn CFUUIDGetConstantUUIDWithBytes(
8150 alloc: CFAllocatorRef,
8151 byte0: UInt8,
8152 byte1: UInt8,
8153 byte2: UInt8,
8154 byte3: UInt8,
8155 byte4: UInt8,
8156 byte5: UInt8,
8157 byte6: UInt8,
8158 byte7: UInt8,
8159 byte8: UInt8,
8160 byte9: UInt8,
8161 byte10: UInt8,
8162 byte11: UInt8,
8163 byte12: UInt8,
8164 byte13: UInt8,
8165 byte14: UInt8,
8166 byte15: UInt8,
8167 ) -> CFUUIDRef;
8168}
8169extern "C" {
8170pub fn CFUUIDGetUUIDBytes(uuid: CFUUIDRef) -> CFUUIDBytes;
8172}
8173extern "C" {
8174pub fn CFUUIDCreateFromUUIDBytes(alloc: CFAllocatorRef, bytes: CFUUIDBytes) -> CFUUIDRef;
8176}
8177extern "C" {
8178pub fn CFCopyHomeDirectoryURL() -> CFURLRef;
8180}
8181pub type cpu_type_t = integer_t;
8183#[repr(C)]
8184#[derive(Debug, Copy, Clone)]
8185pub struct __CFBundle {
8187 _unused: [u8; 0],
8188}
8189pub type CFBundleRef = *mut __CFBundle;
8191pub type CFPlugInRef = *mut __CFBundle;
8193extern "C" {
8194pub static kCFBundleInfoDictionaryVersionKey: CFStringRef;
8196}
8197extern "C" {
8198pub static kCFBundleExecutableKey: CFStringRef;
8200}
8201extern "C" {
8202pub static kCFBundleIdentifierKey: CFStringRef;
8204}
8205extern "C" {
8206pub static kCFBundleVersionKey: CFStringRef;
8208}
8209extern "C" {
8210pub static kCFBundleDevelopmentRegionKey: CFStringRef;
8212}
8213extern "C" {
8214pub static kCFBundleNameKey: CFStringRef;
8216}
8217extern "C" {
8218pub static kCFBundleLocalizationsKey: CFStringRef;
8220}
8221extern "C" {
8222pub fn CFBundleGetMainBundle() -> CFBundleRef;
8224}
8225extern "C" {
8226pub fn CFBundleGetBundleWithIdentifier(bundleID: CFStringRef) -> CFBundleRef;
8228}
8229extern "C" {
8230pub fn CFBundleGetAllBundles() -> CFArrayRef;
8232}
8233extern "C" {
8234pub fn CFBundleGetTypeID() -> CFTypeID;
8236}
8237extern "C" {
8238pub fn CFBundleCreate(allocator: CFAllocatorRef, bundleURL: CFURLRef) -> CFBundleRef;
8240}
8241extern "C" {
8242pub fn CFBundleCreateBundlesFromDirectory(
8244 allocator: CFAllocatorRef,
8245 directoryURL: CFURLRef,
8246 bundleType: CFStringRef,
8247 ) -> CFArrayRef;
8248}
8249extern "C" {
8250pub fn CFBundleCopyBundleURL(bundle: CFBundleRef) -> CFURLRef;
8252}
8253extern "C" {
8254pub fn CFBundleGetValueForInfoDictionaryKey(bundle: CFBundleRef, key: CFStringRef)
8256 -> CFTypeRef;
8257}
8258extern "C" {
8259pub fn CFBundleGetInfoDictionary(bundle: CFBundleRef) -> CFDictionaryRef;
8261}
8262extern "C" {
8263pub fn CFBundleGetLocalInfoDictionary(bundle: CFBundleRef) -> CFDictionaryRef;
8265}
8266extern "C" {
8267pub fn CFBundleGetPackageInfo(
8269 bundle: CFBundleRef,
8270 packageType: *mut UInt32,
8271 packageCreator: *mut UInt32,
8272 );
8273}
8274extern "C" {
8275pub fn CFBundleGetIdentifier(bundle: CFBundleRef) -> CFStringRef;
8277}
8278extern "C" {
8279pub fn CFBundleGetVersionNumber(bundle: CFBundleRef) -> UInt32;
8281}
8282extern "C" {
8283pub fn CFBundleGetDevelopmentRegion(bundle: CFBundleRef) -> CFStringRef;
8285}
8286extern "C" {
8287pub fn CFBundleCopySupportFilesDirectoryURL(bundle: CFBundleRef) -> CFURLRef;
8289}
8290extern "C" {
8291pub fn CFBundleCopyResourcesDirectoryURL(bundle: CFBundleRef) -> CFURLRef;
8293}
8294extern "C" {
8295pub fn CFBundleCopyPrivateFrameworksURL(bundle: CFBundleRef) -> CFURLRef;
8297}
8298extern "C" {
8299pub fn CFBundleCopySharedFrameworksURL(bundle: CFBundleRef) -> CFURLRef;
8301}
8302extern "C" {
8303pub fn CFBundleCopySharedSupportURL(bundle: CFBundleRef) -> CFURLRef;
8305}
8306extern "C" {
8307pub fn CFBundleCopyBuiltInPlugInsURL(bundle: CFBundleRef) -> CFURLRef;
8309}
8310extern "C" {
8311pub fn CFBundleCopyInfoDictionaryInDirectory(bundleURL: CFURLRef) -> CFDictionaryRef;
8313}
8314extern "C" {
8315pub fn CFBundleGetPackageInfoInDirectory(
8317 url: CFURLRef,
8318 packageType: *mut UInt32,
8319 packageCreator: *mut UInt32,
8320 ) -> Boolean;
8321}
8322extern "C" {
8323pub fn CFBundleCopyResourceURL(
8325 bundle: CFBundleRef,
8326 resourceName: CFStringRef,
8327 resourceType: CFStringRef,
8328 subDirName: CFStringRef,
8329 ) -> CFURLRef;
8330}
8331extern "C" {
8332pub fn CFBundleCopyResourceURLsOfType(
8334 bundle: CFBundleRef,
8335 resourceType: CFStringRef,
8336 subDirName: CFStringRef,
8337 ) -> CFArrayRef;
8338}
8339extern "C" {
8340pub fn CFBundleCopyLocalizedString(
8342 bundle: CFBundleRef,
8343 key: CFStringRef,
8344 value: CFStringRef,
8345 tableName: CFStringRef,
8346 ) -> CFStringRef;
8347}
8348extern "C" {
8349pub fn CFBundleCopyLocalizedStringForLocalizations(
8351 bundle: CFBundleRef,
8352 key: CFStringRef,
8353 value: CFStringRef,
8354 tableName: CFStringRef,
8355 localizations: CFArrayRef,
8356 ) -> CFStringRef;
8357}
8358extern "C" {
8359pub fn CFBundleCopyResourceURLInDirectory(
8361 bundleURL: CFURLRef,
8362 resourceName: CFStringRef,
8363 resourceType: CFStringRef,
8364 subDirName: CFStringRef,
8365 ) -> CFURLRef;
8366}
8367extern "C" {
8368pub fn CFBundleCopyResourceURLsOfTypeInDirectory(
8370 bundleURL: CFURLRef,
8371 resourceType: CFStringRef,
8372 subDirName: CFStringRef,
8373 ) -> CFArrayRef;
8374}
8375extern "C" {
8376pub fn CFBundleCopyBundleLocalizations(bundle: CFBundleRef) -> CFArrayRef;
8378}
8379extern "C" {
8380pub fn CFBundleCopyPreferredLocalizationsFromArray(locArray: CFArrayRef) -> CFArrayRef;
8382}
8383extern "C" {
8384pub fn CFBundleCopyLocalizationsForPreferences(
8386 locArray: CFArrayRef,
8387 prefArray: CFArrayRef,
8388 ) -> CFArrayRef;
8389}
8390extern "C" {
8391pub fn CFBundleCopyResourceURLForLocalization(
8393 bundle: CFBundleRef,
8394 resourceName: CFStringRef,
8395 resourceType: CFStringRef,
8396 subDirName: CFStringRef,
8397 localizationName: CFStringRef,
8398 ) -> CFURLRef;
8399}
8400extern "C" {
8401pub fn CFBundleCopyResourceURLsOfTypeForLocalization(
8403 bundle: CFBundleRef,
8404 resourceType: CFStringRef,
8405 subDirName: CFStringRef,
8406 localizationName: CFStringRef,
8407 ) -> CFArrayRef;
8408}
8409extern "C" {
8410pub fn CFBundleCopyInfoDictionaryForURL(url: CFURLRef) -> CFDictionaryRef;
8412}
8413extern "C" {
8414pub fn CFBundleCopyLocalizationsForURL(url: CFURLRef) -> CFArrayRef;
8416}
8417extern "C" {
8418pub fn CFBundleCopyExecutableArchitecturesForURL(url: CFURLRef) -> CFArrayRef;
8420}
8421extern "C" {
8422pub fn CFBundleCopyExecutableURL(bundle: CFBundleRef) -> CFURLRef;
8424}
8425pub const kCFBundleExecutableArchitectureI386: _bindgen_ty_47 = 7;
8427pub const kCFBundleExecutableArchitecturePPC: _bindgen_ty_47 = 18;
8429pub const kCFBundleExecutableArchitectureX86_64: _bindgen_ty_47 = 16777223;
8431pub const kCFBundleExecutableArchitecturePPC64: _bindgen_ty_47 = 16777234;
8433pub const kCFBundleExecutableArchitectureARM64: _bindgen_ty_47 = 16777228;
8435pub type _bindgen_ty_47 = ::core::ffi::c_uint;
8437extern "C" {
8438pub fn CFBundleCopyExecutableArchitectures(bundle: CFBundleRef) -> CFArrayRef;
8440}
8441extern "C" {
8442pub fn CFBundlePreflightExecutable(bundle: CFBundleRef, error: *mut CFErrorRef) -> Boolean;
8444}
8445extern "C" {
8446pub fn CFBundleLoadExecutableAndReturnError(
8448 bundle: CFBundleRef,
8449 error: *mut CFErrorRef,
8450 ) -> Boolean;
8451}
8452extern "C" {
8453pub fn CFBundleLoadExecutable(bundle: CFBundleRef) -> Boolean;
8455}
8456extern "C" {
8457pub fn CFBundleIsExecutableLoaded(bundle: CFBundleRef) -> Boolean;
8459}
8460extern "C" {
8461pub fn CFBundleUnloadExecutable(bundle: CFBundleRef);
8463}
8464extern "C" {
8465pub fn CFBundleGetFunctionPointerForName(
8467 bundle: CFBundleRef,
8468 functionName: CFStringRef,
8469 ) -> *mut ::core::ffi::c_void;
8470}
8471extern "C" {
8472pub fn CFBundleGetFunctionPointersForNames(
8474 bundle: CFBundleRef,
8475 functionNames: CFArrayRef,
8476 ftbl: *mut *mut ::core::ffi::c_void,
8477 );
8478}
8479extern "C" {
8480pub fn CFBundleGetDataPointerForName(
8482 bundle: CFBundleRef,
8483 symbolName: CFStringRef,
8484 ) -> *mut ::core::ffi::c_void;
8485}
8486extern "C" {
8487pub fn CFBundleGetDataPointersForNames(
8489 bundle: CFBundleRef,
8490 symbolNames: CFArrayRef,
8491 stbl: *mut *mut ::core::ffi::c_void,
8492 );
8493}
8494extern "C" {
8495pub fn CFBundleCopyAuxiliaryExecutableURL(
8497 bundle: CFBundleRef,
8498 executableName: CFStringRef,
8499 ) -> CFURLRef;
8500}
8501extern "C" {
8502pub fn CFBundleIsExecutableLoadable(bundle: CFBundleRef) -> Boolean;
8504}
8505extern "C" {
8506pub fn CFBundleIsExecutableLoadableForURL(url: CFURLRef) -> Boolean;
8508}
8509extern "C" {
8510pub fn CFBundleIsArchitectureLoadable(arch: cpu_type_t) -> Boolean;
8512}
8513extern "C" {
8514pub fn CFBundleGetPlugIn(bundle: CFBundleRef) -> CFPlugInRef;
8516}
8517pub type CFBundleRefNum = ::core::ffi::c_int;
8519extern "C" {
8520pub fn CFBundleOpenBundleResourceMap(bundle: CFBundleRef) -> CFBundleRefNum;
8522}
8523extern "C" {
8524pub fn CFBundleOpenBundleResourceFiles(
8526 bundle: CFBundleRef,
8527 refNum: *mut CFBundleRefNum,
8528 localizedRefNum: *mut CFBundleRefNum,
8529 ) -> SInt32;
8530}
8531extern "C" {
8532pub fn CFBundleCloseBundleResourceMap(bundle: CFBundleRef, refNum: CFBundleRefNum);
8534}
8535#[repr(C)]
8536#[derive(Debug, Copy, Clone)]
8537pub struct __CFMessagePort {
8539 _unused: [u8; 0],
8540}
8541pub type CFMessagePortRef = *mut __CFMessagePort;
8543pub const kCFMessagePortSuccess: _bindgen_ty_48 = 0;
8545pub const kCFMessagePortSendTimeout: _bindgen_ty_48 = -1;
8547pub const kCFMessagePortReceiveTimeout: _bindgen_ty_48 = -2;
8549pub const kCFMessagePortIsInvalid: _bindgen_ty_48 = -3;
8551pub const kCFMessagePortTransportError: _bindgen_ty_48 = -4;
8553pub const kCFMessagePortBecameInvalidError: _bindgen_ty_48 = -5;
8555pub type _bindgen_ty_48 = ::core::ffi::c_int;
8557#[repr(C)]
8558#[derive(Debug, Copy, Clone)]
8559pub struct CFMessagePortContext {
8561 pub version: CFIndex,
8562 pub info: *mut ::core::ffi::c_void,
8563 pub retain: ::core::option::Option<
8564 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> *const ::core::ffi::c_void,
8565 >,
8566 pub release: ::core::option::Option<unsafe extern "C" fn(info: *const ::core::ffi::c_void)>,
8567 pub copyDescription: ::core::option::Option<
8568 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> CFStringRef,
8569 >,
8570}
8571pub type CFMessagePortCallBack = ::core::option::Option<
8573 unsafe extern "C" fn(
8574 local: CFMessagePortRef,
8575 msgid: SInt32,
8576 data: CFDataRef,
8577 info: *mut ::core::ffi::c_void,
8578 ) -> CFDataRef,
8579>;
8580pub type CFMessagePortInvalidationCallBack = ::core::option::Option<
8582 unsafe extern "C" fn(ms: CFMessagePortRef, info: *mut ::core::ffi::c_void),
8583>;
8584extern "C" {
8585pub fn CFMessagePortGetTypeID() -> CFTypeID;
8587}
8588extern "C" {
8589pub fn CFMessagePortCreateLocal(
8591 allocator: CFAllocatorRef,
8592 name: CFStringRef,
8593 callout: CFMessagePortCallBack,
8594 context: *mut CFMessagePortContext,
8595 shouldFreeInfo: *mut Boolean,
8596 ) -> CFMessagePortRef;
8597}
8598extern "C" {
8599pub fn CFMessagePortCreateRemote(
8601 allocator: CFAllocatorRef,
8602 name: CFStringRef,
8603 ) -> CFMessagePortRef;
8604}
8605extern "C" {
8606pub fn CFMessagePortIsRemote(ms: CFMessagePortRef) -> Boolean;
8608}
8609extern "C" {
8610pub fn CFMessagePortGetName(ms: CFMessagePortRef) -> CFStringRef;
8612}
8613extern "C" {
8614pub fn CFMessagePortSetName(ms: CFMessagePortRef, newName: CFStringRef) -> Boolean;
8616}
8617extern "C" {
8618pub fn CFMessagePortGetContext(ms: CFMessagePortRef, context: *mut CFMessagePortContext);
8620}
8621extern "C" {
8622pub fn CFMessagePortInvalidate(ms: CFMessagePortRef);
8624}
8625extern "C" {
8626pub fn CFMessagePortIsValid(ms: CFMessagePortRef) -> Boolean;
8628}
8629extern "C" {
8630pub fn CFMessagePortGetInvalidationCallBack(
8632 ms: CFMessagePortRef,
8633 ) -> CFMessagePortInvalidationCallBack;
8634}
8635extern "C" {
8636pub fn CFMessagePortSetInvalidationCallBack(
8638 ms: CFMessagePortRef,
8639 callout: CFMessagePortInvalidationCallBack,
8640 );
8641}
8642extern "C" {
8643pub fn CFMessagePortSendRequest(
8645 remote: CFMessagePortRef,
8646 msgid: SInt32,
8647 data: CFDataRef,
8648 sendTimeout: CFTimeInterval,
8649 rcvTimeout: CFTimeInterval,
8650 replyMode: CFStringRef,
8651 returnData: *mut CFDataRef,
8652 ) -> SInt32;
8653}
8654extern "C" {
8655pub fn CFMessagePortCreateRunLoopSource(
8657 allocator: CFAllocatorRef,
8658 local: CFMessagePortRef,
8659 order: CFIndex,
8660 ) -> CFRunLoopSourceRef;
8661}
8662extern "C" {
8663pub fn CFMessagePortSetDispatchQueue(ms: CFMessagePortRef, queue: dispatch_queue_t);
8665}
8666extern "C" {
8667pub static kCFPlugInDynamicRegistrationKey: CFStringRef;
8669}
8670extern "C" {
8671pub static kCFPlugInDynamicRegisterFunctionKey: CFStringRef;
8673}
8674extern "C" {
8675pub static kCFPlugInUnloadFunctionKey: CFStringRef;
8677}
8678extern "C" {
8679pub static kCFPlugInFactoriesKey: CFStringRef;
8681}
8682extern "C" {
8683pub static kCFPlugInTypesKey: CFStringRef;
8685}
8686pub type CFPlugInDynamicRegisterFunction =
8688 ::core::option::Option<unsafe extern "C" fn(plugIn: CFPlugInRef)>;
8689pub type CFPlugInUnloadFunction = ::core::option::Option<unsafe extern "C" fn(plugIn: CFPlugInRef)>;
8691pub type CFPlugInFactoryFunction = ::core::option::Option<
8693 unsafe extern "C" fn(
8694 allocator: CFAllocatorRef,
8695 typeUUID: CFUUIDRef,
8696 ) -> *mut ::core::ffi::c_void,
8697>;
8698extern "C" {
8699pub fn CFPlugInGetTypeID() -> CFTypeID;
8701}
8702extern "C" {
8703pub fn CFPlugInCreate(allocator: CFAllocatorRef, plugInURL: CFURLRef) -> CFPlugInRef;
8705}
8706extern "C" {
8707pub fn CFPlugInGetBundle(plugIn: CFPlugInRef) -> CFBundleRef;
8709}
8710extern "C" {
8711pub fn CFPlugInSetLoadOnDemand(plugIn: CFPlugInRef, flag: Boolean);
8713}
8714extern "C" {
8715pub fn CFPlugInIsLoadOnDemand(plugIn: CFPlugInRef) -> Boolean;
8717}
8718extern "C" {
8719pub fn CFPlugInFindFactoriesForPlugInType(typeUUID: CFUUIDRef) -> CFArrayRef;
8721}
8722extern "C" {
8723pub fn CFPlugInFindFactoriesForPlugInTypeInPlugIn(
8725 typeUUID: CFUUIDRef,
8726 plugIn: CFPlugInRef,
8727 ) -> CFArrayRef;
8728}
8729extern "C" {
8730pub fn CFPlugInInstanceCreate(
8732 allocator: CFAllocatorRef,
8733 factoryUUID: CFUUIDRef,
8734 typeUUID: CFUUIDRef,
8735 ) -> *mut ::core::ffi::c_void;
8736}
8737extern "C" {
8738pub fn CFPlugInRegisterFactoryFunction(
8740 factoryUUID: CFUUIDRef,
8741 func: CFPlugInFactoryFunction,
8742 ) -> Boolean;
8743}
8744extern "C" {
8745pub fn CFPlugInRegisterFactoryFunctionByName(
8747 factoryUUID: CFUUIDRef,
8748 plugIn: CFPlugInRef,
8749 functionName: CFStringRef,
8750 ) -> Boolean;
8751}
8752extern "C" {
8753pub fn CFPlugInUnregisterFactory(factoryUUID: CFUUIDRef) -> Boolean;
8755}
8756extern "C" {
8757pub fn CFPlugInRegisterPlugInType(factoryUUID: CFUUIDRef, typeUUID: CFUUIDRef) -> Boolean;
8759}
8760extern "C" {
8761pub fn CFPlugInUnregisterPlugInType(factoryUUID: CFUUIDRef, typeUUID: CFUUIDRef) -> Boolean;
8763}
8764extern "C" {
8765pub fn CFPlugInAddInstanceForFactory(factoryID: CFUUIDRef);
8767}
8768extern "C" {
8769pub fn CFPlugInRemoveInstanceForFactory(factoryID: CFUUIDRef);
8771}
8772#[repr(C)]
8773#[derive(Debug, Copy, Clone)]
8774pub struct __CFPlugInInstance {
8776 _unused: [u8; 0],
8777}
8778pub type CFPlugInInstanceRef = *mut __CFPlugInInstance;
8780pub type CFPlugInInstanceGetInterfaceFunction = ::core::option::Option<
8782 unsafe extern "C" fn(
8783 instance: CFPlugInInstanceRef,
8784 interfaceName: CFStringRef,
8785 ftbl: *mut *mut ::core::ffi::c_void,
8786 ) -> Boolean,
8787>;
8788pub type CFPlugInInstanceDeallocateInstanceDataFunction =
8790 ::core::option::Option<unsafe extern "C" fn(instanceData: *mut ::core::ffi::c_void)>;
8791extern "C" {
8792pub fn CFPlugInInstanceGetInterfaceFunctionTable(
8794 instance: CFPlugInInstanceRef,
8795 interfaceName: CFStringRef,
8796 ftbl: *mut *mut ::core::ffi::c_void,
8797 ) -> Boolean;
8798}
8799extern "C" {
8800pub fn CFPlugInInstanceGetFactoryName(instance: CFPlugInInstanceRef) -> CFStringRef;
8802}
8803extern "C" {
8804pub fn CFPlugInInstanceGetInstanceData(
8806 instance: CFPlugInInstanceRef,
8807 ) -> *mut ::core::ffi::c_void;
8808}
8809extern "C" {
8810pub fn CFPlugInInstanceGetTypeID() -> CFTypeID;
8812}
8813extern "C" {
8814pub fn CFPlugInInstanceCreateWithInstanceDataSize(
8816 allocator: CFAllocatorRef,
8817 instanceDataSize: CFIndex,
8818 deallocateInstanceFunction: CFPlugInInstanceDeallocateInstanceDataFunction,
8819 factoryName: CFStringRef,
8820 getInterfaceFunction: CFPlugInInstanceGetInterfaceFunction,
8821 ) -> CFPlugInInstanceRef;
8822}
8823#[repr(C)]
8824#[derive(Debug, Copy, Clone)]
8825pub struct __CFMachPort {
8827 _unused: [u8; 0],
8828}
8829pub type CFMachPortRef = *mut __CFMachPort;
8831#[repr(C)]
8832#[derive(Debug, Copy, Clone)]
8833pub struct CFMachPortContext {
8835 pub version: CFIndex,
8836 pub info: *mut ::core::ffi::c_void,
8837 pub retain: ::core::option::Option<
8838 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> *const ::core::ffi::c_void,
8839 >,
8840 pub release: ::core::option::Option<unsafe extern "C" fn(info: *const ::core::ffi::c_void)>,
8841 pub copyDescription: ::core::option::Option<
8842 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> CFStringRef,
8843 >,
8844}
8845pub type CFMachPortCallBack = ::core::option::Option<
8847 unsafe extern "C" fn(
8848 port: CFMachPortRef,
8849 msg: *mut ::core::ffi::c_void,
8850 size: CFIndex,
8851 info: *mut ::core::ffi::c_void,
8852 ),
8853>;
8854pub type CFMachPortInvalidationCallBack = ::core::option::Option<
8856 unsafe extern "C" fn(port: CFMachPortRef, info: *mut ::core::ffi::c_void),
8857>;
8858extern "C" {
8859pub fn CFMachPortGetTypeID() -> CFTypeID;
8861}
8862extern "C" {
8863pub fn CFMachPortCreate(
8865 allocator: CFAllocatorRef,
8866 callout: CFMachPortCallBack,
8867 context: *mut CFMachPortContext,
8868 shouldFreeInfo: *mut Boolean,
8869 ) -> CFMachPortRef;
8870}
8871extern "C" {
8872pub fn CFMachPortCreateWithPort(
8874 allocator: CFAllocatorRef,
8875 portNum: mach_port_t,
8876 callout: CFMachPortCallBack,
8877 context: *mut CFMachPortContext,
8878 shouldFreeInfo: *mut Boolean,
8879 ) -> CFMachPortRef;
8880}
8881extern "C" {
8882pub fn CFMachPortGetPort(port: CFMachPortRef) -> mach_port_t;
8884}
8885extern "C" {
8886pub fn CFMachPortGetContext(port: CFMachPortRef, context: *mut CFMachPortContext);
8888}
8889extern "C" {
8890pub fn CFMachPortInvalidate(port: CFMachPortRef);
8892}
8893extern "C" {
8894pub fn CFMachPortIsValid(port: CFMachPortRef) -> Boolean;
8896}
8897extern "C" {
8898pub fn CFMachPortGetInvalidationCallBack(port: CFMachPortRef)
8900 -> CFMachPortInvalidationCallBack;
8901}
8902extern "C" {
8903pub fn CFMachPortSetInvalidationCallBack(
8905 port: CFMachPortRef,
8906 callout: CFMachPortInvalidationCallBack,
8907 );
8908}
8909extern "C" {
8910pub fn CFMachPortCreateRunLoopSource(
8912 allocator: CFAllocatorRef,
8913 port: CFMachPortRef,
8914 order: CFIndex,
8915 ) -> CFRunLoopSourceRef;
8916}
8917#[repr(C)]
8918#[derive(Debug, Copy, Clone)]
8919pub struct __CFAttributedString {
8921 _unused: [u8; 0],
8922}
8923pub type CFAttributedStringRef = *const __CFAttributedString;
8925pub type CFMutableAttributedStringRef = *mut __CFAttributedString;
8927extern "C" {
8928pub fn CFAttributedStringGetTypeID() -> CFTypeID;
8930}
8931extern "C" {
8932pub fn CFAttributedStringCreate(
8934 alloc: CFAllocatorRef,
8935 str_: CFStringRef,
8936 attributes: CFDictionaryRef,
8937 ) -> CFAttributedStringRef;
8938}
8939extern "C" {
8940pub fn CFAttributedStringCreateWithSubstring(
8942 alloc: CFAllocatorRef,
8943 aStr: CFAttributedStringRef,
8944 range: CFRange,
8945 ) -> CFAttributedStringRef;
8946}
8947extern "C" {
8948pub fn CFAttributedStringCreateCopy(
8950 alloc: CFAllocatorRef,
8951 aStr: CFAttributedStringRef,
8952 ) -> CFAttributedStringRef;
8953}
8954extern "C" {
8955pub fn CFAttributedStringGetString(aStr: CFAttributedStringRef) -> CFStringRef;
8957}
8958extern "C" {
8959pub fn CFAttributedStringGetLength(aStr: CFAttributedStringRef) -> CFIndex;
8961}
8962extern "C" {
8963pub fn CFAttributedStringGetAttributes(
8965 aStr: CFAttributedStringRef,
8966 loc: CFIndex,
8967 effectiveRange: *mut CFRange,
8968 ) -> CFDictionaryRef;
8969}
8970extern "C" {
8971pub fn CFAttributedStringGetAttribute(
8973 aStr: CFAttributedStringRef,
8974 loc: CFIndex,
8975 attrName: CFStringRef,
8976 effectiveRange: *mut CFRange,
8977 ) -> CFTypeRef;
8978}
8979extern "C" {
8980pub fn CFAttributedStringGetAttributesAndLongestEffectiveRange(
8982 aStr: CFAttributedStringRef,
8983 loc: CFIndex,
8984 inRange: CFRange,
8985 longestEffectiveRange: *mut CFRange,
8986 ) -> CFDictionaryRef;
8987}
8988extern "C" {
8989pub fn CFAttributedStringGetAttributeAndLongestEffectiveRange(
8991 aStr: CFAttributedStringRef,
8992 loc: CFIndex,
8993 attrName: CFStringRef,
8994 inRange: CFRange,
8995 longestEffectiveRange: *mut CFRange,
8996 ) -> CFTypeRef;
8997}
8998extern "C" {
8999pub fn CFAttributedStringCreateMutableCopy(
9001 alloc: CFAllocatorRef,
9002 maxLength: CFIndex,
9003 aStr: CFAttributedStringRef,
9004 ) -> CFMutableAttributedStringRef;
9005}
9006extern "C" {
9007pub fn CFAttributedStringCreateMutable(
9009 alloc: CFAllocatorRef,
9010 maxLength: CFIndex,
9011 ) -> CFMutableAttributedStringRef;
9012}
9013extern "C" {
9014pub fn CFAttributedStringReplaceString(
9016 aStr: CFMutableAttributedStringRef,
9017 range: CFRange,
9018 replacement: CFStringRef,
9019 );
9020}
9021extern "C" {
9022pub fn CFAttributedStringGetMutableString(
9024 aStr: CFMutableAttributedStringRef,
9025 ) -> CFMutableStringRef;
9026}
9027extern "C" {
9028pub fn CFAttributedStringSetAttributes(
9030 aStr: CFMutableAttributedStringRef,
9031 range: CFRange,
9032 replacement: CFDictionaryRef,
9033 clearOtherAttributes: Boolean,
9034 );
9035}
9036extern "C" {
9037pub fn CFAttributedStringSetAttribute(
9039 aStr: CFMutableAttributedStringRef,
9040 range: CFRange,
9041 attrName: CFStringRef,
9042 value: CFTypeRef,
9043 );
9044}
9045extern "C" {
9046pub fn CFAttributedStringRemoveAttribute(
9048 aStr: CFMutableAttributedStringRef,
9049 range: CFRange,
9050 attrName: CFStringRef,
9051 );
9052}
9053extern "C" {
9054pub fn CFAttributedStringReplaceAttributedString(
9056 aStr: CFMutableAttributedStringRef,
9057 range: CFRange,
9058 replacement: CFAttributedStringRef,
9059 );
9060}
9061extern "C" {
9062pub fn CFAttributedStringBeginEditing(aStr: CFMutableAttributedStringRef);
9064}
9065extern "C" {
9066pub fn CFAttributedStringEndEditing(aStr: CFMutableAttributedStringRef);
9068}
9069extern "C" {
9070pub fn CFAttributedStringGetBidiLevelsAndResolvedDirections(
9072 attributedString: CFAttributedStringRef,
9073 range: CFRange,
9074 baseDirection: i8,
9075 bidiLevels: *mut u8,
9076 baseDirections: *mut u8,
9077 ) -> bool;
9078}
9079extern "C" {
9080pub fn CFAttributedStringGetStatisticalWritingDirections(
9082 attributedString: CFAttributedStringRef,
9083 range: CFRange,
9084 baseDirection: i8,
9085 bidiLevels: *mut u8,
9086 baseDirections: *mut u8,
9087 ) -> bool;
9088}
9089#[repr(C)]
9090#[derive(Debug, Copy, Clone)]
9091pub struct __CFURLEnumerator {
9093 _unused: [u8; 0],
9094}
9095pub type CFURLEnumeratorRef = *const __CFURLEnumerator;
9097extern "C" {
9098pub fn CFURLEnumeratorGetTypeID() -> CFTypeID;
9100}
9101pub type CFURLEnumeratorOptions = CFOptionFlags;
9103pub const kCFURLEnumeratorDefaultBehavior: _bindgen_ty_49 = 0;
9105pub const kCFURLEnumeratorDescendRecursively: _bindgen_ty_49 = 1;
9107pub const kCFURLEnumeratorSkipInvisibles: _bindgen_ty_49 = 2;
9109pub const kCFURLEnumeratorGenerateFileReferenceURLs: _bindgen_ty_49 = 4;
9111pub const kCFURLEnumeratorSkipPackageContents: _bindgen_ty_49 = 8;
9113pub const kCFURLEnumeratorIncludeDirectoriesPreOrder: _bindgen_ty_49 = 16;
9115pub const kCFURLEnumeratorIncludeDirectoriesPostOrder: _bindgen_ty_49 = 32;
9117pub const kCFURLEnumeratorGenerateRelativePathURLs: _bindgen_ty_49 = 64;
9119pub type _bindgen_ty_49 = ::core::ffi::c_uint;
9121extern "C" {
9122pub fn CFURLEnumeratorCreateForDirectoryURL(
9124 alloc: CFAllocatorRef,
9125 directoryURL: CFURLRef,
9126 option: CFURLEnumeratorOptions,
9127 propertyKeys: CFArrayRef,
9128 ) -> CFURLEnumeratorRef;
9129}
9130extern "C" {
9131pub fn CFURLEnumeratorCreateForMountedVolumes(
9133 alloc: CFAllocatorRef,
9134 option: CFURLEnumeratorOptions,
9135 propertyKeys: CFArrayRef,
9136 ) -> CFURLEnumeratorRef;
9137}
9138pub type CFURLEnumeratorResult = CFIndex;
9140pub const kCFURLEnumeratorSuccess: _bindgen_ty_50 = 1;
9142pub const kCFURLEnumeratorEnd: _bindgen_ty_50 = 2;
9144pub const kCFURLEnumeratorError: _bindgen_ty_50 = 3;
9146pub const kCFURLEnumeratorDirectoryPostOrderSuccess: _bindgen_ty_50 = 4;
9148pub type _bindgen_ty_50 = ::core::ffi::c_uint;
9150extern "C" {
9151pub fn CFURLEnumeratorGetNextURL(
9153 enumerator: CFURLEnumeratorRef,
9154 url: *mut CFURLRef,
9155 error: *mut CFErrorRef,
9156 ) -> CFURLEnumeratorResult;
9157}
9158extern "C" {
9159pub fn CFURLEnumeratorSkipDescendents(enumerator: CFURLEnumeratorRef);
9161}
9162extern "C" {
9163pub fn CFURLEnumeratorGetDescendentLevel(enumerator: CFURLEnumeratorRef) -> CFIndex;
9165}
9166extern "C" {
9167pub fn CFURLEnumeratorGetSourceDidChange(enumerator: CFURLEnumeratorRef) -> Boolean;
9169}
9170#[repr(C)]
9171#[derive(Debug, Copy, Clone)]
9172pub struct _acl {
9174 _unused: [u8; 0],
9175}
9176pub type acl_t = *mut _acl;
9178#[repr(C)]
9179#[derive(Debug, Copy, Clone)]
9180pub struct __CFFileSecurity {
9182 _unused: [u8; 0],
9183}
9184pub type CFFileSecurityRef = *mut __CFFileSecurity;
9186extern "C" {
9187pub fn CFFileSecurityGetTypeID() -> CFTypeID;
9189}
9190extern "C" {
9191pub fn CFFileSecurityCreate(allocator: CFAllocatorRef) -> CFFileSecurityRef;
9193}
9194extern "C" {
9195pub fn CFFileSecurityCreateCopy(
9197 allocator: CFAllocatorRef,
9198 fileSec: CFFileSecurityRef,
9199 ) -> CFFileSecurityRef;
9200}
9201extern "C" {
9202pub fn CFFileSecurityCopyOwnerUUID(
9204 fileSec: CFFileSecurityRef,
9205 ownerUUID: *mut CFUUIDRef,
9206 ) -> Boolean;
9207}
9208extern "C" {
9209pub fn CFFileSecuritySetOwnerUUID(fileSec: CFFileSecurityRef, ownerUUID: CFUUIDRef) -> Boolean;
9211}
9212extern "C" {
9213pub fn CFFileSecurityCopyGroupUUID(
9215 fileSec: CFFileSecurityRef,
9216 groupUUID: *mut CFUUIDRef,
9217 ) -> Boolean;
9218}
9219extern "C" {
9220pub fn CFFileSecuritySetGroupUUID(fileSec: CFFileSecurityRef, groupUUID: CFUUIDRef) -> Boolean;
9222}
9223extern "C" {
9224pub fn CFFileSecurityCopyAccessControlList(
9226 fileSec: CFFileSecurityRef,
9227 accessControlList: *mut acl_t,
9228 ) -> Boolean;
9229}
9230extern "C" {
9231pub fn CFFileSecuritySetAccessControlList(
9233 fileSec: CFFileSecurityRef,
9234 accessControlList: acl_t,
9235 ) -> Boolean;
9236}
9237extern "C" {
9238pub fn CFFileSecurityGetOwner(fileSec: CFFileSecurityRef, owner: *mut uid_t) -> Boolean;
9240}
9241extern "C" {
9242pub fn CFFileSecuritySetOwner(fileSec: CFFileSecurityRef, owner: uid_t) -> Boolean;
9244}
9245extern "C" {
9246pub fn CFFileSecurityGetGroup(fileSec: CFFileSecurityRef, group: *mut gid_t) -> Boolean;
9248}
9249extern "C" {
9250pub fn CFFileSecuritySetGroup(fileSec: CFFileSecurityRef, group: gid_t) -> Boolean;
9252}
9253extern "C" {
9254pub fn CFFileSecurityGetMode(fileSec: CFFileSecurityRef, mode: *mut mode_t) -> Boolean;
9256}
9257extern "C" {
9258pub fn CFFileSecuritySetMode(fileSec: CFFileSecurityRef, mode: mode_t) -> Boolean;
9260}
9261pub type CFFileSecurityClearOptions = CFOptionFlags;
9263pub const kCFFileSecurityClearOwner: _bindgen_ty_51 = 1;
9265pub const kCFFileSecurityClearGroup: _bindgen_ty_51 = 2;
9267pub const kCFFileSecurityClearMode: _bindgen_ty_51 = 4;
9269pub const kCFFileSecurityClearOwnerUUID: _bindgen_ty_51 = 8;
9271pub const kCFFileSecurityClearGroupUUID: _bindgen_ty_51 = 16;
9273pub const kCFFileSecurityClearAccessControlList: _bindgen_ty_51 = 32;
9275pub type _bindgen_ty_51 = ::core::ffi::c_uint;
9277extern "C" {
9278pub fn CFFileSecurityClearProperties(
9280 fileSec: CFFileSecurityRef,
9281 clearPropertyMask: CFFileSecurityClearOptions,
9282 ) -> Boolean;
9283}
9284extern "C" {
9285pub fn CFStringTokenizerCopyBestStringLanguage(
9287 string: CFStringRef,
9288 range: CFRange,
9289 ) -> CFStringRef;
9290}
9291#[repr(C)]
9292#[derive(Debug, Copy, Clone)]
9293pub struct __CFStringTokenizer {
9295 _unused: [u8; 0],
9296}
9297pub type CFStringTokenizerRef = *mut __CFStringTokenizer;
9299pub const kCFStringTokenizerUnitWord: _bindgen_ty_52 = 0;
9301pub const kCFStringTokenizerUnitSentence: _bindgen_ty_52 = 1;
9303pub const kCFStringTokenizerUnitParagraph: _bindgen_ty_52 = 2;
9305pub const kCFStringTokenizerUnitLineBreak: _bindgen_ty_52 = 3;
9307pub const kCFStringTokenizerUnitWordBoundary: _bindgen_ty_52 = 4;
9309pub const kCFStringTokenizerAttributeLatinTranscription: _bindgen_ty_52 = 65536;
9311pub const kCFStringTokenizerAttributeLanguage: _bindgen_ty_52 = 131072;
9313pub type _bindgen_ty_52 = ::core::ffi::c_uint;
9315pub type CFStringTokenizerTokenType = CFOptionFlags;
9317pub const kCFStringTokenizerTokenNone: _bindgen_ty_53 = 0;
9319pub const kCFStringTokenizerTokenNormal: _bindgen_ty_53 = 1;
9321pub const kCFStringTokenizerTokenHasSubTokensMask: _bindgen_ty_53 = 2;
9323pub const kCFStringTokenizerTokenHasDerivedSubTokensMask: _bindgen_ty_53 = 4;
9325pub const kCFStringTokenizerTokenHasHasNumbersMask: _bindgen_ty_53 = 8;
9327pub const kCFStringTokenizerTokenHasNonLettersMask: _bindgen_ty_53 = 16;
9329pub const kCFStringTokenizerTokenIsCJWordMask: _bindgen_ty_53 = 32;
9331pub type _bindgen_ty_53 = ::core::ffi::c_uint;
9333extern "C" {
9334pub fn CFStringTokenizerGetTypeID() -> CFTypeID;
9336}
9337extern "C" {
9338pub fn CFStringTokenizerCreate(
9340 alloc: CFAllocatorRef,
9341 string: CFStringRef,
9342 range: CFRange,
9343 options: CFOptionFlags,
9344 locale: CFLocaleRef,
9345 ) -> CFStringTokenizerRef;
9346}
9347extern "C" {
9348pub fn CFStringTokenizerSetString(
9350 tokenizer: CFStringTokenizerRef,
9351 string: CFStringRef,
9352 range: CFRange,
9353 );
9354}
9355extern "C" {
9356pub fn CFStringTokenizerGoToTokenAtIndex(
9358 tokenizer: CFStringTokenizerRef,
9359 index: CFIndex,
9360 ) -> CFStringTokenizerTokenType;
9361}
9362extern "C" {
9363pub fn CFStringTokenizerAdvanceToNextToken(
9365 tokenizer: CFStringTokenizerRef,
9366 ) -> CFStringTokenizerTokenType;
9367}
9368extern "C" {
9369pub fn CFStringTokenizerGetCurrentTokenRange(tokenizer: CFStringTokenizerRef) -> CFRange;
9371}
9372extern "C" {
9373pub fn CFStringTokenizerCopyCurrentTokenAttribute(
9375 tokenizer: CFStringTokenizerRef,
9376 attribute: CFOptionFlags,
9377 ) -> CFTypeRef;
9378}
9379extern "C" {
9380pub fn CFStringTokenizerGetCurrentSubTokens(
9382 tokenizer: CFStringTokenizerRef,
9383 ranges: *mut CFRange,
9384 maxRangeLength: CFIndex,
9385 derivedSubTokens: CFMutableArrayRef,
9386 ) -> CFIndex;
9387}
9388pub type CFFileDescriptorNativeDescriptor = ::core::ffi::c_int;
9390#[repr(C)]
9391#[derive(Debug, Copy, Clone)]
9392pub struct __CFFileDescriptor {
9394 _unused: [u8; 0],
9395}
9396pub type CFFileDescriptorRef = *mut __CFFileDescriptor;
9398pub const kCFFileDescriptorReadCallBack: _bindgen_ty_54 = 1;
9400pub const kCFFileDescriptorWriteCallBack: _bindgen_ty_54 = 2;
9402pub type _bindgen_ty_54 = ::core::ffi::c_uint;
9404pub type CFFileDescriptorCallBack = ::core::option::Option<
9406 unsafe extern "C" fn(
9407 f: CFFileDescriptorRef,
9408 callBackTypes: CFOptionFlags,
9409 info: *mut ::core::ffi::c_void,
9410 ),
9411>;
9412#[repr(C)]
9413#[derive(Debug, Copy, Clone)]
9414pub struct CFFileDescriptorContext {
9416 pub version: CFIndex,
9417 pub info: *mut ::core::ffi::c_void,
9418 pub retain: ::core::option::Option<
9419 unsafe extern "C" fn(info: *mut ::core::ffi::c_void) -> *mut ::core::ffi::c_void,
9420 >,
9421 pub release: ::core::option::Option<unsafe extern "C" fn(info: *mut ::core::ffi::c_void)>,
9422 pub copyDescription:
9423 ::core::option::Option<unsafe extern "C" fn(info: *mut ::core::ffi::c_void) -> CFStringRef>,
9424}
9425extern "C" {
9426pub fn CFFileDescriptorGetTypeID() -> CFTypeID;
9428}
9429extern "C" {
9430pub fn CFFileDescriptorCreate(
9432 allocator: CFAllocatorRef,
9433 fd: CFFileDescriptorNativeDescriptor,
9434 closeOnInvalidate: Boolean,
9435 callout: CFFileDescriptorCallBack,
9436 context: *const CFFileDescriptorContext,
9437 ) -> CFFileDescriptorRef;
9438}
9439extern "C" {
9440pub fn CFFileDescriptorGetNativeDescriptor(
9442 f: CFFileDescriptorRef,
9443 ) -> CFFileDescriptorNativeDescriptor;
9444}
9445extern "C" {
9446pub fn CFFileDescriptorGetContext(
9448 f: CFFileDescriptorRef,
9449 context: *mut CFFileDescriptorContext,
9450 );
9451}
9452extern "C" {
9453pub fn CFFileDescriptorEnableCallBacks(f: CFFileDescriptorRef, callBackTypes: CFOptionFlags);
9455}
9456extern "C" {
9457pub fn CFFileDescriptorDisableCallBacks(f: CFFileDescriptorRef, callBackTypes: CFOptionFlags);
9459}
9460extern "C" {
9461pub fn CFFileDescriptorInvalidate(f: CFFileDescriptorRef);
9463}
9464extern "C" {
9465pub fn CFFileDescriptorIsValid(f: CFFileDescriptorRef) -> Boolean;
9467}
9468extern "C" {
9469pub fn CFFileDescriptorCreateRunLoopSource(
9471 allocator: CFAllocatorRef,
9472 f: CFFileDescriptorRef,
9473 order: CFIndex,
9474 ) -> CFRunLoopSourceRef;
9475}
9476#[repr(C)]
9477#[derive(Debug, Copy, Clone)]
9478pub struct __CFUserNotification {
9480 _unused: [u8; 0],
9481}
9482pub type CFUserNotificationRef = *mut __CFUserNotification;
9484pub type CFUserNotificationCallBack = ::core::option::Option<
9486 unsafe extern "C" fn(userNotification: CFUserNotificationRef, responseFlags: CFOptionFlags),
9487>;
9488extern "C" {
9489pub fn CFUserNotificationGetTypeID() -> CFTypeID;
9491}
9492extern "C" {
9493pub fn CFUserNotificationCreate(
9495 allocator: CFAllocatorRef,
9496 timeout: CFTimeInterval,
9497 flags: CFOptionFlags,
9498 error: *mut SInt32,
9499 dictionary: CFDictionaryRef,
9500 ) -> CFUserNotificationRef;
9501}
9502extern "C" {
9503pub fn CFUserNotificationReceiveResponse(
9505 userNotification: CFUserNotificationRef,
9506 timeout: CFTimeInterval,
9507 responseFlags: *mut CFOptionFlags,
9508 ) -> SInt32;
9509}
9510extern "C" {
9511pub fn CFUserNotificationGetResponseValue(
9513 userNotification: CFUserNotificationRef,
9514 key: CFStringRef,
9515 idx: CFIndex,
9516 ) -> CFStringRef;
9517}
9518extern "C" {
9519pub fn CFUserNotificationGetResponseDictionary(
9521 userNotification: CFUserNotificationRef,
9522 ) -> CFDictionaryRef;
9523}
9524extern "C" {
9525pub fn CFUserNotificationUpdate(
9527 userNotification: CFUserNotificationRef,
9528 timeout: CFTimeInterval,
9529 flags: CFOptionFlags,
9530 dictionary: CFDictionaryRef,
9531 ) -> SInt32;
9532}
9533extern "C" {
9534pub fn CFUserNotificationCancel(userNotification: CFUserNotificationRef) -> SInt32;
9536}
9537extern "C" {
9538pub fn CFUserNotificationCreateRunLoopSource(
9540 allocator: CFAllocatorRef,
9541 userNotification: CFUserNotificationRef,
9542 callout: CFUserNotificationCallBack,
9543 order: CFIndex,
9544 ) -> CFRunLoopSourceRef;
9545}
9546extern "C" {
9547pub fn CFUserNotificationDisplayNotice(
9549 timeout: CFTimeInterval,
9550 flags: CFOptionFlags,
9551 iconURL: CFURLRef,
9552 soundURL: CFURLRef,
9553 localizationURL: CFURLRef,
9554 alertHeader: CFStringRef,
9555 alertMessage: CFStringRef,
9556 defaultButtonTitle: CFStringRef,
9557 ) -> SInt32;
9558}
9559extern "C" {
9560pub fn CFUserNotificationDisplayAlert(
9562 timeout: CFTimeInterval,
9563 flags: CFOptionFlags,
9564 iconURL: CFURLRef,
9565 soundURL: CFURLRef,
9566 localizationURL: CFURLRef,
9567 alertHeader: CFStringRef,
9568 alertMessage: CFStringRef,
9569 defaultButtonTitle: CFStringRef,
9570 alternateButtonTitle: CFStringRef,
9571 otherButtonTitle: CFStringRef,
9572 responseFlags: *mut CFOptionFlags,
9573 ) -> SInt32;
9574}
9575pub const kCFUserNotificationStopAlertLevel: _bindgen_ty_55 = 0;
9577pub const kCFUserNotificationNoteAlertLevel: _bindgen_ty_55 = 1;
9579pub const kCFUserNotificationCautionAlertLevel: _bindgen_ty_55 = 2;
9581pub const kCFUserNotificationPlainAlertLevel: _bindgen_ty_55 = 3;
9583pub type _bindgen_ty_55 = ::core::ffi::c_uint;
9585pub const kCFUserNotificationDefaultResponse: _bindgen_ty_56 = 0;
9587pub const kCFUserNotificationAlternateResponse: _bindgen_ty_56 = 1;
9589pub const kCFUserNotificationOtherResponse: _bindgen_ty_56 = 2;
9591pub const kCFUserNotificationCancelResponse: _bindgen_ty_56 = 3;
9593pub type _bindgen_ty_56 = ::core::ffi::c_uint;
9595pub const kCFUserNotificationNoDefaultButtonFlag: _bindgen_ty_57 = 32;
9597pub const kCFUserNotificationUseRadioButtonsFlag: _bindgen_ty_57 = 64;
9599pub type _bindgen_ty_57 = ::core::ffi::c_uint;
9601extern "C" {
9602pub static kCFUserNotificationIconURLKey: CFStringRef;
9604}
9605extern "C" {
9606pub static kCFUserNotificationSoundURLKey: CFStringRef;
9608}
9609extern "C" {
9610pub static kCFUserNotificationLocalizationURLKey: CFStringRef;
9612}
9613extern "C" {
9614pub static kCFUserNotificationAlertHeaderKey: CFStringRef;
9616}
9617extern "C" {
9618pub static kCFUserNotificationAlertMessageKey: CFStringRef;
9620}
9621extern "C" {
9622pub static kCFUserNotificationDefaultButtonTitleKey: CFStringRef;
9624}
9625extern "C" {
9626pub static kCFUserNotificationAlternateButtonTitleKey: CFStringRef;
9628}
9629extern "C" {
9630pub static kCFUserNotificationOtherButtonTitleKey: CFStringRef;
9632}
9633extern "C" {
9634pub static kCFUserNotificationProgressIndicatorValueKey: CFStringRef;
9636}
9637extern "C" {
9638pub static kCFUserNotificationPopUpTitlesKey: CFStringRef;
9640}
9641extern "C" {
9642pub static kCFUserNotificationTextFieldTitlesKey: CFStringRef;
9644}
9645extern "C" {
9646pub static kCFUserNotificationCheckBoxTitlesKey: CFStringRef;
9648}
9649extern "C" {
9650pub static kCFUserNotificationTextFieldValuesKey: CFStringRef;
9652}
9653extern "C" {
9654pub static kCFUserNotificationPopUpSelectionKey: CFStringRef;
9656}
9657extern "C" {
9658pub static kCFUserNotificationAlertTopMostKey: CFStringRef;
9660}
9661extern "C" {
9662pub static kCFUserNotificationKeyboardTypesKey: CFStringRef;
9664}
9665extern "C" {
9666pub static kCFUserNotificationAlertAccessibilityIdentifierKey: CFStringRef;
9668}
9669extern "C" {
9670pub static kCFUserNotificationDefaultButtonAccessibilityIdentifierKey: CFStringRef;
9672}
9673extern "C" {
9674pub static kCFUserNotificationAlternateButtonAccessibilityIdentifierKey: CFStringRef;
9676}
9677extern "C" {
9678pub static kCFUserNotificationOtherButtonAccessibilityIdentifierKey: CFStringRef;
9680}
9681pub const kCFXMLNodeCurrentVersion: _bindgen_ty_58 = 1;
9683pub type _bindgen_ty_58 = ::core::ffi::c_uint;
9685#[repr(C)]
9686#[derive(Debug, Copy, Clone)]
9687pub struct __CFXMLNode {
9689 _unused: [u8; 0],
9690}
9691pub type CFXMLNodeRef = *const __CFXMLNode;
9693pub type CFXMLTreeRef = CFTreeRef;
9695pub type CFXMLNodeTypeCode = CFIndex;
9697pub const kCFXMLNodeTypeDocument: _bindgen_ty_59 = 1;
9699pub const kCFXMLNodeTypeElement: _bindgen_ty_59 = 2;
9701pub const kCFXMLNodeTypeAttribute: _bindgen_ty_59 = 3;
9703pub const kCFXMLNodeTypeProcessingInstruction: _bindgen_ty_59 = 4;
9705pub const kCFXMLNodeTypeComment: _bindgen_ty_59 = 5;
9707pub const kCFXMLNodeTypeText: _bindgen_ty_59 = 6;
9709pub const kCFXMLNodeTypeCDATASection: _bindgen_ty_59 = 7;
9711pub const kCFXMLNodeTypeDocumentFragment: _bindgen_ty_59 = 8;
9713pub const kCFXMLNodeTypeEntity: _bindgen_ty_59 = 9;
9715pub const kCFXMLNodeTypeEntityReference: _bindgen_ty_59 = 10;
9717pub const kCFXMLNodeTypeDocumentType: _bindgen_ty_59 = 11;
9719pub const kCFXMLNodeTypeWhitespace: _bindgen_ty_59 = 12;
9721pub const kCFXMLNodeTypeNotation: _bindgen_ty_59 = 13;
9723pub const kCFXMLNodeTypeElementTypeDeclaration: _bindgen_ty_59 = 14;
9725pub const kCFXMLNodeTypeAttributeListDeclaration: _bindgen_ty_59 = 15;
9727pub type _bindgen_ty_59 = ::core::ffi::c_uint;
9729#[repr(C)]
9730#[derive(Debug, Copy, Clone)]
9731pub struct CFXMLElementInfo {
9733 pub attributes: CFDictionaryRef,
9734 pub attributeOrder: CFArrayRef,
9735 pub isEmpty: Boolean,
9736 pub _reserved: [::core::ffi::c_char; 3usize],
9737}
9738#[repr(C)]
9739#[derive(Debug, Copy, Clone)]
9740pub struct CFXMLProcessingInstructionInfo {
9742 pub dataString: CFStringRef,
9743}
9744#[repr(C)]
9745#[derive(Debug, Copy, Clone)]
9746pub struct CFXMLDocumentInfo {
9748 pub sourceURL: CFURLRef,
9749 pub encoding: CFStringEncoding,
9750}
9751#[repr(C)]
9752#[derive(Debug, Copy, Clone)]
9753pub struct CFXMLExternalID {
9755 pub systemID: CFURLRef,
9756 pub publicID: CFStringRef,
9757}
9758#[repr(C)]
9759#[derive(Debug, Copy, Clone)]
9760pub struct CFXMLDocumentTypeInfo {
9762 pub externalID: CFXMLExternalID,
9763}
9764#[repr(C)]
9765#[derive(Debug, Copy, Clone)]
9766pub struct CFXMLNotationInfo {
9768 pub externalID: CFXMLExternalID,
9769}
9770#[repr(C)]
9771#[derive(Debug, Copy, Clone)]
9772pub struct CFXMLElementTypeDeclarationInfo {
9774 pub contentDescription: CFStringRef,
9775}
9776#[repr(C)]
9777#[derive(Debug, Copy, Clone)]
9778pub struct CFXMLAttributeDeclarationInfo {
9780 pub attributeName: CFStringRef,
9781 pub typeString: CFStringRef,
9782 pub defaultString: CFStringRef,
9783}
9784#[repr(C)]
9785#[derive(Debug, Copy, Clone)]
9786pub struct CFXMLAttributeListDeclarationInfo {
9788 pub numberOfAttributes: CFIndex,
9789 pub attributes: *mut CFXMLAttributeDeclarationInfo,
9790}
9791pub type CFXMLEntityTypeCode = CFIndex;
9793pub const kCFXMLEntityTypeParameter: _bindgen_ty_60 = 0;
9795pub const kCFXMLEntityTypeParsedInternal: _bindgen_ty_60 = 1;
9797pub const kCFXMLEntityTypeParsedExternal: _bindgen_ty_60 = 2;
9799pub const kCFXMLEntityTypeUnparsed: _bindgen_ty_60 = 3;
9801pub const kCFXMLEntityTypeCharacter: _bindgen_ty_60 = 4;
9803pub type _bindgen_ty_60 = ::core::ffi::c_uint;
9805#[repr(C)]
9806#[derive(Debug, Copy, Clone)]
9807pub struct CFXMLEntityInfo {
9809 pub entityType: CFXMLEntityTypeCode,
9810 pub replacementText: CFStringRef,
9811 pub entityID: CFXMLExternalID,
9812 pub notationName: CFStringRef,
9813}
9814#[repr(C)]
9815#[derive(Debug, Copy, Clone)]
9816pub struct CFXMLEntityReferenceInfo {
9818 pub entityType: CFXMLEntityTypeCode,
9819}
9820extern "C" {
9821pub fn CFXMLNodeGetTypeID() -> CFTypeID;
9823}
9824extern "C" {
9825pub fn CFXMLNodeCreate(
9827 alloc: CFAllocatorRef,
9828 xmlType: CFXMLNodeTypeCode,
9829 dataString: CFStringRef,
9830 additionalInfoPtr: *const ::core::ffi::c_void,
9831 version: CFIndex,
9832 ) -> CFXMLNodeRef;
9833}
9834extern "C" {
9835pub fn CFXMLNodeCreateCopy(alloc: CFAllocatorRef, origNode: CFXMLNodeRef) -> CFXMLNodeRef;
9837}
9838extern "C" {
9839pub fn CFXMLNodeGetTypeCode(node: CFXMLNodeRef) -> CFXMLNodeTypeCode;
9841}
9842extern "C" {
9843pub fn CFXMLNodeGetString(node: CFXMLNodeRef) -> CFStringRef;
9845}
9846extern "C" {
9847pub fn CFXMLNodeGetInfoPtr(node: CFXMLNodeRef) -> *const ::core::ffi::c_void;
9849}
9850extern "C" {
9851pub fn CFXMLNodeGetVersion(node: CFXMLNodeRef) -> CFIndex;
9853}
9854extern "C" {
9855pub fn CFXMLTreeCreateWithNode(allocator: CFAllocatorRef, node: CFXMLNodeRef) -> CFXMLTreeRef;
9857}
9858extern "C" {
9859pub fn CFXMLTreeGetNode(xmlTree: CFXMLTreeRef) -> CFXMLNodeRef;
9861}
9862#[repr(C)]
9863#[derive(Debug, Copy, Clone)]
9864pub struct __CFXMLParser {
9866 _unused: [u8; 0],
9867}
9868pub type CFXMLParserRef = *mut __CFXMLParser;
9870pub type CFXMLParserOptions = CFOptionFlags;
9872pub const kCFXMLParserValidateDocument: _bindgen_ty_61 = 1;
9874pub const kCFXMLParserSkipMetaData: _bindgen_ty_61 = 2;
9876pub const kCFXMLParserReplacePhysicalEntities: _bindgen_ty_61 = 4;
9878pub const kCFXMLParserSkipWhitespace: _bindgen_ty_61 = 8;
9880pub const kCFXMLParserResolveExternalEntities: _bindgen_ty_61 = 16;
9882pub const kCFXMLParserAddImpliedAttributes: _bindgen_ty_61 = 32;
9884pub const kCFXMLParserAllOptions: _bindgen_ty_61 = 16777215;
9886pub const kCFXMLParserNoOptions: _bindgen_ty_61 = 0;
9888pub type _bindgen_ty_61 = ::core::ffi::c_uint;
9890pub type CFXMLParserStatusCode = CFIndex;
9892pub const kCFXMLStatusParseNotBegun: _bindgen_ty_62 = -2;
9894pub const kCFXMLStatusParseInProgress: _bindgen_ty_62 = -1;
9896pub const kCFXMLStatusParseSuccessful: _bindgen_ty_62 = 0;
9898pub const kCFXMLErrorUnexpectedEOF: _bindgen_ty_62 = 1;
9900pub const kCFXMLErrorUnknownEncoding: _bindgen_ty_62 = 2;
9902pub const kCFXMLErrorEncodingConversionFailure: _bindgen_ty_62 = 3;
9904pub const kCFXMLErrorMalformedProcessingInstruction: _bindgen_ty_62 = 4;
9906pub const kCFXMLErrorMalformedDTD: _bindgen_ty_62 = 5;
9908pub const kCFXMLErrorMalformedName: _bindgen_ty_62 = 6;
9910pub const kCFXMLErrorMalformedCDSect: _bindgen_ty_62 = 7;
9912pub const kCFXMLErrorMalformedCloseTag: _bindgen_ty_62 = 8;
9914pub const kCFXMLErrorMalformedStartTag: _bindgen_ty_62 = 9;
9916pub const kCFXMLErrorMalformedDocument: _bindgen_ty_62 = 10;
9918pub const kCFXMLErrorElementlessDocument: _bindgen_ty_62 = 11;
9920pub const kCFXMLErrorMalformedComment: _bindgen_ty_62 = 12;
9922pub const kCFXMLErrorMalformedCharacterReference: _bindgen_ty_62 = 13;
9924pub const kCFXMLErrorMalformedParsedCharacterData: _bindgen_ty_62 = 14;
9926pub const kCFXMLErrorNoData: _bindgen_ty_62 = 15;
9928pub type _bindgen_ty_62 = ::core::ffi::c_int;
9930pub type CFXMLParserCreateXMLStructureCallBack = ::core::option::Option<
9932 unsafe extern "C" fn(
9933 parser: CFXMLParserRef,
9934 nodeDesc: CFXMLNodeRef,
9935 info: *mut ::core::ffi::c_void,
9936 ) -> *mut ::core::ffi::c_void,
9937>;
9938pub type CFXMLParserAddChildCallBack = ::core::option::Option<
9940 unsafe extern "C" fn(
9941 parser: CFXMLParserRef,
9942 parent: *mut ::core::ffi::c_void,
9943 child: *mut ::core::ffi::c_void,
9944 info: *mut ::core::ffi::c_void,
9945 ),
9946>;
9947pub type CFXMLParserEndXMLStructureCallBack = ::core::option::Option<
9949 unsafe extern "C" fn(
9950 parser: CFXMLParserRef,
9951 xmlType: *mut ::core::ffi::c_void,
9952 info: *mut ::core::ffi::c_void,
9953 ),
9954>;
9955pub type CFXMLParserResolveExternalEntityCallBack = ::core::option::Option<
9957 unsafe extern "C" fn(
9958 parser: CFXMLParserRef,
9959 extID: *mut CFXMLExternalID,
9960 info: *mut ::core::ffi::c_void,
9961 ) -> CFDataRef,
9962>;
9963pub type CFXMLParserHandleErrorCallBack = ::core::option::Option<
9965 unsafe extern "C" fn(
9966 parser: CFXMLParserRef,
9967 error: CFXMLParserStatusCode,
9968 info: *mut ::core::ffi::c_void,
9969 ) -> Boolean,
9970>;
9971#[repr(C)]
9972#[derive(Debug, Copy, Clone)]
9973pub struct CFXMLParserCallBacks {
9975 pub version: CFIndex,
9976 pub createXMLStructure: CFXMLParserCreateXMLStructureCallBack,
9977 pub addChild: CFXMLParserAddChildCallBack,
9978 pub endXMLStructure: CFXMLParserEndXMLStructureCallBack,
9979 pub resolveExternalEntity: CFXMLParserResolveExternalEntityCallBack,
9980 pub handleError: CFXMLParserHandleErrorCallBack,
9981}
9982pub type CFXMLParserRetainCallBack = ::core::option::Option<
9984 unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> *const ::core::ffi::c_void,
9985>;
9986pub type CFXMLParserReleaseCallBack =
9988 ::core::option::Option<unsafe extern "C" fn(info: *const ::core::ffi::c_void)>;
9989pub type CFXMLParserCopyDescriptionCallBack =
9991 ::core::option::Option<unsafe extern "C" fn(info: *const ::core::ffi::c_void) -> CFStringRef>;
9992#[repr(C)]
9993#[derive(Debug, Copy, Clone)]
9994pub struct CFXMLParserContext {
9996 pub version: CFIndex,
9997 pub info: *mut ::core::ffi::c_void,
9998 pub retain: CFXMLParserRetainCallBack,
9999 pub release: CFXMLParserReleaseCallBack,
10000 pub copyDescription: CFXMLParserCopyDescriptionCallBack,
10001}
10002extern "C" {
10003pub fn CFXMLParserGetTypeID() -> CFTypeID;
10005}
10006extern "C" {
10007pub fn CFXMLParserCreate(
10009 allocator: CFAllocatorRef,
10010 xmlData: CFDataRef,
10011 dataSource: CFURLRef,
10012 parseOptions: CFOptionFlags,
10013 versionOfNodes: CFIndex,
10014 callBacks: *mut CFXMLParserCallBacks,
10015 context: *mut CFXMLParserContext,
10016 ) -> CFXMLParserRef;
10017}
10018extern "C" {
10019pub fn CFXMLParserCreateWithDataFromURL(
10021 allocator: CFAllocatorRef,
10022 dataSource: CFURLRef,
10023 parseOptions: CFOptionFlags,
10024 versionOfNodes: CFIndex,
10025 callBacks: *mut CFXMLParserCallBacks,
10026 context: *mut CFXMLParserContext,
10027 ) -> CFXMLParserRef;
10028}
10029extern "C" {
10030pub fn CFXMLParserGetContext(parser: CFXMLParserRef, context: *mut CFXMLParserContext);
10032}
10033extern "C" {
10034pub fn CFXMLParserGetCallBacks(parser: CFXMLParserRef, callBacks: *mut CFXMLParserCallBacks);
10036}
10037extern "C" {
10038pub fn CFXMLParserGetSourceURL(parser: CFXMLParserRef) -> CFURLRef;
10040}
10041extern "C" {
10042pub fn CFXMLParserGetLocation(parser: CFXMLParserRef) -> CFIndex;
10044}
10045extern "C" {
10046pub fn CFXMLParserGetLineNumber(parser: CFXMLParserRef) -> CFIndex;
10048}
10049extern "C" {
10050pub fn CFXMLParserGetDocument(parser: CFXMLParserRef) -> *mut ::core::ffi::c_void;
10052}
10053extern "C" {
10054pub fn CFXMLParserGetStatusCode(parser: CFXMLParserRef) -> CFXMLParserStatusCode;
10056}
10057extern "C" {
10058pub fn CFXMLParserCopyErrorDescription(parser: CFXMLParserRef) -> CFStringRef;
10060}
10061extern "C" {
10062pub fn CFXMLParserAbort(
10064 parser: CFXMLParserRef,
10065 errorCode: CFXMLParserStatusCode,
10066 errorDescription: CFStringRef,
10067 );
10068}
10069extern "C" {
10070pub fn CFXMLParserParse(parser: CFXMLParserRef) -> Boolean;
10072}
10073extern "C" {
10074pub fn CFXMLTreeCreateFromData(
10076 allocator: CFAllocatorRef,
10077 xmlData: CFDataRef,
10078 dataSource: CFURLRef,
10079 parseOptions: CFOptionFlags,
10080 versionOfNodes: CFIndex,
10081 ) -> CFXMLTreeRef;
10082}
10083extern "C" {
10084pub fn CFXMLTreeCreateFromDataWithError(
10086 allocator: CFAllocatorRef,
10087 xmlData: CFDataRef,
10088 dataSource: CFURLRef,
10089 parseOptions: CFOptionFlags,
10090 versionOfNodes: CFIndex,
10091 errorDict: *mut CFDictionaryRef,
10092 ) -> CFXMLTreeRef;
10093}
10094extern "C" {
10095pub fn CFXMLTreeCreateWithDataFromURL(
10097 allocator: CFAllocatorRef,
10098 dataSource: CFURLRef,
10099 parseOptions: CFOptionFlags,
10100 versionOfNodes: CFIndex,
10101 ) -> CFXMLTreeRef;
10102}
10103extern "C" {
10104pub fn CFXMLTreeCreateXMLData(allocator: CFAllocatorRef, xmlTree: CFXMLTreeRef) -> CFDataRef;
10106}
10107extern "C" {
10108pub fn CFXMLCreateStringByEscapingEntities(
10110 allocator: CFAllocatorRef,
10111 string: CFStringRef,
10112 entitiesDictionary: CFDictionaryRef,
10113 ) -> CFStringRef;
10114}
10115extern "C" {
10116pub fn CFXMLCreateStringByUnescapingEntities(
10118 allocator: CFAllocatorRef,
10119 string: CFStringRef,
10120 entitiesDictionary: CFDictionaryRef,
10121 ) -> CFStringRef;
10122}
10123extern "C" {
10124pub static kCFXMLTreeErrorDescription: CFStringRef;
10126}
10127extern "C" {
10128pub static kCFXMLTreeErrorLineNumber: CFStringRef;
10130}
10131extern "C" {
10132pub static kCFXMLTreeErrorLocation: CFStringRef;
10134}
10135extern "C" {
10136pub static kCFXMLTreeErrorStatusCode: CFStringRef;
10138}
10139pub type CMItemCount = CFIndex;
10141pub type CMItemIndex = CFIndex;
10143pub type CMBaseClassVersion = usize;
10145pub type CMStructVersion = usize;
10147pub type CMPersistentTrackID = i32;
10149pub const kCMPersistentTrackID_Invalid: _bindgen_ty_63 = 0;
10151pub type _bindgen_ty_63 = ::core::ffi::c_uint;
10153pub type CMTimeValue = i64;
10155pub type CMTimeScale = i32;
10157pub type CMTimeEpoch = i64;
10159pub type CMTimeFlags = u32;
10161pub const kCMTimeFlags_Valid: _bindgen_ty_64 = 1;
10163pub const kCMTimeFlags_HasBeenRounded: _bindgen_ty_64 = 2;
10165pub const kCMTimeFlags_PositiveInfinity: _bindgen_ty_64 = 4;
10167pub const kCMTimeFlags_NegativeInfinity: _bindgen_ty_64 = 8;
10169pub const kCMTimeFlags_Indefinite: _bindgen_ty_64 = 16;
10171pub const kCMTimeFlags_ImpliedValueFlagsMask: _bindgen_ty_64 = 28;
10173pub type _bindgen_ty_64 = ::core::ffi::c_uint;
10175#[repr(C, packed(4))]
10176#[derive(Debug, Copy, Clone)]
10177pub struct CMTime {
10179 pub value: CMTimeValue,
10180 pub timescale: CMTimeScale,
10181 pub flags: CMTimeFlags,
10182 pub epoch: CMTimeEpoch,
10183}
10184extern "C" {
10185pub static kCMTimeInvalid: CMTime;
10187}
10188extern "C" {
10189pub static kCMTimeIndefinite: CMTime;
10191}
10192extern "C" {
10193pub static kCMTimePositiveInfinity: CMTime;
10195}
10196extern "C" {
10197pub static kCMTimeNegativeInfinity: CMTime;
10199}
10200extern "C" {
10201pub static kCMTimeZero: CMTime;
10203}
10204extern "C" {
10205pub fn CMTimeMake(value: i64, timescale: i32) -> CMTime;
10207}
10208extern "C" {
10209pub fn CMTimeMakeWithEpoch(value: i64, timescale: i32, epoch: i64) -> CMTime;
10211}
10212extern "C" {
10213pub fn CMTimeMakeWithSeconds(seconds: Float64, preferredTimescale: i32) -> CMTime;
10215}
10216extern "C" {
10217pub fn CMTimeGetSeconds(time: CMTime) -> Float64;
10219}
10220pub type CMTimeRoundingMethod = u32;
10222pub const kCMTimeRoundingMethod_RoundHalfAwayFromZero: _bindgen_ty_65 = 1;
10224pub const kCMTimeRoundingMethod_RoundTowardZero: _bindgen_ty_65 = 2;
10226pub const kCMTimeRoundingMethod_RoundAwayFromZero: _bindgen_ty_65 = 3;
10228pub const kCMTimeRoundingMethod_QuickTime: _bindgen_ty_65 = 4;
10230pub const kCMTimeRoundingMethod_RoundTowardPositiveInfinity: _bindgen_ty_65 = 5;
10232pub const kCMTimeRoundingMethod_RoundTowardNegativeInfinity: _bindgen_ty_65 = 6;
10234pub const kCMTimeRoundingMethod_Default: _bindgen_ty_65 = 1;
10236pub type _bindgen_ty_65 = ::core::ffi::c_uint;
10238extern "C" {
10239pub fn CMTimeConvertScale(
10241 time: CMTime,
10242 newTimescale: i32,
10243 method: CMTimeRoundingMethod,
10244 ) -> CMTime;
10245}
10246extern "C" {
10247pub fn CMTimeAdd(lhs: CMTime, rhs: CMTime) -> CMTime;
10249}
10250extern "C" {
10251pub fn CMTimeSubtract(lhs: CMTime, rhs: CMTime) -> CMTime;
10253}
10254extern "C" {
10255pub fn CMTimeMultiply(time: CMTime, multiplier: i32) -> CMTime;
10257}
10258extern "C" {
10259pub fn CMTimeMultiplyByFloat64(time: CMTime, multiplier: Float64) -> CMTime;
10261}
10262extern "C" {
10263pub fn CMTimeMultiplyByRatio(time: CMTime, multiplier: i32, divisor: i32) -> CMTime;
10265}
10266extern "C" {
10267pub fn CMTimeCompare(time1: CMTime, time2: CMTime) -> i32;
10269}
10270extern "C" {
10271pub fn CMTimeMinimum(time1: CMTime, time2: CMTime) -> CMTime;
10273}
10274extern "C" {
10275pub fn CMTimeMaximum(time1: CMTime, time2: CMTime) -> CMTime;
10277}
10278extern "C" {
10279pub fn CMTimeAbsoluteValue(time: CMTime) -> CMTime;
10281}
10282extern "C" {
10283pub fn CMTimeCopyAsDictionary(time: CMTime, allocator: CFAllocatorRef) -> CFDictionaryRef;
10285}
10286extern "C" {
10287pub fn CMTimeMakeFromDictionary(dictionaryRepresentation: CFDictionaryRef) -> CMTime;
10289}
10290extern "C" {
10291pub static kCMTimeValueKey: CFStringRef;
10293}
10294extern "C" {
10295pub static kCMTimeScaleKey: CFStringRef;
10297}
10298extern "C" {
10299pub static kCMTimeEpochKey: CFStringRef;
10301}
10302extern "C" {
10303pub static kCMTimeFlagsKey: CFStringRef;
10305}
10306extern "C" {
10307pub fn CMTimeCopyDescription(allocator: CFAllocatorRef, time: CMTime) -> CFStringRef;
10309}
10310extern "C" {
10311pub fn CMTimeShow(time: CMTime);
10313}
10314#[repr(C)]
10315#[derive(Debug, Copy, Clone)]
10316pub struct CMTimeRange {
10318 pub start: CMTime,
10319 pub duration: CMTime,
10320}
10321extern "C" {
10322pub static kCMTimeRangeZero: CMTimeRange;
10324}
10325extern "C" {
10326pub static kCMTimeRangeInvalid: CMTimeRange;
10328}
10329extern "C" {
10330pub fn CMTimeRangeMake(start: CMTime, duration: CMTime) -> CMTimeRange;
10332}
10333extern "C" {
10334pub fn CMTimeRangeGetUnion(range: CMTimeRange, otherRange: CMTimeRange) -> CMTimeRange;
10336}
10337extern "C" {
10338pub fn CMTimeRangeGetIntersection(range: CMTimeRange, otherRange: CMTimeRange) -> CMTimeRange;
10340}
10341extern "C" {
10342pub fn CMTimeRangeEqual(range1: CMTimeRange, range2: CMTimeRange) -> Boolean;
10344}
10345extern "C" {
10346pub fn CMTimeRangeContainsTime(range: CMTimeRange, time: CMTime) -> Boolean;
10348}
10349extern "C" {
10350pub fn CMTimeRangeContainsTimeRange(range: CMTimeRange, otherRange: CMTimeRange) -> Boolean;
10352}
10353extern "C" {
10354pub fn CMTimeRangeGetEnd(range: CMTimeRange) -> CMTime;
10356}
10357extern "C" {
10358pub fn CMTimeMapTimeFromRangeToRange(
10360 t: CMTime,
10361 fromRange: CMTimeRange,
10362 toRange: CMTimeRange,
10363 ) -> CMTime;
10364}
10365extern "C" {
10366pub fn CMTimeClampToRange(time: CMTime, range: CMTimeRange) -> CMTime;
10368}
10369extern "C" {
10370pub fn CMTimeMapDurationFromRangeToRange(
10372 dur: CMTime,
10373 fromRange: CMTimeRange,
10374 toRange: CMTimeRange,
10375 ) -> CMTime;
10376}
10377extern "C" {
10378pub fn CMTimeFoldIntoRange(time: CMTime, foldRange: CMTimeRange) -> CMTime;
10380}
10381extern "C" {
10382pub fn CMTimeRangeFromTimeToTime(start: CMTime, end: CMTime) -> CMTimeRange;
10384}
10385extern "C" {
10386pub fn CMTimeRangeCopyAsDictionary(
10388 range: CMTimeRange,
10389 allocator: CFAllocatorRef,
10390 ) -> CFDictionaryRef;
10391}
10392extern "C" {
10393pub fn CMTimeRangeMakeFromDictionary(dictionaryRepresentation: CFDictionaryRef) -> CMTimeRange;
10395}
10396extern "C" {
10397pub static kCMTimeRangeStartKey: CFStringRef;
10399}
10400extern "C" {
10401pub static kCMTimeRangeDurationKey: CFStringRef;
10403}
10404extern "C" {
10405pub fn CMTimeRangeCopyDescription(allocator: CFAllocatorRef, range: CMTimeRange)
10407 -> CFStringRef;
10408}
10409extern "C" {
10410pub fn CMTimeRangeShow(range: CMTimeRange);
10412}
10413#[repr(C)]
10414#[derive(Debug, Copy, Clone)]
10415pub struct CMTimeMapping {
10417 pub source: CMTimeRange,
10418 pub target: CMTimeRange,
10419}
10420extern "C" {
10421pub static kCMTimeMappingInvalid: CMTimeMapping;
10423}
10424extern "C" {
10425pub fn CMTimeMappingMake(source: CMTimeRange, target: CMTimeRange) -> CMTimeMapping;
10427}
10428extern "C" {
10429pub fn CMTimeMappingMakeEmpty(target: CMTimeRange) -> CMTimeMapping;
10431}
10432extern "C" {
10433pub fn CMTimeMappingCopyAsDictionary(
10435 mapping: CMTimeMapping,
10436 allocator: CFAllocatorRef,
10437 ) -> CFDictionaryRef;
10438}
10439extern "C" {
10440pub fn CMTimeMappingMakeFromDictionary(
10442 dictionaryRepresentation: CFDictionaryRef,
10443 ) -> CMTimeMapping;
10444}
10445extern "C" {
10446pub static kCMTimeMappingSourceKey: CFStringRef;
10448}
10449extern "C" {
10450pub static kCMTimeMappingTargetKey: CFStringRef;
10452}
10453extern "C" {
10454pub fn CMTimeMappingCopyDescription(
10456 allocator: CFAllocatorRef,
10457 mapping: CMTimeMapping,
10458 ) -> CFStringRef;
10459}
10460extern "C" {
10461pub fn CMTimeMappingShow(mapping: CMTimeMapping);
10463}
10464#[repr(C)]
10465#[derive(Debug, Copy, Clone)]
10466pub struct AudioBuffer {
10468 pub mNumberChannels: UInt32,
10469 pub mDataByteSize: UInt32,
10470 pub mData: *mut ::core::ffi::c_void,
10471}
10472#[repr(C)]
10473#[derive(Debug, Copy, Clone)]
10474pub struct AudioBufferList {
10476 pub mNumberBuffers: UInt32,
10477 pub mBuffers: [AudioBuffer; 1usize],
10478}
10479pub type AudioFormatID = UInt32;
10481pub type AudioFormatFlags = UInt32;
10483#[repr(C)]
10484#[derive(Debug, Copy, Clone)]
10485pub struct AudioStreamBasicDescription {
10487 pub mSampleRate: Float64,
10488 pub mFormatID: AudioFormatID,
10489 pub mFormatFlags: AudioFormatFlags,
10490 pub mBytesPerPacket: UInt32,
10491 pub mFramesPerPacket: UInt32,
10492 pub mBytesPerFrame: UInt32,
10493 pub mChannelsPerFrame: UInt32,
10494 pub mBitsPerChannel: UInt32,
10495 pub mReserved: UInt32,
10496}
10497#[repr(C)]
10498#[derive(Debug, Copy, Clone)]
10499pub struct AudioStreamPacketDescription {
10501 pub mStartOffset: SInt64,
10502 pub mVariableFramesInPacket: UInt32,
10503 pub mDataByteSize: UInt32,
10504}
10505pub type AudioChannelLabel = UInt32;
10507pub type AudioChannelLayoutTag = UInt32;
10509pub type AudioChannelBitmap = UInt32;
10511pub type AudioChannelFlags = UInt32;
10513#[repr(C)]
10514#[derive(Debug, Copy, Clone)]
10515pub struct AudioChannelDescription {
10517 pub mChannelLabel: AudioChannelLabel,
10518 pub mChannelFlags: AudioChannelFlags,
10519 pub mCoordinates: [Float32; 3usize],
10520}
10521#[repr(C)]
10522#[derive(Debug, Copy, Clone)]
10523pub struct AudioChannelLayout {
10525 pub mChannelLayoutTag: AudioChannelLayoutTag,
10526 pub mChannelBitmap: AudioChannelBitmap,
10527 pub mNumberChannelDescriptions: UInt32,
10528 pub mChannelDescriptions: [AudioChannelDescription; 1usize],
10529}
10530#[repr(C)]
10531#[derive(Debug, Copy, Clone)]
10532pub struct AudioFormatListItem {
10534 pub mASBD: AudioStreamBasicDescription,
10535 pub mChannelLayoutTag: AudioChannelLayoutTag,
10536}
10537#[repr(C)]
10538#[derive(Debug, Copy, Clone)]
10539pub struct __IOSurface {
10541 _unused: [u8; 0],
10542}
10543pub type IOSurfaceRef = *mut __IOSurface;
10545pub type CVOptionFlags = u64;
10547#[repr(C)]
10548#[derive(Debug, Copy, Clone)]
10549pub struct CVSMPTETime {
10551 pub subframes: SInt16,
10552 pub subframeDivisor: SInt16,
10553 pub counter: UInt32,
10554 pub type_: UInt32,
10555 pub flags: UInt32,
10556 pub hours: SInt16,
10557 pub minutes: SInt16,
10558 pub seconds: SInt16,
10559 pub frames: SInt16,
10560}
10561pub type CVSMPTETimeType = u32;
10563pub const kCVSMPTETimeType24: _bindgen_ty_81 = 0;
10565pub const kCVSMPTETimeType25: _bindgen_ty_81 = 1;
10567pub const kCVSMPTETimeType30Drop: _bindgen_ty_81 = 2;
10569pub const kCVSMPTETimeType30: _bindgen_ty_81 = 3;
10571pub const kCVSMPTETimeType2997: _bindgen_ty_81 = 4;
10573pub const kCVSMPTETimeType2997Drop: _bindgen_ty_81 = 5;
10575pub const kCVSMPTETimeType60: _bindgen_ty_81 = 6;
10577pub const kCVSMPTETimeType5994: _bindgen_ty_81 = 7;
10579pub type _bindgen_ty_81 = ::core::ffi::c_uint;
10581pub type CVSMPTETimeFlags = u32;
10583pub const kCVSMPTETimeValid: _bindgen_ty_82 = 1;
10585pub const kCVSMPTETimeRunning: _bindgen_ty_82 = 2;
10587pub type _bindgen_ty_82 = ::core::ffi::c_uint;
10589pub type CVTimeFlags = i32;
10591pub const kCVTimeIsIndefinite: _bindgen_ty_83 = 1;
10593pub type _bindgen_ty_83 = ::core::ffi::c_uint;
10595#[repr(C)]
10596#[derive(Debug, Copy, Clone)]
10597pub struct CVTime {
10599 pub timeValue: i64,
10600 pub timeScale: i32,
10601 pub flags: i32,
10602}
10603extern "C" {
10604pub static kCVZeroTime: CVTime;
10606}
10607extern "C" {
10608pub static kCVIndefiniteTime: CVTime;
10610}
10611#[repr(C)]
10612#[derive(Debug, Copy, Clone)]
10613pub struct CVTimeStamp {
10615 pub version: u32,
10616 pub videoTimeScale: i32,
10617 pub videoTime: i64,
10618 pub hostTime: u64,
10619 pub rateScalar: f64,
10620 pub videoRefreshPeriod: i64,
10621 pub smpteTime: CVSMPTETime,
10622 pub flags: u64,
10623 pub reserved: u64,
10624}
10625pub type CVTimeStampFlags = u64;
10627pub const kCVTimeStampVideoTimeValid: _bindgen_ty_84 = 1;
10629pub const kCVTimeStampHostTimeValid: _bindgen_ty_84 = 2;
10631pub const kCVTimeStampSMPTETimeValid: _bindgen_ty_84 = 4;
10633pub const kCVTimeStampVideoRefreshPeriodValid: _bindgen_ty_84 = 8;
10635pub const kCVTimeStampRateScalarValid: _bindgen_ty_84 = 16;
10637pub const kCVTimeStampTopField: _bindgen_ty_84 = 65536;
10639pub const kCVTimeStampBottomField: _bindgen_ty_84 = 131072;
10641pub const kCVTimeStampVideoHostTimeValid: _bindgen_ty_84 = 3;
10643pub const kCVTimeStampIsInterlaced: _bindgen_ty_84 = 196608;
10645pub type _bindgen_ty_84 = ::core::ffi::c_uint;
10647pub type CVReturn = i32;
10649extern "C" {
10650pub fn CVGetCurrentHostTime() -> u64;
10652}
10653extern "C" {
10654pub fn CVGetHostClockFrequency() -> f64;
10656}
10657extern "C" {
10658pub fn CVGetHostClockMinimumTimeDelta() -> u32;
10660}
10661#[repr(C)]
10662#[derive(Debug, Copy, Clone)]
10663pub struct CGColorSpace {
10665 _unused: [u8; 0],
10666}
10667pub type CGColorSpaceRef = *mut CGColorSpace;
10669#[repr(C)]
10670#[derive(Debug, Copy, Clone)]
10671pub struct ColorSyncProfile {
10673 _unused: [u8; 0],
10674}
10675pub type CGDirectDisplayID = u32;
10677pub type CGOpenGLDisplayMask = u32;
10679pub type task_id_token_t = mach_port_t;
10681#[repr(C)]
10682#[derive(Debug, Copy, Clone)]
10683pub struct _CGLContextObject {
10685 _unused: [u8; 0],
10686}
10687pub type CGLContextObj = *mut _CGLContextObject;
10689#[repr(C)]
10690#[derive(Debug, Copy, Clone)]
10691pub struct _CGLPixelFormatObject {
10693 _unused: [u8; 0],
10694}
10695pub type CGLPixelFormatObj = *mut _CGLPixelFormatObject;
10697pub type GLenum = u32;
10699pub type GLfloat = f32;
10701pub type GLint = i32;
10703pub type GLuint = u32;
10705#[repr(C)]
10706#[derive(Debug, Copy, Clone)]
10707pub struct __CVDisplayLink {
10709 _unused: [u8; 0],
10710}
10711pub type CVDisplayLinkRef = *mut __CVDisplayLink;
10713pub type CVDisplayLinkOutputCallback = ::core::option::Option<
10715 unsafe extern "C" fn(
10716 displayLink: CVDisplayLinkRef,
10717 inNow: *const CVTimeStamp,
10718 inOutputTime: *const CVTimeStamp,
10719 flagsIn: CVOptionFlags,
10720 flagsOut: *mut CVOptionFlags,
10721 displayLinkContext: *mut ::core::ffi::c_void,
10722 ) -> CVReturn,
10723>;
10724pub type CVDisplayLinkOutputHandler = *mut ::core::ffi::c_void;
10726extern "C" {
10727pub fn CVDisplayLinkGetTypeID() -> CFTypeID;
10729}
10730extern "C" {
10731pub fn CVDisplayLinkCreateWithCGDisplays(
10733 displayArray: *mut CGDirectDisplayID,
10734 count: CFIndex,
10735 displayLinkOut: *mut CVDisplayLinkRef,
10736 ) -> CVReturn;
10737}
10738extern "C" {
10739pub fn CVDisplayLinkCreateWithOpenGLDisplayMask(
10741 mask: CGOpenGLDisplayMask,
10742 displayLinkOut: *mut CVDisplayLinkRef,
10743 ) -> CVReturn;
10744}
10745extern "C" {
10746pub fn CVDisplayLinkCreateWithCGDisplay(
10748 displayID: CGDirectDisplayID,
10749 displayLinkOut: *mut CVDisplayLinkRef,
10750 ) -> CVReturn;
10751}
10752extern "C" {
10753pub fn CVDisplayLinkCreateWithActiveCGDisplays(
10755 displayLinkOut: *mut CVDisplayLinkRef,
10756 ) -> CVReturn;
10757}
10758extern "C" {
10759pub fn CVDisplayLinkSetCurrentCGDisplay(
10761 displayLink: CVDisplayLinkRef,
10762 displayID: CGDirectDisplayID,
10763 ) -> CVReturn;
10764}
10765extern "C" {
10766pub fn CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(
10768 displayLink: CVDisplayLinkRef,
10769 cglContext: CGLContextObj,
10770 cglPixelFormat: CGLPixelFormatObj,
10771 ) -> CVReturn;
10772}
10773extern "C" {
10774pub fn CVDisplayLinkGetCurrentCGDisplay(displayLink: CVDisplayLinkRef) -> CGDirectDisplayID;
10776}
10777extern "C" {
10778pub fn CVDisplayLinkSetOutputCallback(
10780 displayLink: CVDisplayLinkRef,
10781 callback: CVDisplayLinkOutputCallback,
10782 userInfo: *mut ::core::ffi::c_void,
10783 ) -> CVReturn;
10784}
10785extern "C" {
10786pub fn CVDisplayLinkSetOutputHandler(
10788 displayLink: CVDisplayLinkRef,
10789 handler: CVDisplayLinkOutputHandler,
10790 ) -> CVReturn;
10791}
10792extern "C" {
10793pub fn CVDisplayLinkStart(displayLink: CVDisplayLinkRef) -> CVReturn;
10795}
10796extern "C" {
10797pub fn CVDisplayLinkStop(displayLink: CVDisplayLinkRef) -> CVReturn;
10799}
10800extern "C" {
10801pub fn CVDisplayLinkGetNominalOutputVideoRefreshPeriod(displayLink: CVDisplayLinkRef)
10803 -> CVTime;
10804}
10805extern "C" {
10806pub fn CVDisplayLinkGetOutputVideoLatency(displayLink: CVDisplayLinkRef) -> CVTime;
10808}
10809extern "C" {
10810pub fn CVDisplayLinkGetActualOutputVideoRefreshPeriod(displayLink: CVDisplayLinkRef) -> f64;
10812}
10813extern "C" {
10814pub fn CVDisplayLinkIsRunning(displayLink: CVDisplayLinkRef) -> Boolean;
10816}
10817extern "C" {
10818pub fn CVDisplayLinkGetCurrentTime(
10820 displayLink: CVDisplayLinkRef,
10821 outTime: *mut CVTimeStamp,
10822 ) -> CVReturn;
10823}
10824extern "C" {
10825pub fn CVDisplayLinkTranslateTime(
10827 displayLink: CVDisplayLinkRef,
10828 inTime: *const CVTimeStamp,
10829 outTime: *mut CVTimeStamp,
10830 ) -> CVReturn;
10831}
10832extern "C" {
10833pub fn CVDisplayLinkRetain(displayLink: CVDisplayLinkRef) -> CVDisplayLinkRef;
10835}
10836extern "C" {
10837pub fn CVDisplayLinkRelease(displayLink: CVDisplayLinkRef);
10839}
10840extern "C" {
10841pub static mut kCVBufferPropagatedAttachmentsKey: CFStringRef;
10843}
10844extern "C" {
10845pub static mut kCVBufferNonPropagatedAttachmentsKey: CFStringRef;
10847}
10848extern "C" {
10849pub static mut kCVBufferMovieTimeKey: CFStringRef;
10851}
10852extern "C" {
10853pub static mut kCVBufferTimeValueKey: CFStringRef;
10855}
10856extern "C" {
10857pub static mut kCVBufferTimeScaleKey: CFStringRef;
10859}
10860pub type CVAttachmentMode = u32;
10862pub const kCVAttachmentMode_ShouldNotPropagate: _bindgen_ty_218 = 0;
10864pub const kCVAttachmentMode_ShouldPropagate: _bindgen_ty_218 = 1;
10866pub type _bindgen_ty_218 = ::core::ffi::c_uint;
10868#[repr(C)]
10869#[derive(Debug, Copy, Clone)]
10870pub struct __CVBuffer {
10872 _unused: [u8; 0],
10873}
10874pub type CVBufferRef = *mut __CVBuffer;
10876extern "C" {
10877pub fn CVBufferRetain(buffer: CVBufferRef) -> CVBufferRef;
10879}
10880extern "C" {
10881pub fn CVBufferRelease(buffer: CVBufferRef);
10883}
10884extern "C" {
10885pub fn CVBufferSetAttachment(
10887 buffer: CVBufferRef,
10888 key: CFStringRef,
10889 value: CFTypeRef,
10890 attachmentMode: CVAttachmentMode,
10891 );
10892}
10893extern "C" {
10894pub fn CVBufferGetAttachment(
10896 buffer: CVBufferRef,
10897 key: CFStringRef,
10898 attachmentMode: *mut CVAttachmentMode,
10899 ) -> CFTypeRef;
10900}
10901extern "C" {
10902pub fn CVBufferRemoveAttachment(buffer: CVBufferRef, key: CFStringRef);
10904}
10905extern "C" {
10906pub fn CVBufferRemoveAllAttachments(buffer: CVBufferRef);
10908}
10909extern "C" {
10910pub fn CVBufferGetAttachments(
10912 buffer: CVBufferRef,
10913 attachmentMode: CVAttachmentMode,
10914 ) -> CFDictionaryRef;
10915}
10916extern "C" {
10917pub fn CVBufferSetAttachments(
10919 buffer: CVBufferRef,
10920 theAttachments: CFDictionaryRef,
10921 attachmentMode: CVAttachmentMode,
10922 );
10923}
10924extern "C" {
10925pub fn CVBufferPropagateAttachments(sourceBuffer: CVBufferRef, destinationBuffer: CVBufferRef);
10927}
10928extern "C" {
10929pub fn CVBufferCopyAttachments(
10931 buffer: CVBufferRef,
10932 attachmentMode: CVAttachmentMode,
10933 ) -> CFDictionaryRef;
10934}
10935extern "C" {
10936pub fn CVBufferCopyAttachment(
10938 buffer: CVBufferRef,
10939 key: CFStringRef,
10940 attachmentMode: *mut CVAttachmentMode,
10941 ) -> CFTypeRef;
10942}
10943extern "C" {
10944pub fn CVBufferHasAttachment(buffer: CVBufferRef, key: CFStringRef) -> Boolean;
10946}
10947pub const kOld68kRTA: _bindgen_ty_492 = 0;
10949pub const kPowerPCRTA: _bindgen_ty_492 = 0;
10951pub const kCFM68kRTA: _bindgen_ty_492 = 16;
10953pub type _bindgen_ty_492 = ::core::ffi::c_uint;
10955#[repr(C)]
10956#[derive(Debug, Copy, Clone)]
10957pub struct FSRef {
10959 pub hidden: [UInt8; 80usize],
10960}
10961extern "C" {
10962pub static kCFErrorDomainCFNetwork: CFStringRef;
10964}
10965extern "C" {
10966pub static kCFErrorDomainWinSock: CFStringRef;
10968}
10969pub type CFNetworkErrors = ::core::ffi::c_int;
10971pub const kCFHostErrorHostNotFound: _bindgen_ty_1057 = 1;
10973pub const kCFHostErrorUnknown: _bindgen_ty_1057 = 2;
10975pub const kCFSOCKSErrorUnknownClientVersion: _bindgen_ty_1057 = 100;
10977pub const kCFSOCKSErrorUnsupportedServerVersion: _bindgen_ty_1057 = 101;
10979pub const kCFSOCKS4ErrorRequestFailed: _bindgen_ty_1057 = 110;
10981pub const kCFSOCKS4ErrorIdentdFailed: _bindgen_ty_1057 = 111;
10983pub const kCFSOCKS4ErrorIdConflict: _bindgen_ty_1057 = 112;
10985pub const kCFSOCKS4ErrorUnknownStatusCode: _bindgen_ty_1057 = 113;
10987pub const kCFSOCKS5ErrorBadState: _bindgen_ty_1057 = 120;
10989pub const kCFSOCKS5ErrorBadResponseAddr: _bindgen_ty_1057 = 121;
10991pub const kCFSOCKS5ErrorBadCredentials: _bindgen_ty_1057 = 122;
10993pub const kCFSOCKS5ErrorUnsupportedNegotiationMethod: _bindgen_ty_1057 = 123;
10995pub const kCFSOCKS5ErrorNoAcceptableMethod: _bindgen_ty_1057 = 124;
10997pub const kCFFTPErrorUnexpectedStatusCode: _bindgen_ty_1057 = 200;
10999pub const kCFErrorHTTPAuthenticationTypeUnsupported: _bindgen_ty_1057 = 300;
11001pub const kCFErrorHTTPBadCredentials: _bindgen_ty_1057 = 301;
11003pub const kCFErrorHTTPConnectionLost: _bindgen_ty_1057 = 302;
11005pub const kCFErrorHTTPParseFailure: _bindgen_ty_1057 = 303;
11007pub const kCFErrorHTTPRedirectionLoopDetected: _bindgen_ty_1057 = 304;
11009pub const kCFErrorHTTPBadURL: _bindgen_ty_1057 = 305;
11011pub const kCFErrorHTTPProxyConnectionFailure: _bindgen_ty_1057 = 306;
11013pub const kCFErrorHTTPBadProxyCredentials: _bindgen_ty_1057 = 307;
11015pub const kCFErrorPACFileError: _bindgen_ty_1057 = 308;
11017pub const kCFErrorPACFileAuth: _bindgen_ty_1057 = 309;
11019pub const kCFErrorHTTPSProxyConnectionFailure: _bindgen_ty_1057 = 310;
11021pub const kCFStreamErrorHTTPSProxyFailureUnexpectedResponseToCONNECTMethod: _bindgen_ty_1057 = 311;
11023pub const kCFURLErrorBackgroundSessionInUseByAnotherProcess: _bindgen_ty_1057 = -996;
11025pub const kCFURLErrorBackgroundSessionWasDisconnected: _bindgen_ty_1057 = -997;
11027pub const kCFURLErrorUnknown: _bindgen_ty_1057 = -998;
11029pub const kCFURLErrorCancelled: _bindgen_ty_1057 = -999;
11031pub const kCFURLErrorBadURL: _bindgen_ty_1057 = -1000;
11033pub const kCFURLErrorTimedOut: _bindgen_ty_1057 = -1001;
11035pub const kCFURLErrorUnsupportedURL: _bindgen_ty_1057 = -1002;
11037pub const kCFURLErrorCannotFindHost: _bindgen_ty_1057 = -1003;
11039pub const kCFURLErrorCannotConnectToHost: _bindgen_ty_1057 = -1004;
11041pub const kCFURLErrorNetworkConnectionLost: _bindgen_ty_1057 = -1005;
11043pub const kCFURLErrorDNSLookupFailed: _bindgen_ty_1057 = -1006;
11045pub const kCFURLErrorHTTPTooManyRedirects: _bindgen_ty_1057 = -1007;
11047pub const kCFURLErrorResourceUnavailable: _bindgen_ty_1057 = -1008;
11049pub const kCFURLErrorNotConnectedToInternet: _bindgen_ty_1057 = -1009;
11051pub const kCFURLErrorRedirectToNonExistentLocation: _bindgen_ty_1057 = -1010;
11053pub const kCFURLErrorBadServerResponse: _bindgen_ty_1057 = -1011;
11055pub const kCFURLErrorUserCancelledAuthentication: _bindgen_ty_1057 = -1012;
11057pub const kCFURLErrorUserAuthenticationRequired: _bindgen_ty_1057 = -1013;
11059pub const kCFURLErrorZeroByteResource: _bindgen_ty_1057 = -1014;
11061pub const kCFURLErrorCannotDecodeRawData: _bindgen_ty_1057 = -1015;
11063pub const kCFURLErrorCannotDecodeContentData: _bindgen_ty_1057 = -1016;
11065pub const kCFURLErrorCannotParseResponse: _bindgen_ty_1057 = -1017;
11067pub const kCFURLErrorInternationalRoamingOff: _bindgen_ty_1057 = -1018;
11069pub const kCFURLErrorCallIsActive: _bindgen_ty_1057 = -1019;
11071pub const kCFURLErrorDataNotAllowed: _bindgen_ty_1057 = -1020;
11073pub const kCFURLErrorRequestBodyStreamExhausted: _bindgen_ty_1057 = -1021;
11075pub const kCFURLErrorAppTransportSecurityRequiresSecureConnection: _bindgen_ty_1057 = -1022;
11077pub const kCFURLErrorFileDoesNotExist: _bindgen_ty_1057 = -1100;
11079pub const kCFURLErrorFileIsDirectory: _bindgen_ty_1057 = -1101;
11081pub const kCFURLErrorNoPermissionsToReadFile: _bindgen_ty_1057 = -1102;
11083pub const kCFURLErrorDataLengthExceedsMaximum: _bindgen_ty_1057 = -1103;
11085pub const kCFURLErrorFileOutsideSafeArea: _bindgen_ty_1057 = -1104;
11087pub const kCFURLErrorSecureConnectionFailed: _bindgen_ty_1057 = -1200;
11089pub const kCFURLErrorServerCertificateHasBadDate: _bindgen_ty_1057 = -1201;
11091pub const kCFURLErrorServerCertificateUntrusted: _bindgen_ty_1057 = -1202;
11093pub const kCFURLErrorServerCertificateHasUnknownRoot: _bindgen_ty_1057 = -1203;
11095pub const kCFURLErrorServerCertificateNotYetValid: _bindgen_ty_1057 = -1204;
11097pub const kCFURLErrorClientCertificateRejected: _bindgen_ty_1057 = -1205;
11099pub const kCFURLErrorClientCertificateRequired: _bindgen_ty_1057 = -1206;
11101pub const kCFURLErrorCannotLoadFromNetwork: _bindgen_ty_1057 = -2000;
11103pub const kCFURLErrorCannotCreateFile: _bindgen_ty_1057 = -3000;
11105pub const kCFURLErrorCannotOpenFile: _bindgen_ty_1057 = -3001;
11107pub const kCFURLErrorCannotCloseFile: _bindgen_ty_1057 = -3002;
11109pub const kCFURLErrorCannotWriteToFile: _bindgen_ty_1057 = -3003;
11111pub const kCFURLErrorCannotRemoveFile: _bindgen_ty_1057 = -3004;
11113pub const kCFURLErrorCannotMoveFile: _bindgen_ty_1057 = -3005;
11115pub const kCFURLErrorDownloadDecodingFailedMidStream: _bindgen_ty_1057 = -3006;
11117pub const kCFURLErrorDownloadDecodingFailedToComplete: _bindgen_ty_1057 = -3007;
11119pub const kCFHTTPCookieCannotParseCookieFile: _bindgen_ty_1057 = -4000;
11121pub const kCFNetServiceErrorUnknown: _bindgen_ty_1057 = -72000;
11123pub const kCFNetServiceErrorCollision: _bindgen_ty_1057 = -72001;
11125pub const kCFNetServiceErrorNotFound: _bindgen_ty_1057 = -72002;
11127pub const kCFNetServiceErrorInProgress: _bindgen_ty_1057 = -72003;
11129pub const kCFNetServiceErrorBadArgument: _bindgen_ty_1057 = -72004;
11131pub const kCFNetServiceErrorCancel: _bindgen_ty_1057 = -72005;
11133pub const kCFNetServiceErrorInvalid: _bindgen_ty_1057 = -72006;
11135pub const kCFNetServiceErrorTimeout: _bindgen_ty_1057 = -72007;
11137pub const kCFNetServiceErrorDNSServiceFailure: _bindgen_ty_1057 = -73000;
11139pub type _bindgen_ty_1057 = ::core::ffi::c_int;
11141extern "C" {
11142pub static kCFURLErrorFailingURLErrorKey: CFStringRef;
11144}
11145extern "C" {
11146pub static kCFURLErrorFailingURLStringErrorKey: CFStringRef;
11148}
11149extern "C" {
11150pub static kCFGetAddrInfoFailureKey: CFStringRef;
11152}
11153extern "C" {
11154pub static kCFSOCKSStatusCodeKey: CFStringRef;
11156}
11157extern "C" {
11158pub static kCFSOCKSVersionKey: CFStringRef;
11160}
11161extern "C" {
11162pub static kCFSOCKSNegotiationMethodKey: CFStringRef;
11164}
11165extern "C" {
11166pub static kCFDNSServiceFailureKey: CFStringRef;
11168}
11169extern "C" {
11170pub static kCFFTPStatusCodeKey: CFStringRef;
11172}
11173#[repr(C)]
11174#[derive(Debug, Copy, Clone)]
11175pub struct __CFHost {
11177 _unused: [u8; 0],
11178}
11179pub type CFHostRef = *mut __CFHost;
11181extern "C" {
11182pub static kCFStreamErrorDomainNetDB: SInt32;
11184}
11185extern "C" {
11186pub static kCFStreamErrorDomainSystemConfiguration: SInt32;
11188}
11189pub type CFHostInfoType = ::core::ffi::c_int;
11191pub const kCFHostAddresses: _bindgen_ty_1058 = 0;
11193pub const kCFHostNames: _bindgen_ty_1058 = 1;
11195pub const kCFHostReachability: _bindgen_ty_1058 = 2;
11197pub type _bindgen_ty_1058 = ::core::ffi::c_uint;
11199#[repr(C, packed(2))]
11200#[derive(Debug, Copy, Clone)]
11201pub struct CFHostClientContext {
11203 pub version: CFIndex,
11204 pub info: *mut ::core::ffi::c_void,
11205 pub retain: CFAllocatorRetainCallBack,
11206 pub release: CFAllocatorReleaseCallBack,
11207 pub copyDescription: CFAllocatorCopyDescriptionCallBack,
11208}
11209pub type CFHostClientCallBack = ::core::option::Option<
11211 unsafe extern "C" fn(
11212 theHost: CFHostRef,
11213 typeInfo: CFHostInfoType,
11214 error: *const CFStreamError,
11215 info: *mut ::core::ffi::c_void,
11216 ),
11217>;
11218extern "C" {
11219pub fn CFHostGetTypeID() -> CFTypeID;
11221}
11222extern "C" {
11223pub fn CFHostCreateWithName(allocator: CFAllocatorRef, hostname: CFStringRef) -> CFHostRef;
11225}
11226extern "C" {
11227pub fn CFHostCreateWithAddress(allocator: CFAllocatorRef, addr: CFDataRef) -> CFHostRef;
11229}
11230extern "C" {
11231pub fn CFHostCreateCopy(alloc: CFAllocatorRef, host: CFHostRef) -> CFHostRef;
11233}
11234extern "C" {
11235pub fn CFHostStartInfoResolution(
11237 theHost: CFHostRef,
11238 info: CFHostInfoType,
11239 error: *mut CFStreamError,
11240 ) -> Boolean;
11241}
11242extern "C" {
11243pub fn CFHostGetAddressing(theHost: CFHostRef, hasBeenResolved: *mut Boolean) -> CFArrayRef;
11245}
11246extern "C" {
11247pub fn CFHostGetNames(theHost: CFHostRef, hasBeenResolved: *mut Boolean) -> CFArrayRef;
11249}
11250extern "C" {
11251pub fn CFHostGetReachability(theHost: CFHostRef, hasBeenResolved: *mut Boolean) -> CFDataRef;
11253}
11254extern "C" {
11255pub fn CFHostCancelInfoResolution(theHost: CFHostRef, info: CFHostInfoType);
11257}
11258extern "C" {
11259pub fn CFHostSetClient(
11261 theHost: CFHostRef,
11262 clientCB: CFHostClientCallBack,
11263 clientContext: *mut CFHostClientContext,
11264 ) -> Boolean;
11265}
11266extern "C" {
11267pub fn CFHostScheduleWithRunLoop(
11269 theHost: CFHostRef,
11270 runLoop: CFRunLoopRef,
11271 runLoopMode: CFStringRef,
11272 );
11273}
11274extern "C" {
11275pub fn CFHostUnscheduleFromRunLoop(
11277 theHost: CFHostRef,
11278 runLoop: CFRunLoopRef,
11279 runLoopMode: CFStringRef,
11280 );
11281}
11282#[repr(C)]
11283#[derive(Debug, Copy, Clone)]
11284pub struct __CFNetService {
11286 _unused: [u8; 0],
11287}
11288pub type CFNetServiceRef = *mut __CFNetService;
11290#[repr(C)]
11291#[derive(Debug, Copy, Clone)]
11292pub struct __CFNetServiceMonitor {
11294 _unused: [u8; 0],
11295}
11296pub type CFNetServiceMonitorRef = *mut __CFNetServiceMonitor;
11298#[repr(C)]
11299#[derive(Debug, Copy, Clone)]
11300pub struct __CFNetServiceBrowser {
11302 _unused: [u8; 0],
11303}
11304pub type CFNetServiceBrowserRef = *mut __CFNetServiceBrowser;
11306extern "C" {
11307pub static kCFStreamErrorDomainMach: SInt32;
11309}
11310extern "C" {
11311pub static kCFStreamErrorDomainNetServices: SInt32;
11313}
11314pub type CFNetServicesError = ::core::ffi::c_int;
11316pub const kCFNetServicesErrorUnknown: _bindgen_ty_1059 = -72000;
11318pub const kCFNetServicesErrorCollision: _bindgen_ty_1059 = -72001;
11320pub const kCFNetServicesErrorNotFound: _bindgen_ty_1059 = -72002;
11322pub const kCFNetServicesErrorInProgress: _bindgen_ty_1059 = -72003;
11324pub const kCFNetServicesErrorBadArgument: _bindgen_ty_1059 = -72004;
11326pub const kCFNetServicesErrorCancel: _bindgen_ty_1059 = -72005;
11328pub const kCFNetServicesErrorInvalid: _bindgen_ty_1059 = -72006;
11330pub const kCFNetServicesErrorTimeout: _bindgen_ty_1059 = -72007;
11332pub const kCFNetServicesErrorMissingRequiredConfiguration: _bindgen_ty_1059 = -72008;
11334pub type _bindgen_ty_1059 = ::core::ffi::c_int;
11336pub type CFNetServiceMonitorType = ::core::ffi::c_int;
11338pub const kCFNetServiceMonitorTXT: _bindgen_ty_1060 = 1;
11340pub type _bindgen_ty_1060 = ::core::ffi::c_uint;
11342pub type CFNetServiceRegisterFlags = CFOptionFlags;
11344pub const kCFNetServiceFlagNoAutoRename: _bindgen_ty_1061 = 1;
11346pub type _bindgen_ty_1061 = ::core::ffi::c_uint;
11348pub type CFNetServiceBrowserFlags = CFOptionFlags;
11350pub const kCFNetServiceFlagMoreComing: _bindgen_ty_1062 = 1;
11352pub const kCFNetServiceFlagIsDomain: _bindgen_ty_1062 = 2;
11354pub const kCFNetServiceFlagIsDefault: _bindgen_ty_1062 = 4;
11356pub const kCFNetServiceFlagIsRegistrationDomain: _bindgen_ty_1062 = 4;
11358pub const kCFNetServiceFlagRemove: _bindgen_ty_1062 = 8;
11360pub type _bindgen_ty_1062 = ::core::ffi::c_uint;
11362#[repr(C, packed(2))]
11363#[derive(Debug, Copy, Clone)]
11364pub struct CFNetServiceClientContext {
11366 pub version: CFIndex,
11367 pub info: *mut ::core::ffi::c_void,
11368 pub retain: CFAllocatorRetainCallBack,
11369 pub release: CFAllocatorReleaseCallBack,
11370 pub copyDescription: CFAllocatorCopyDescriptionCallBack,
11371}
11372pub type CFNetServiceClientCallBack = ::core::option::Option<
11374 unsafe extern "C" fn(
11375 theService: CFNetServiceRef,
11376 error: *mut CFStreamError,
11377 info: *mut ::core::ffi::c_void,
11378 ),
11379>;
11380pub type CFNetServiceMonitorClientCallBack = ::core::option::Option<
11382 unsafe extern "C" fn(
11383 theMonitor: CFNetServiceMonitorRef,
11384 theService: CFNetServiceRef,
11385 typeInfo: CFNetServiceMonitorType,
11386 rdata: CFDataRef,
11387 error: *mut CFStreamError,
11388 info: *mut ::core::ffi::c_void,
11389 ),
11390>;
11391pub type CFNetServiceBrowserClientCallBack = ::core::option::Option<
11393 unsafe extern "C" fn(
11394 browser: CFNetServiceBrowserRef,
11395 flags: CFOptionFlags,
11396 domainOrService: CFTypeRef,
11397 error: *mut CFStreamError,
11398 info: *mut ::core::ffi::c_void,
11399 ),
11400>;
11401extern "C" {
11402pub fn CFNetServiceGetTypeID() -> CFTypeID;
11404}
11405extern "C" {
11406pub fn CFNetServiceMonitorGetTypeID() -> CFTypeID;
11408}
11409extern "C" {
11410pub fn CFNetServiceBrowserGetTypeID() -> CFTypeID;
11412}
11413extern "C" {
11414pub fn CFNetServiceCreate(
11416 alloc: CFAllocatorRef,
11417 domain: CFStringRef,
11418 serviceType: CFStringRef,
11419 name: CFStringRef,
11420 port: SInt32,
11421 ) -> CFNetServiceRef;
11422}
11423extern "C" {
11424pub fn CFNetServiceCreateCopy(
11426 alloc: CFAllocatorRef,
11427 service: CFNetServiceRef,
11428 ) -> CFNetServiceRef;
11429}
11430extern "C" {
11431pub fn CFNetServiceGetDomain(theService: CFNetServiceRef) -> CFStringRef;
11433}
11434extern "C" {
11435pub fn CFNetServiceGetType(theService: CFNetServiceRef) -> CFStringRef;
11437}
11438extern "C" {
11439pub fn CFNetServiceGetName(theService: CFNetServiceRef) -> CFStringRef;
11441}
11442extern "C" {
11443pub fn CFNetServiceRegisterWithOptions(
11445 theService: CFNetServiceRef,
11446 options: CFOptionFlags,
11447 error: *mut CFStreamError,
11448 ) -> Boolean;
11449}
11450extern "C" {
11451pub fn CFNetServiceResolveWithTimeout(
11453 theService: CFNetServiceRef,
11454 timeout: CFTimeInterval,
11455 error: *mut CFStreamError,
11456 ) -> Boolean;
11457}
11458extern "C" {
11459pub fn CFNetServiceCancel(theService: CFNetServiceRef);
11461}
11462extern "C" {
11463pub fn CFNetServiceGetTargetHost(theService: CFNetServiceRef) -> CFStringRef;
11465}
11466extern "C" {
11467pub fn CFNetServiceGetPortNumber(theService: CFNetServiceRef) -> SInt32;
11469}
11470extern "C" {
11471pub fn CFNetServiceGetAddressing(theService: CFNetServiceRef) -> CFArrayRef;
11473}
11474extern "C" {
11475pub fn CFNetServiceGetTXTData(theService: CFNetServiceRef) -> CFDataRef;
11477}
11478extern "C" {
11479pub fn CFNetServiceSetTXTData(theService: CFNetServiceRef, txtRecord: CFDataRef) -> Boolean;
11481}
11482extern "C" {
11483pub fn CFNetServiceCreateDictionaryWithTXTData(
11485 alloc: CFAllocatorRef,
11486 txtRecord: CFDataRef,
11487 ) -> CFDictionaryRef;
11488}
11489extern "C" {
11490pub fn CFNetServiceCreateTXTDataWithDictionary(
11492 alloc: CFAllocatorRef,
11493 keyValuePairs: CFDictionaryRef,
11494 ) -> CFDataRef;
11495}
11496extern "C" {
11497pub fn CFNetServiceSetClient(
11499 theService: CFNetServiceRef,
11500 clientCB: CFNetServiceClientCallBack,
11501 clientContext: *mut CFNetServiceClientContext,
11502 ) -> Boolean;
11503}
11504extern "C" {
11505pub fn CFNetServiceScheduleWithRunLoop(
11507 theService: CFNetServiceRef,
11508 runLoop: CFRunLoopRef,
11509 runLoopMode: CFStringRef,
11510 );
11511}
11512extern "C" {
11513pub fn CFNetServiceUnscheduleFromRunLoop(
11515 theService: CFNetServiceRef,
11516 runLoop: CFRunLoopRef,
11517 runLoopMode: CFStringRef,
11518 );
11519}
11520extern "C" {
11521pub fn CFNetServiceMonitorCreate(
11523 alloc: CFAllocatorRef,
11524 theService: CFNetServiceRef,
11525 clientCB: CFNetServiceMonitorClientCallBack,
11526 clientContext: *mut CFNetServiceClientContext,
11527 ) -> CFNetServiceMonitorRef;
11528}
11529extern "C" {
11530pub fn CFNetServiceMonitorInvalidate(monitor: CFNetServiceMonitorRef);
11532}
11533extern "C" {
11534pub fn CFNetServiceMonitorStart(
11536 monitor: CFNetServiceMonitorRef,
11537 recordType: CFNetServiceMonitorType,
11538 error: *mut CFStreamError,
11539 ) -> Boolean;
11540}
11541extern "C" {
11542pub fn CFNetServiceMonitorStop(monitor: CFNetServiceMonitorRef, error: *mut CFStreamError);
11544}
11545extern "C" {
11546pub fn CFNetServiceMonitorScheduleWithRunLoop(
11548 monitor: CFNetServiceMonitorRef,
11549 runLoop: CFRunLoopRef,
11550 runLoopMode: CFStringRef,
11551 );
11552}
11553extern "C" {
11554pub fn CFNetServiceMonitorUnscheduleFromRunLoop(
11556 monitor: CFNetServiceMonitorRef,
11557 runLoop: CFRunLoopRef,
11558 runLoopMode: CFStringRef,
11559 );
11560}
11561extern "C" {
11562pub fn CFNetServiceBrowserCreate(
11564 alloc: CFAllocatorRef,
11565 clientCB: CFNetServiceBrowserClientCallBack,
11566 clientContext: *mut CFNetServiceClientContext,
11567 ) -> CFNetServiceBrowserRef;
11568}
11569extern "C" {
11570pub fn CFNetServiceBrowserInvalidate(browser: CFNetServiceBrowserRef);
11572}
11573extern "C" {
11574pub fn CFNetServiceBrowserSearchForDomains(
11576 browser: CFNetServiceBrowserRef,
11577 registrationDomains: Boolean,
11578 error: *mut CFStreamError,
11579 ) -> Boolean;
11580}
11581extern "C" {
11582pub fn CFNetServiceBrowserSearchForServices(
11584 browser: CFNetServiceBrowserRef,
11585 domain: CFStringRef,
11586 serviceType: CFStringRef,
11587 error: *mut CFStreamError,
11588 ) -> Boolean;
11589}
11590extern "C" {
11591pub fn CFNetServiceBrowserStopSearch(
11593 browser: CFNetServiceBrowserRef,
11594 error: *mut CFStreamError,
11595 );
11596}
11597extern "C" {
11598pub fn CFNetServiceBrowserScheduleWithRunLoop(
11600 browser: CFNetServiceBrowserRef,
11601 runLoop: CFRunLoopRef,
11602 runLoopMode: CFStringRef,
11603 );
11604}
11605extern "C" {
11606pub fn CFNetServiceBrowserUnscheduleFromRunLoop(
11608 browser: CFNetServiceBrowserRef,
11609 runLoop: CFRunLoopRef,
11610 runLoopMode: CFStringRef,
11611 );
11612}
11613extern "C" {
11614pub fn CFNetServiceRegister(theService: CFNetServiceRef, error: *mut CFStreamError) -> Boolean;
11616}
11617extern "C" {
11618pub fn CFNetServiceResolve(theService: CFNetServiceRef, error: *mut CFStreamError) -> Boolean;
11620}
11621extern "C" {
11622pub static kCFStreamPropertySSLContext: CFStringRef;
11624}
11625extern "C" {
11626pub static kCFStreamPropertySSLPeerTrust: CFStringRef;
11628}
11629extern "C" {
11630pub static kCFStreamSSLValidatesCertificateChain: CFStringRef;
11632}
11633extern "C" {
11634pub static kCFStreamPropertySSLSettings: CFStringRef;
11636}
11637extern "C" {
11638pub static kCFStreamSSLLevel: CFStringRef;
11640}
11641extern "C" {
11642pub static kCFStreamSSLPeerName: CFStringRef;
11644}
11645extern "C" {
11646pub static kCFStreamSSLCertificates: CFStringRef;
11648}
11649extern "C" {
11650pub static kCFStreamSSLIsServer: CFStringRef;
11652}
11653extern "C" {
11654pub static kCFStreamNetworkServiceType: CFStringRef;
11656}
11657extern "C" {
11658pub static kCFStreamNetworkServiceTypeVideo: CFStringRef;
11660}
11661extern "C" {
11662pub static kCFStreamNetworkServiceTypeVoice: CFStringRef;
11664}
11665extern "C" {
11666pub static kCFStreamNetworkServiceTypeBackground: CFStringRef;
11668}
11669extern "C" {
11670pub static kCFStreamNetworkServiceTypeResponsiveData: CFStringRef;
11672}
11673extern "C" {
11674pub static kCFStreamNetworkServiceTypeCallSignaling: CFStringRef;
11676}
11677extern "C" {
11678pub static kCFStreamNetworkServiceTypeAVStreaming: CFStringRef;
11680}
11681extern "C" {
11682pub static kCFStreamNetworkServiceTypeResponsiveAV: CFStringRef;
11684}
11685extern "C" {
11686pub static kCFStreamNetworkServiceTypeVoIP: CFStringRef;
11688}
11689extern "C" {
11690pub static kCFStreamPropertyNoCellular: CFStringRef;
11692}
11693extern "C" {
11694pub static kCFStreamPropertyConnectionIsCellular: CFStringRef;
11696}
11697extern "C" {
11698pub static kCFStreamPropertyAllowExpensiveNetworkAccess: CFStringRef;
11700}
11701extern "C" {
11702pub static kCFStreamPropertyConnectionIsExpensive: CFStringRef;
11704}
11705extern "C" {
11706pub static kCFStreamPropertyAllowConstrainedNetworkAccess: CFStringRef;
11708}
11709extern "C" {
11710pub static kCFStreamErrorDomainWinSock: CFIndex;
11712}
11713pub const kCFStreamErrorSOCKSSubDomainNone: _bindgen_ty_1063 = 0;
11715pub const kCFStreamErrorSOCKSSubDomainVersionCode: _bindgen_ty_1063 = 1;
11717pub const kCFStreamErrorSOCKS4SubDomainResponse: _bindgen_ty_1063 = 2;
11719pub const kCFStreamErrorSOCKS5SubDomainUserPass: _bindgen_ty_1063 = 3;
11721pub const kCFStreamErrorSOCKS5SubDomainMethod: _bindgen_ty_1063 = 4;
11723pub const kCFStreamErrorSOCKS5SubDomainResponse: _bindgen_ty_1063 = 5;
11725pub type _bindgen_ty_1063 = ::core::ffi::c_uint;
11727pub const kCFStreamErrorSOCKS5BadResponseAddr: _bindgen_ty_1064 = 1;
11729pub const kCFStreamErrorSOCKS5BadState: _bindgen_ty_1064 = 2;
11731pub const kCFStreamErrorSOCKSUnknownClientVersion: _bindgen_ty_1064 = 3;
11733pub type _bindgen_ty_1064 = ::core::ffi::c_uint;
11735pub const kCFStreamErrorSOCKS4RequestFailed: _bindgen_ty_1065 = 91;
11737pub const kCFStreamErrorSOCKS4IdentdFailed: _bindgen_ty_1065 = 92;
11739pub const kCFStreamErrorSOCKS4IdConflict: _bindgen_ty_1065 = 93;
11741pub type _bindgen_ty_1065 = ::core::ffi::c_uint;
11743extern "C" {
11744pub static kCFStreamPropertyProxyLocalBypass: CFStringRef;
11746}
11747extern "C" {
11748pub static kCFStreamPropertySocketRemoteHost: CFStringRef;
11750}
11751extern "C" {
11752pub static kCFStreamPropertySocketRemoteNetService: CFStringRef;
11754}
11755extern "C" {
11756pub static kCFStreamPropertySocketExtendedBackgroundIdleMode: CFStringRef;
11758}
11759extern "C" {
11760pub fn CFStreamCreatePairWithSocketToCFHost(
11762 alloc: CFAllocatorRef,
11763 host: CFHostRef,
11764 port: SInt32,
11765 readStream: *mut CFReadStreamRef,
11766 writeStream: *mut CFWriteStreamRef,
11767 );
11768}
11769extern "C" {
11770pub fn CFStreamCreatePairWithSocketToNetService(
11772 alloc: CFAllocatorRef,
11773 service: CFNetServiceRef,
11774 readStream: *mut CFReadStreamRef,
11775 writeStream: *mut CFWriteStreamRef,
11776 );
11777}
11778extern "C" {
11779pub static kCFStreamPropertySSLPeerCertificates: CFStringRef;
11781}
11782extern "C" {
11783pub static kCFStreamSSLAllowsExpiredCertificates: CFStringRef;
11785}
11786extern "C" {
11787pub static kCFStreamSSLAllowsExpiredRoots: CFStringRef;
11789}
11790extern "C" {
11791pub static kCFStreamSSLAllowsAnyRoot: CFStringRef;
11793}
11794extern "C" {
11795pub static kCFStreamErrorDomainFTP: SInt32;
11797}
11798extern "C" {
11799pub static kCFStreamPropertyFTPUserName: CFStringRef;
11801}
11802extern "C" {
11803pub static kCFStreamPropertyFTPPassword: CFStringRef;
11805}
11806extern "C" {
11807pub static kCFStreamPropertyFTPUsePassiveMode: CFStringRef;
11809}
11810extern "C" {
11811pub static kCFStreamPropertyFTPResourceSize: CFStringRef;
11813}
11814extern "C" {
11815pub static kCFStreamPropertyFTPFetchResourceInfo: CFStringRef;
11817}
11818extern "C" {
11819pub static kCFStreamPropertyFTPFileTransferOffset: CFStringRef;
11821}
11822extern "C" {
11823pub static kCFStreamPropertyFTPAttemptPersistentConnection: CFStringRef;
11825}
11826extern "C" {
11827pub static kCFStreamPropertyFTPProxy: CFStringRef;
11829}
11830extern "C" {
11831pub static kCFStreamPropertyFTPProxyHost: CFStringRef;
11833}
11834extern "C" {
11835pub static kCFStreamPropertyFTPProxyPort: CFStringRef;
11837}
11838extern "C" {
11839pub static kCFStreamPropertyFTPProxyUser: CFStringRef;
11841}
11842extern "C" {
11843pub static kCFStreamPropertyFTPProxyPassword: CFStringRef;
11845}
11846extern "C" {
11847pub static kCFFTPResourceMode: CFStringRef;
11849}
11850extern "C" {
11851pub static kCFFTPResourceName: CFStringRef;
11853}
11854extern "C" {
11855pub static kCFFTPResourceOwner: CFStringRef;
11857}
11858extern "C" {
11859pub static kCFFTPResourceGroup: CFStringRef;
11861}
11862extern "C" {
11863pub static kCFFTPResourceLink: CFStringRef;
11865}
11866extern "C" {
11867pub static kCFFTPResourceSize: CFStringRef;
11869}
11870extern "C" {
11871pub static kCFFTPResourceType: CFStringRef;
11873}
11874extern "C" {
11875pub static kCFFTPResourceModDate: CFStringRef;
11877}
11878extern "C" {
11879pub fn CFReadStreamCreateWithFTPURL(alloc: CFAllocatorRef, ftpURL: CFURLRef)
11881 -> CFReadStreamRef;
11882}
11883extern "C" {
11884pub fn CFFTPCreateParsedResourceListing(
11886 alloc: CFAllocatorRef,
11887 buffer: *const UInt8,
11888 bufferLength: CFIndex,
11889 parsed: *mut CFDictionaryRef,
11890 ) -> CFIndex;
11891}
11892extern "C" {
11893pub fn CFWriteStreamCreateWithFTPURL(
11895 alloc: CFAllocatorRef,
11896 ftpURL: CFURLRef,
11897 ) -> CFWriteStreamRef;
11898}
11899extern "C" {
11900pub static kCFHTTPVersion1_0: CFStringRef;
11902}
11903extern "C" {
11904pub static kCFHTTPVersion1_1: CFStringRef;
11906}
11907extern "C" {
11908pub static kCFHTTPVersion2_0: CFStringRef;
11910}
11911extern "C" {
11912pub static kCFHTTPVersion3_0: CFStringRef;
11914}
11915extern "C" {
11916pub static kCFHTTPAuthenticationSchemeBasic: CFStringRef;
11918}
11919extern "C" {
11920pub static kCFHTTPAuthenticationSchemeDigest: CFStringRef;
11922}
11923extern "C" {
11924pub static kCFHTTPAuthenticationSchemeNTLM: CFStringRef;
11926}
11927extern "C" {
11928pub static kCFHTTPAuthenticationSchemeKerberos: CFStringRef;
11930}
11931extern "C" {
11932pub static kCFHTTPAuthenticationSchemeNegotiate: CFStringRef;
11934}
11935extern "C" {
11936pub static kCFHTTPAuthenticationSchemeNegotiate2: CFStringRef;
11938}
11939extern "C" {
11940pub static kCFHTTPAuthenticationSchemeXMobileMeAuthToken: CFStringRef;
11942}
11943#[repr(C)]
11944#[derive(Debug, Copy, Clone)]
11945pub struct __CFHTTPMessage {
11947 _unused: [u8; 0],
11948}
11949pub type CFHTTPMessageRef = *mut __CFHTTPMessage;
11951extern "C" {
11952pub fn CFHTTPMessageGetTypeID() -> CFTypeID;
11954}
11955extern "C" {
11956pub fn CFHTTPMessageCreateRequest(
11958 alloc: CFAllocatorRef,
11959 requestMethod: CFStringRef,
11960 url: CFURLRef,
11961 httpVersion: CFStringRef,
11962 ) -> CFHTTPMessageRef;
11963}
11964extern "C" {
11965pub fn CFHTTPMessageCreateResponse(
11967 alloc: CFAllocatorRef,
11968 statusCode: CFIndex,
11969 statusDescription: CFStringRef,
11970 httpVersion: CFStringRef,
11971 ) -> CFHTTPMessageRef;
11972}
11973extern "C" {
11974pub fn CFHTTPMessageCreateEmpty(alloc: CFAllocatorRef, isRequest: Boolean) -> CFHTTPMessageRef;
11976}
11977extern "C" {
11978pub fn CFHTTPMessageCreateCopy(
11980 alloc: CFAllocatorRef,
11981 message: CFHTTPMessageRef,
11982 ) -> CFHTTPMessageRef;
11983}
11984extern "C" {
11985pub fn CFHTTPMessageIsRequest(message: CFHTTPMessageRef) -> Boolean;
11987}
11988extern "C" {
11989pub fn CFHTTPMessageCopyVersion(message: CFHTTPMessageRef) -> CFStringRef;
11991}
11992extern "C" {
11993pub fn CFHTTPMessageCopyBody(message: CFHTTPMessageRef) -> CFDataRef;
11995}
11996extern "C" {
11997pub fn CFHTTPMessageSetBody(message: CFHTTPMessageRef, bodyData: CFDataRef);
11999}
12000extern "C" {
12001pub fn CFHTTPMessageCopyHeaderFieldValue(
12003 message: CFHTTPMessageRef,
12004 headerField: CFStringRef,
12005 ) -> CFStringRef;
12006}
12007extern "C" {
12008pub fn CFHTTPMessageCopyAllHeaderFields(message: CFHTTPMessageRef) -> CFDictionaryRef;
12010}
12011extern "C" {
12012pub fn CFHTTPMessageSetHeaderFieldValue(
12014 message: CFHTTPMessageRef,
12015 headerField: CFStringRef,
12016 value: CFStringRef,
12017 );
12018}
12019extern "C" {
12020pub fn CFHTTPMessageAppendBytes(
12022 message: CFHTTPMessageRef,
12023 newBytes: *const UInt8,
12024 numBytes: CFIndex,
12025 ) -> Boolean;
12026}
12027extern "C" {
12028pub fn CFHTTPMessageIsHeaderComplete(message: CFHTTPMessageRef) -> Boolean;
12030}
12031extern "C" {
12032pub fn CFHTTPMessageCopySerializedMessage(message: CFHTTPMessageRef) -> CFDataRef;
12034}
12035extern "C" {
12036pub fn CFHTTPMessageCopyRequestURL(request: CFHTTPMessageRef) -> CFURLRef;
12038}
12039extern "C" {
12040pub fn CFHTTPMessageCopyRequestMethod(request: CFHTTPMessageRef) -> CFStringRef;
12042}
12043extern "C" {
12044pub fn CFHTTPMessageAddAuthentication(
12046 request: CFHTTPMessageRef,
12047 authenticationFailureResponse: CFHTTPMessageRef,
12048 username: CFStringRef,
12049 password: CFStringRef,
12050 authenticationScheme: CFStringRef,
12051 forProxy: Boolean,
12052 ) -> Boolean;
12053}
12054extern "C" {
12055pub fn CFHTTPMessageGetResponseStatusCode(response: CFHTTPMessageRef) -> CFIndex;
12057}
12058extern "C" {
12059pub fn CFHTTPMessageCopyResponseStatusLine(response: CFHTTPMessageRef) -> CFStringRef;
12061}
12062extern "C" {
12063pub static kCFStreamErrorDomainHTTP: SInt32;
12065}
12066pub type CFStreamErrorHTTP = ::core::ffi::c_int;
12068pub const kCFStreamErrorHTTPParseFailure: _bindgen_ty_1067 = -1;
12070pub const kCFStreamErrorHTTPRedirectionLoop: _bindgen_ty_1067 = -2;
12072pub const kCFStreamErrorHTTPBadURL: _bindgen_ty_1067 = -3;
12074pub type _bindgen_ty_1067 = ::core::ffi::c_int;
12076extern "C" {
12077pub static kCFStreamPropertyHTTPResponseHeader: CFStringRef;
12079}
12080extern "C" {
12081pub static kCFStreamPropertyHTTPFinalURL: CFStringRef;
12083}
12084extern "C" {
12085pub static kCFStreamPropertyHTTPFinalRequest: CFStringRef;
12087}
12088extern "C" {
12089pub static kCFStreamPropertyHTTPProxy: CFStringRef;
12091}
12092extern "C" {
12093pub static kCFStreamPropertyHTTPProxyHost: CFStringRef;
12095}
12096extern "C" {
12097pub static kCFStreamPropertyHTTPProxyPort: CFStringRef;
12099}
12100extern "C" {
12101pub static kCFStreamPropertyHTTPSProxyHost: CFStringRef;
12103}
12104extern "C" {
12105pub static kCFStreamPropertyHTTPSProxyPort: CFStringRef;
12107}
12108extern "C" {
12109pub static kCFStreamPropertyHTTPShouldAutoredirect: CFStringRef;
12111}
12112extern "C" {
12113pub static kCFStreamPropertyHTTPAttemptPersistentConnection: CFStringRef;
12115}
12116extern "C" {
12117pub static kCFStreamPropertyHTTPRequestBytesWrittenCount: CFStringRef;
12119}
12120extern "C" {
12121pub fn CFReadStreamCreateForHTTPRequest(
12123 alloc: CFAllocatorRef,
12124 request: CFHTTPMessageRef,
12125 ) -> CFReadStreamRef;
12126}
12127extern "C" {
12128pub fn CFReadStreamCreateForStreamedHTTPRequest(
12130 alloc: CFAllocatorRef,
12131 requestHeaders: CFHTTPMessageRef,
12132 requestBody: CFReadStreamRef,
12133 ) -> CFReadStreamRef;
12134}
12135#[repr(C)]
12136#[derive(Debug, Copy, Clone)]
12137pub struct _CFHTTPAuthentication {
12139 _unused: [u8; 0],
12140}
12141pub type CFHTTPAuthenticationRef = *mut _CFHTTPAuthentication;
12143pub type CFStreamErrorHTTPAuthentication = ::core::ffi::c_int;
12145pub const kCFStreamErrorHTTPAuthenticationTypeUnsupported: _bindgen_ty_1068 = -1000;
12147pub const kCFStreamErrorHTTPAuthenticationBadUserName: _bindgen_ty_1068 = -1001;
12149pub const kCFStreamErrorHTTPAuthenticationBadPassword: _bindgen_ty_1068 = -1002;
12151pub type _bindgen_ty_1068 = ::core::ffi::c_int;
12153extern "C" {
12154pub static kCFHTTPAuthenticationUsername: CFStringRef;
12156}
12157extern "C" {
12158pub static kCFHTTPAuthenticationPassword: CFStringRef;
12160}
12161extern "C" {
12162pub static kCFHTTPAuthenticationAccountDomain: CFStringRef;
12164}
12165extern "C" {
12166pub fn CFHTTPAuthenticationGetTypeID() -> CFTypeID;
12168}
12169extern "C" {
12170pub fn CFHTTPAuthenticationCreateFromResponse(
12172 alloc: CFAllocatorRef,
12173 response: CFHTTPMessageRef,
12174 ) -> CFHTTPAuthenticationRef;
12175}
12176extern "C" {
12177pub fn CFHTTPAuthenticationIsValid(
12179 auth: CFHTTPAuthenticationRef,
12180 error: *mut CFStreamError,
12181 ) -> Boolean;
12182}
12183extern "C" {
12184pub fn CFHTTPAuthenticationAppliesToRequest(
12186 auth: CFHTTPAuthenticationRef,
12187 request: CFHTTPMessageRef,
12188 ) -> Boolean;
12189}
12190extern "C" {
12191pub fn CFHTTPAuthenticationRequiresOrderedRequests(auth: CFHTTPAuthenticationRef) -> Boolean;
12193}
12194extern "C" {
12195pub fn CFHTTPMessageApplyCredentials(
12197 request: CFHTTPMessageRef,
12198 auth: CFHTTPAuthenticationRef,
12199 username: CFStringRef,
12200 password: CFStringRef,
12201 error: *mut CFStreamError,
12202 ) -> Boolean;
12203}
12204extern "C" {
12205pub fn CFHTTPMessageApplyCredentialDictionary(
12207 request: CFHTTPMessageRef,
12208 auth: CFHTTPAuthenticationRef,
12209 dict: CFDictionaryRef,
12210 error: *mut CFStreamError,
12211 ) -> Boolean;
12212}
12213extern "C" {
12214pub fn CFHTTPAuthenticationCopyRealm(auth: CFHTTPAuthenticationRef) -> CFStringRef;
12216}
12217extern "C" {
12218pub fn CFHTTPAuthenticationCopyDomains(auth: CFHTTPAuthenticationRef) -> CFArrayRef;
12220}
12221extern "C" {
12222pub fn CFHTTPAuthenticationCopyMethod(auth: CFHTTPAuthenticationRef) -> CFStringRef;
12224}
12225extern "C" {
12226pub fn CFHTTPAuthenticationRequiresUserNameAndPassword(
12228 auth: CFHTTPAuthenticationRef,
12229 ) -> Boolean;
12230}
12231extern "C" {
12232pub fn CFHTTPAuthenticationRequiresAccountDomain(auth: CFHTTPAuthenticationRef) -> Boolean;
12234}
12235#[repr(C)]
12236#[derive(Debug, Copy, Clone)]
12237pub struct __CFNetDiagnostic {
12239 _unused: [u8; 0],
12240}
12241pub type CFNetDiagnosticRef = *mut __CFNetDiagnostic;
12243pub type CFNetDiagnosticStatusValues = ::core::ffi::c_int;
12245pub const kCFNetDiagnosticNoErr: _bindgen_ty_1069 = 0;
12247pub const kCFNetDiagnosticErr: _bindgen_ty_1069 = -66560;
12249pub const kCFNetDiagnosticConnectionUp: _bindgen_ty_1069 = -66559;
12251pub const kCFNetDiagnosticConnectionIndeterminate: _bindgen_ty_1069 = -66558;
12253pub const kCFNetDiagnosticConnectionDown: _bindgen_ty_1069 = -66557;
12255pub type _bindgen_ty_1069 = ::core::ffi::c_int;
12257pub type CFNetDiagnosticStatus = CFIndex;
12259extern "C" {
12260pub fn CFNetDiagnosticCreateWithStreams(
12262 alloc: CFAllocatorRef,
12263 readStream: CFReadStreamRef,
12264 writeStream: CFWriteStreamRef,
12265 ) -> CFNetDiagnosticRef;
12266}
12267extern "C" {
12268pub fn CFNetDiagnosticCreateWithURL(alloc: CFAllocatorRef, url: CFURLRef)
12270 -> CFNetDiagnosticRef;
12271}
12272extern "C" {
12273pub fn CFNetDiagnosticSetName(details: CFNetDiagnosticRef, name: CFStringRef);
12275}
12276extern "C" {
12277pub fn CFNetDiagnosticDiagnoseProblemInteractively(
12279 details: CFNetDiagnosticRef,
12280 ) -> CFNetDiagnosticStatus;
12281}
12282extern "C" {
12283pub fn CFNetDiagnosticCopyNetworkStatusPassively(
12285 details: CFNetDiagnosticRef,
12286 description: *mut CFStringRef,
12287 ) -> CFNetDiagnosticStatus;
12288}
12289extern "C" {
12290pub fn CFNetworkCopySystemProxySettings() -> CFDictionaryRef;
12292}
12293extern "C" {
12294pub fn CFNetworkCopyProxiesForURL(url: CFURLRef, proxySettings: CFDictionaryRef) -> CFArrayRef;
12296}
12297pub type CFProxyAutoConfigurationResultCallback = ::core::option::Option<
12299 unsafe extern "C" fn(
12300 client: *mut ::core::ffi::c_void,
12301 proxyList: CFArrayRef,
12302 error: CFErrorRef,
12303 ),
12304>;
12305extern "C" {
12306pub fn CFNetworkCopyProxiesForAutoConfigurationScript(
12308 proxyAutoConfigurationScript: CFStringRef,
12309 targetURL: CFURLRef,
12310 error: *mut CFErrorRef,
12311 ) -> CFArrayRef;
12312}
12313extern "C" {
12314pub fn CFNetworkExecuteProxyAutoConfigurationScript(
12316 proxyAutoConfigurationScript: CFStringRef,
12317 targetURL: CFURLRef,
12318 cb: CFProxyAutoConfigurationResultCallback,
12319 clientContext: *mut CFStreamClientContext,
12320 ) -> CFRunLoopSourceRef;
12321}
12322extern "C" {
12323pub fn CFNetworkExecuteProxyAutoConfigurationURL(
12325 proxyAutoConfigURL: CFURLRef,
12326 targetURL: CFURLRef,
12327 cb: CFProxyAutoConfigurationResultCallback,
12328 clientContext: *mut CFStreamClientContext,
12329 ) -> CFRunLoopSourceRef;
12330}
12331extern "C" {
12332pub static kCFProxyTypeKey: CFStringRef;
12334}
12335extern "C" {
12336pub static kCFProxyHostNameKey: CFStringRef;
12338}
12339extern "C" {
12340pub static kCFProxyPortNumberKey: CFStringRef;
12342}
12343extern "C" {
12344pub static kCFProxyAutoConfigurationURLKey: CFStringRef;
12346}
12347extern "C" {
12348pub static kCFProxyAutoConfigurationJavaScriptKey: CFStringRef;
12350}
12351extern "C" {
12352pub static kCFProxyUsernameKey: CFStringRef;
12354}
12355extern "C" {
12356pub static kCFProxyPasswordKey: CFStringRef;
12358}
12359extern "C" {
12360pub static kCFProxyTypeNone: CFStringRef;
12362}
12363extern "C" {
12364pub static kCFProxyTypeHTTP: CFStringRef;
12366}
12367extern "C" {
12368pub static kCFProxyTypeHTTPS: CFStringRef;
12370}
12371extern "C" {
12372pub static kCFProxyTypeSOCKS: CFStringRef;
12374}
12375extern "C" {
12376pub static kCFProxyTypeFTP: CFStringRef;
12378}
12379extern "C" {
12380pub static kCFProxyTypeAutoConfigurationURL: CFStringRef;
12382}
12383extern "C" {
12384pub static kCFProxyTypeAutoConfigurationJavaScript: CFStringRef;
12386}
12387extern "C" {
12388pub static kCFProxyAutoConfigurationHTTPResponseKey: CFStringRef;
12390}
12391extern "C" {
12392pub static kCFNetworkProxiesExceptionsList: CFStringRef;
12394}
12395extern "C" {
12396pub static kCFNetworkProxiesExcludeSimpleHostnames: CFStringRef;
12398}
12399extern "C" {
12400pub static kCFNetworkProxiesFTPEnable: CFStringRef;
12402}
12403extern "C" {
12404pub static kCFNetworkProxiesFTPPassive: CFStringRef;
12406}
12407extern "C" {
12408pub static kCFNetworkProxiesFTPPort: CFStringRef;
12410}
12411extern "C" {
12412pub static kCFNetworkProxiesFTPProxy: CFStringRef;
12414}
12415extern "C" {
12416pub static kCFNetworkProxiesGopherEnable: CFStringRef;
12418}
12419extern "C" {
12420pub static kCFNetworkProxiesGopherPort: CFStringRef;
12422}
12423extern "C" {
12424pub static kCFNetworkProxiesGopherProxy: CFStringRef;
12426}
12427extern "C" {
12428pub static kCFNetworkProxiesHTTPEnable: CFStringRef;
12430}
12431extern "C" {
12432pub static kCFNetworkProxiesHTTPPort: CFStringRef;
12434}
12435extern "C" {
12436pub static kCFNetworkProxiesHTTPProxy: CFStringRef;
12438}
12439extern "C" {
12440pub static kCFNetworkProxiesHTTPSEnable: CFStringRef;
12442}
12443extern "C" {
12444pub static kCFNetworkProxiesHTTPSPort: CFStringRef;
12446}
12447extern "C" {
12448pub static kCFNetworkProxiesHTTPSProxy: CFStringRef;
12450}
12451extern "C" {
12452pub static kCFNetworkProxiesRTSPEnable: CFStringRef;
12454}
12455extern "C" {
12456pub static kCFNetworkProxiesRTSPPort: CFStringRef;
12458}
12459extern "C" {
12460pub static kCFNetworkProxiesRTSPProxy: CFStringRef;
12462}
12463extern "C" {
12464pub static kCFNetworkProxiesSOCKSEnable: CFStringRef;
12466}
12467extern "C" {
12468pub static kCFNetworkProxiesSOCKSPort: CFStringRef;
12470}
12471extern "C" {
12472pub static kCFNetworkProxiesSOCKSProxy: CFStringRef;
12474}
12475extern "C" {
12476pub static kCFNetworkProxiesProxyAutoConfigEnable: CFStringRef;
12478}
12479extern "C" {
12480pub static kCFNetworkProxiesProxyAutoConfigURLString: CFStringRef;
12482}
12483extern "C" {
12484pub static kCFNetworkProxiesProxyAutoConfigJavaScript: CFStringRef;
12486}
12487extern "C" {
12488pub static kCFNetworkProxiesProxyAutoDiscoveryEnable: CFStringRef;
12490}
12491#[repr(C)]
12492#[derive(Debug, Copy, Clone)]
12493pub struct __SecCertificate {
12495 _unused: [u8; 0],
12496}
12497pub type SecCertificateRef = *mut __SecCertificate;
12499#[repr(C)]
12500#[derive(Debug, Copy, Clone)]
12501pub struct cssm_data {
12503 pub Length: usize,
12504 pub Data: *mut u8,
12505}
12506pub type SecAsn1Oid = cssm_data;
12508#[repr(C)]
12509#[derive(Debug, Copy, Clone)]
12510pub struct __SecTrust {
12512 _unused: [u8; 0],
12513}
12514pub type SecTrustRef = *mut __SecTrust;
12516pub type xpc_object_t = *mut ::core::ffi::c_void;
12518#[repr(C)]
12519#[derive(Debug, Copy, Clone)]
12520pub struct _CMSDecoder {
12522 _unused: [u8; 0],
12523}
12524pub type CMSDecoderRef = *mut _CMSDecoder;
12526extern "C" {
12527pub fn CMSDecoderGetTypeID() -> CFTypeID;
12529}
12530pub type CMSSignerStatus = u32;
12532pub const kCMSSignerUnsigned: _bindgen_ty_1276 = 0;
12534pub const kCMSSignerValid: _bindgen_ty_1276 = 1;
12536pub const kCMSSignerNeedsDetachedContent: _bindgen_ty_1276 = 2;
12538pub const kCMSSignerInvalidSignature: _bindgen_ty_1276 = 3;
12540pub const kCMSSignerInvalidCert: _bindgen_ty_1276 = 4;
12542pub const kCMSSignerInvalidIndex: _bindgen_ty_1276 = 5;
12544pub type _bindgen_ty_1276 = ::core::ffi::c_uint;
12546extern "C" {
12547pub fn CMSDecoderCreate(cmsDecoderOut: *mut CMSDecoderRef) -> OSStatus;
12549}
12550extern "C" {
12551pub fn CMSDecoderUpdateMessage(
12553 cmsDecoder: CMSDecoderRef,
12554 msgBytes: *const ::core::ffi::c_void,
12555 msgBytesLen: usize,
12556 ) -> OSStatus;
12557}
12558extern "C" {
12559pub fn CMSDecoderFinalizeMessage(cmsDecoder: CMSDecoderRef) -> OSStatus;
12561}
12562extern "C" {
12563pub fn CMSDecoderSetDetachedContent(
12565 cmsDecoder: CMSDecoderRef,
12566 detachedContent: CFDataRef,
12567 ) -> OSStatus;
12568}
12569extern "C" {
12570pub fn CMSDecoderCopyDetachedContent(
12572 cmsDecoder: CMSDecoderRef,
12573 detachedContentOut: *mut CFDataRef,
12574 ) -> OSStatus;
12575}
12576extern "C" {
12577pub fn CMSDecoderSetSearchKeychain(
12579 cmsDecoder: CMSDecoderRef,
12580 keychainOrArray: CFTypeRef,
12581 ) -> OSStatus;
12582}
12583extern "C" {
12584pub fn CMSDecoderGetNumSigners(
12586 cmsDecoder: CMSDecoderRef,
12587 numSignersOut: *mut usize,
12588 ) -> OSStatus;
12589}
12590extern "C" {
12591pub fn CMSDecoderCopySignerStatus(
12593 cmsDecoder: CMSDecoderRef,
12594 signerIndex: usize,
12595 policyOrArray: CFTypeRef,
12596 evaluateSecTrust: Boolean,
12597 signerStatusOut: *mut CMSSignerStatus,
12598 secTrustOut: *mut SecTrustRef,
12599 certVerifyResultCodeOut: *mut OSStatus,
12600 ) -> OSStatus;
12601}
12602extern "C" {
12603pub fn CMSDecoderCopySignerEmailAddress(
12605 cmsDecoder: CMSDecoderRef,
12606 signerIndex: usize,
12607 signerEmailAddressOut: *mut CFStringRef,
12608 ) -> OSStatus;
12609}
12610extern "C" {
12611pub fn CMSDecoderCopySignerCert(
12613 cmsDecoder: CMSDecoderRef,
12614 signerIndex: usize,
12615 signerCertOut: *mut SecCertificateRef,
12616 ) -> OSStatus;
12617}
12618extern "C" {
12619pub fn CMSDecoderIsContentEncrypted(
12621 cmsDecoder: CMSDecoderRef,
12622 isEncryptedOut: *mut Boolean,
12623 ) -> OSStatus;
12624}
12625extern "C" {
12626pub fn CMSDecoderCopyEncapsulatedContentType(
12628 cmsDecoder: CMSDecoderRef,
12629 eContentTypeOut: *mut CFDataRef,
12630 ) -> OSStatus;
12631}
12632extern "C" {
12633pub fn CMSDecoderCopyAllCerts(cmsDecoder: CMSDecoderRef, certsOut: *mut CFArrayRef)
12635 -> OSStatus;
12636}
12637extern "C" {
12638pub fn CMSDecoderCopyContent(cmsDecoder: CMSDecoderRef, contentOut: *mut CFDataRef)
12640 -> OSStatus;
12641}
12642extern "C" {
12643pub fn CMSDecoderCopySignerSigningTime(
12645 cmsDecoder: CMSDecoderRef,
12646 signerIndex: usize,
12647 signingTime: *mut CFAbsoluteTime,
12648 ) -> OSStatus;
12649}
12650extern "C" {
12651pub fn CMSDecoderCopySignerTimestamp(
12653 cmsDecoder: CMSDecoderRef,
12654 signerIndex: usize,
12655 timestamp: *mut CFAbsoluteTime,
12656 ) -> OSStatus;
12657}
12658extern "C" {
12659pub fn CMSDecoderCopySignerTimestampWithPolicy(
12661 cmsDecoder: CMSDecoderRef,
12662 timeStampPolicy: CFTypeRef,
12663 signerIndex: usize,
12664 timestamp: *mut CFAbsoluteTime,
12665 ) -> OSStatus;
12666}
12667extern "C" {
12668pub fn CMSDecoderCopySignerTimestampCertificates(
12670 cmsDecoder: CMSDecoderRef,
12671 signerIndex: usize,
12672 certificateRefs: *mut CFArrayRef,
12673 ) -> OSStatus;
12674}
12675#[repr(C)]
12676#[derive(Debug, Copy, Clone)]
12677pub struct _CMSEncoder {
12679 _unused: [u8; 0],
12680}
12681pub type CMSEncoderRef = *mut _CMSEncoder;
12683extern "C" {
12684pub fn CMSEncoderGetTypeID() -> CFTypeID;
12686}
12687extern "C" {
12688pub fn CMSEncoderCreate(cmsEncoderOut: *mut CMSEncoderRef) -> OSStatus;
12690}
12691extern "C" {
12692pub static kCMSEncoderDigestAlgorithmSHA1: CFStringRef;
12694}
12695extern "C" {
12696pub static kCMSEncoderDigestAlgorithmSHA256: CFStringRef;
12698}
12699extern "C" {
12700pub fn CMSEncoderSetSignerAlgorithm(
12702 cmsEncoder: CMSEncoderRef,
12703 digestAlgorithm: CFStringRef,
12704 ) -> OSStatus;
12705}
12706extern "C" {
12707pub fn CMSEncoderAddSigners(cmsEncoder: CMSEncoderRef, signerOrArray: CFTypeRef) -> OSStatus;
12709}
12710extern "C" {
12711pub fn CMSEncoderCopySigners(
12713 cmsEncoder: CMSEncoderRef,
12714 signersOut: *mut CFArrayRef,
12715 ) -> OSStatus;
12716}
12717extern "C" {
12718pub fn CMSEncoderAddRecipients(
12720 cmsEncoder: CMSEncoderRef,
12721 recipientOrArray: CFTypeRef,
12722 ) -> OSStatus;
12723}
12724extern "C" {
12725pub fn CMSEncoderCopyRecipients(
12727 cmsEncoder: CMSEncoderRef,
12728 recipientsOut: *mut CFArrayRef,
12729 ) -> OSStatus;
12730}
12731extern "C" {
12732pub fn CMSEncoderSetHasDetachedContent(
12734 cmsEncoder: CMSEncoderRef,
12735 detachedContent: Boolean,
12736 ) -> OSStatus;
12737}
12738extern "C" {
12739pub fn CMSEncoderGetHasDetachedContent(
12741 cmsEncoder: CMSEncoderRef,
12742 detachedContentOut: *mut Boolean,
12743 ) -> OSStatus;
12744}
12745extern "C" {
12746pub fn CMSEncoderSetEncapsulatedContentType(
12748 cmsEncoder: CMSEncoderRef,
12749 eContentType: *const SecAsn1Oid,
12750 ) -> OSStatus;
12751}
12752extern "C" {
12753pub fn CMSEncoderSetEncapsulatedContentTypeOID(
12755 cmsEncoder: CMSEncoderRef,
12756 eContentTypeOID: CFTypeRef,
12757 ) -> OSStatus;
12758}
12759extern "C" {
12760pub fn CMSEncoderCopyEncapsulatedContentType(
12762 cmsEncoder: CMSEncoderRef,
12763 eContentTypeOut: *mut CFDataRef,
12764 ) -> OSStatus;
12765}
12766extern "C" {
12767pub fn CMSEncoderAddSupportingCerts(
12769 cmsEncoder: CMSEncoderRef,
12770 certOrArray: CFTypeRef,
12771 ) -> OSStatus;
12772}
12773extern "C" {
12774pub fn CMSEncoderCopySupportingCerts(
12776 cmsEncoder: CMSEncoderRef,
12777 certsOut: *mut CFArrayRef,
12778 ) -> OSStatus;
12779}
12780pub type CMSSignedAttributes = u32;
12782pub const kCMSAttrNone: _bindgen_ty_1277 = 0;
12784pub const kCMSAttrSmimeCapabilities: _bindgen_ty_1277 = 1;
12786pub const kCMSAttrSmimeEncryptionKeyPrefs: _bindgen_ty_1277 = 2;
12788pub const kCMSAttrSmimeMSEncryptionKeyPrefs: _bindgen_ty_1277 = 4;
12790pub const kCMSAttrSigningTime: _bindgen_ty_1277 = 8;
12792pub const kCMSAttrAppleCodesigningHashAgility: _bindgen_ty_1277 = 16;
12794pub const kCMSAttrAppleCodesigningHashAgilityV2: _bindgen_ty_1277 = 32;
12796pub const kCMSAttrAppleExpirationTime: _bindgen_ty_1277 = 64;
12798pub type _bindgen_ty_1277 = ::core::ffi::c_uint;
12800extern "C" {
12801pub fn CMSEncoderAddSignedAttributes(
12803 cmsEncoder: CMSEncoderRef,
12804 signedAttributes: CMSSignedAttributes,
12805 ) -> OSStatus;
12806}
12807pub type CMSCertificateChainMode = u32;
12809pub const kCMSCertificateNone: _bindgen_ty_1278 = 0;
12811pub const kCMSCertificateSignerOnly: _bindgen_ty_1278 = 1;
12813pub const kCMSCertificateChain: _bindgen_ty_1278 = 2;
12815pub const kCMSCertificateChainWithRoot: _bindgen_ty_1278 = 3;
12817pub const kCMSCertificateChainWithRootOrFail: _bindgen_ty_1278 = 4;
12819pub type _bindgen_ty_1278 = ::core::ffi::c_uint;
12821extern "C" {
12822pub fn CMSEncoderSetCertificateChainMode(
12824 cmsEncoder: CMSEncoderRef,
12825 chainMode: CMSCertificateChainMode,
12826 ) -> OSStatus;
12827}
12828extern "C" {
12829pub fn CMSEncoderGetCertificateChainMode(
12831 cmsEncoder: CMSEncoderRef,
12832 chainModeOut: *mut CMSCertificateChainMode,
12833 ) -> OSStatus;
12834}
12835extern "C" {
12836pub fn CMSEncoderUpdateContent(
12838 cmsEncoder: CMSEncoderRef,
12839 content: *const ::core::ffi::c_void,
12840 contentLen: usize,
12841 ) -> OSStatus;
12842}
12843extern "C" {
12844pub fn CMSEncoderCopyEncodedContent(
12846 cmsEncoder: CMSEncoderRef,
12847 encodedContentOut: *mut CFDataRef,
12848 ) -> OSStatus;
12849}
12850extern "C" {
12851pub fn CMSEncode(
12853 signers: CFTypeRef,
12854 recipients: CFTypeRef,
12855 eContentType: *const SecAsn1Oid,
12856 detachedContent: Boolean,
12857 signedAttributes: CMSSignedAttributes,
12858 content: *const ::core::ffi::c_void,
12859 contentLen: usize,
12860 encodedContentOut: *mut CFDataRef,
12861 ) -> OSStatus;
12862}
12863extern "C" {
12864pub fn CMSEncodeContent(
12866 signers: CFTypeRef,
12867 recipients: CFTypeRef,
12868 eContentTypeOID: CFTypeRef,
12869 detachedContent: Boolean,
12870 signedAttributes: CMSSignedAttributes,
12871 content: *const ::core::ffi::c_void,
12872 contentLen: usize,
12873 encodedContentOut: *mut CFDataRef,
12874 ) -> OSStatus;
12875}
12876extern "C" {
12877pub fn CMSEncoderCopySignerTimestamp(
12879 cmsEncoder: CMSEncoderRef,
12880 signerIndex: usize,
12881 timestamp: *mut CFAbsoluteTime,
12882 ) -> OSStatus;
12883}
12884extern "C" {
12885pub fn CMSEncoderCopySignerTimestampWithPolicy(
12887 cmsEncoder: CMSEncoderRef,
12888 timeStampPolicy: CFTypeRef,
12889 signerIndex: usize,
12890 timestamp: *mut CFAbsoluteTime,
12891 ) -> OSStatus;
12892}
12893pub type ColorSyncMutableProfileRef = *mut ColorSyncProfile;
12895#[repr(C)]
12896#[derive(Debug, Copy, Clone)]
12897pub struct ColorSyncTransform {
12899 _unused: [u8; 0],
12900}
12901pub type ColorSyncTransformRef = *mut ColorSyncTransform;
12903pub const ColorSyncDataDepth_kColorSync1BitGamut: ColorSyncDataDepth = 1;
12905pub const ColorSyncDataDepth_kColorSync8BitInteger: ColorSyncDataDepth = 2;
12907pub const ColorSyncDataDepth_kColorSync16BitInteger: ColorSyncDataDepth = 3;
12909pub const ColorSyncDataDepth_kColorSync16BitFloat: ColorSyncDataDepth = 4;
12911pub const ColorSyncDataDepth_kColorSync32BitInteger: ColorSyncDataDepth = 5;
12913pub const ColorSyncDataDepth_kColorSync32BitNamedColorIndex: ColorSyncDataDepth = 6;
12915pub const ColorSyncDataDepth_kColorSync32BitFloat: ColorSyncDataDepth = 7;
12917pub const ColorSyncDataDepth_kColorSync10BitInteger: ColorSyncDataDepth = 8;
12919pub type ColorSyncDataDepth = ::core::ffi::c_uint;
12921pub type ColorSyncDataLayout = u32;
12923pub type CMMInitializeLinkProfileProc = ::core::option::Option<
12925 unsafe extern "C" fn(
12926 arg1: ColorSyncMutableProfileRef,
12927 profileInfo: CFArrayRef,
12928 options: CFDictionaryRef,
12929 ) -> bool,
12930>;
12931pub type CMMInitializeTransformProc = ::core::option::Option<
12933 unsafe extern "C" fn(
12934 arg1: ColorSyncTransformRef,
12935 profileInfo: CFArrayRef,
12936 options: CFDictionaryRef,
12937 ) -> bool,
12938>;
12939pub type CMMApplyTransformProc = ::core::option::Option<
12941 unsafe extern "C" fn(
12942 transform: ColorSyncTransformRef,
12943 width: usize,
12944 height: usize,
12945 dstPlanes: usize,
12946 dst: *mut *mut ::core::ffi::c_void,
12947 dstDepth: ColorSyncDataDepth,
12948 dstFormat: ColorSyncDataLayout,
12949 dstBytesPerRow: usize,
12950 srcPlanes: usize,
12951 src: *mut *const ::core::ffi::c_void,
12952 srcDepth: ColorSyncDataDepth,
12953 srcFormat: ColorSyncDataLayout,
12954 srcBytesPerRow: usize,
12955 options: CFDictionaryRef,
12956 ) -> bool,
12957>;
12958pub type CMMCreateTransformPropertyProc = ::core::option::Option<
12960 unsafe extern "C" fn(
12961 transform: ColorSyncTransformRef,
12962 key: CFTypeRef,
12963 options: CFDictionaryRef,
12964 ) -> CFTypeRef,
12965>;
12966extern "C" {
12967pub static mut kCMMInitializeLinkProfileProcName: CFStringRef;
12969}
12970extern "C" {
12971pub static mut kCMMInitializeTransformProcName: CFStringRef;
12973}
12974extern "C" {
12975pub static mut kCMMApplyTransformProcName: CFStringRef;
12977}
12978extern "C" {
12979pub static mut kCMMCreateTransformPropertyProcName: CFStringRef;
12981}
12982#[repr(C)]
12983#[derive(Debug, Copy, Clone)]
12984pub struct CMDateTime {
12986 pub year: UInt16,
12987 pub month: UInt16,
12988 pub dayOfTheMonth: UInt16,
12989 pub hours: UInt16,
12990 pub minutes: UInt16,
12991 pub seconds: UInt16,
12992}
12993#[repr(C, packed(2))]
12994#[derive(Debug, Copy, Clone)]
12995pub struct CMFixedXYColor {
12997 pub x: Fixed,
12998 pub y: Fixed,
12999}
13000#[repr(C, packed(2))]
13001#[derive(Debug, Copy, Clone)]
13002pub struct CMFixedXYZColor {
13004 pub X: Fixed,
13005 pub Y: Fixed,
13006 pub Z: Fixed,
13007}
13008pub type CMXYZComponent = UInt16;
13010#[repr(C)]
13011#[derive(Debug, Copy, Clone)]
13012pub struct CMXYZColor {
13014 pub X: CMXYZComponent,
13015 pub Y: CMXYZComponent,
13016 pub Z: CMXYZComponent,
13017}
13018pub type CMProfileMD5 = [::core::ffi::c_uchar; 16usize];
13020pub type CMProfileMD5Ptr = *mut CMProfileMD5;
13022#[repr(C, packed(2))]
13023#[derive(Debug, Copy, Clone)]
13024pub struct CM2Header {
13026 pub size: UInt32,
13027 pub CMMType: OSType,
13028 pub profileVersion: UInt32,
13029 pub profileClass: OSType,
13030 pub dataColorSpace: OSType,
13031 pub profileConnectionSpace: OSType,
13032 pub dateTime: CMDateTime,
13033 pub CS2profileSignature: OSType,
13034 pub platform: OSType,
13035 pub flags: UInt32,
13036 pub deviceManufacturer: OSType,
13037 pub deviceModel: UInt32,
13038 pub deviceAttributes: [UInt32; 2usize],
13039 pub renderingIntent: UInt32,
13040 pub white: CMFixedXYZColor,
13041 pub creator: OSType,
13042 pub reserved: [::core::ffi::c_char; 44usize],
13043}
13044#[repr(C, packed(2))]
13045#[derive(Debug, Copy, Clone)]
13046pub struct CM4Header {
13048 pub size: UInt32,
13049 pub CMMType: OSType,
13050 pub profileVersion: UInt32,
13051 pub profileClass: OSType,
13052 pub dataColorSpace: OSType,
13053 pub profileConnectionSpace: OSType,
13054 pub dateTime: CMDateTime,
13055 pub CS2profileSignature: OSType,
13056 pub platform: OSType,
13057 pub flags: UInt32,
13058 pub deviceManufacturer: OSType,
13059 pub deviceModel: UInt32,
13060 pub deviceAttributes: [UInt32; 2usize],
13061 pub renderingIntent: UInt32,
13062 pub white: CMFixedXYZColor,
13063 pub creator: OSType,
13064 pub digest: CMProfileMD5,
13065 pub reserved: [::core::ffi::c_char; 28usize],
13066}
13067#[repr(C, packed(2))]
13068#[derive(Debug, Copy, Clone)]
13069pub struct CMTagRecord {
13071 pub tag: OSType,
13072 pub elementOffset: UInt32,
13073 pub elementSize: UInt32,
13074}
13075#[repr(C, packed(2))]
13076#[derive(Debug, Copy, Clone)]
13077pub struct CMTagElemTable {
13079 pub count: UInt32,
13080 pub tagList: [CMTagRecord; 1usize],
13081}
13082#[repr(C)]
13083#[derive(Debug, Copy, Clone)]
13084pub struct CM2Profile {
13086 pub header: CM2Header,
13087 pub tagTable: CMTagElemTable,
13088 pub elemData: [::core::ffi::c_char; 1usize],
13089}
13090pub type CM2ProfilePtr = *mut CM2Profile;
13092pub type CM2ProfileHandle = *mut *mut CM2Profile;
13094#[repr(C, packed(2))]
13095#[derive(Debug, Copy, Clone)]
13096pub struct CMAdaptationMatrixType {
13098 pub typeDescriptor: OSType,
13099 pub reserved: UInt32,
13100 pub adaptationMatrix: [Fixed; 9usize],
13101}
13102#[repr(C, packed(2))]
13103#[derive(Debug, Copy, Clone)]
13104pub struct CMCurveType {
13106 pub typeDescriptor: OSType,
13107 pub reserved: UInt32,
13108 pub countValue: UInt32,
13109 pub data: [UInt16; 1usize],
13110}
13111#[repr(C, packed(2))]
13112#[derive(Debug, Copy, Clone)]
13113pub struct CMDataType {
13115 pub typeDescriptor: OSType,
13116 pub reserved: UInt32,
13117 pub dataFlag: UInt32,
13118 pub data: [::core::ffi::c_char; 1usize],
13119}
13120#[repr(C, packed(2))]
13121#[derive(Debug, Copy, Clone)]
13122pub struct CMDateTimeType {
13124 pub typeDescriptor: OSType,
13125 pub reserved: UInt32,
13126 pub dateTime: CMDateTime,
13127}
13128#[repr(C, packed(2))]
13129#[derive(Debug, Copy, Clone)]
13130pub struct CMLut16Type {
13132 pub typeDescriptor: OSType,
13133 pub reserved: UInt32,
13134 pub inputChannels: UInt8,
13135 pub outputChannels: UInt8,
13136 pub gridPoints: UInt8,
13137 pub reserved2: UInt8,
13138 pub matrix: [[Fixed; 3usize]; 3usize],
13139 pub inputTableEntries: UInt16,
13140 pub outputTableEntries: UInt16,
13141 pub inputTable: [UInt16; 1usize],
13142}
13143#[repr(C, packed(2))]
13144#[derive(Debug, Copy, Clone)]
13145pub struct CMLut8Type {
13147 pub typeDescriptor: OSType,
13148 pub reserved: UInt32,
13149 pub inputChannels: UInt8,
13150 pub outputChannels: UInt8,
13151 pub gridPoints: UInt8,
13152 pub reserved2: UInt8,
13153 pub matrix: [[Fixed; 3usize]; 3usize],
13154 pub inputTable: [UInt8; 1usize],
13155}
13156#[repr(C, packed(2))]
13157#[derive(Debug, Copy, Clone)]
13158pub struct CMMultiFunctLutType {
13160 pub typeDescriptor: OSType,
13161 pub reserved: UInt32,
13162 pub inputChannels: UInt8,
13163 pub outputChannels: UInt8,
13164 pub reserved2: UInt16,
13165 pub offsetBcurves: UInt32,
13166 pub offsetMatrix: UInt32,
13167 pub offsetMcurves: UInt32,
13168 pub offsetCLUT: UInt32,
13169 pub offsetAcurves: UInt32,
13170 pub data: [UInt8; 1usize],
13171}
13172pub type CMMultiFunctLutA2BType = CMMultiFunctLutType;
13174pub type CMMultiFunctLutB2AType = CMMultiFunctLutType;
13176#[repr(C)]
13177#[derive(Debug, Copy, Clone)]
13178pub struct CMMultiFunctCLUTType {
13180 pub gridPoints: [UInt8; 16usize],
13181 pub entrySize: UInt8,
13182 pub reserved: [UInt8; 3usize],
13183 pub data: [UInt8; 2usize],
13184}
13185#[repr(C, packed(2))]
13186#[derive(Debug, Copy, Clone)]
13187pub struct CMMeasurementType {
13189 pub typeDescriptor: OSType,
13190 pub reserved: UInt32,
13191 pub standardObserver: UInt32,
13192 pub backingXYZ: CMFixedXYZColor,
13193 pub geometry: UInt32,
13194 pub flare: UInt32,
13195 pub illuminant: UInt32,
13196}
13197#[repr(C, packed(2))]
13198#[derive(Debug, Copy, Clone)]
13199pub struct CMNamedColorType {
13201 pub typeDescriptor: OSType,
13202 pub reserved: UInt32,
13203 pub vendorFlag: UInt32,
13204 pub count: UInt32,
13205 pub prefixName: [UInt8; 1usize],
13206}
13207#[repr(C)]
13208#[derive(Debug, Copy, Clone)]
13209pub struct CMNamedColor2EntryType {
13211 pub rootName: [UInt8; 32usize],
13212 pub PCSColorCoords: [UInt16; 3usize],
13213 pub DeviceColorCoords: [UInt16; 1usize],
13214}
13215#[repr(C, packed(2))]
13216#[derive(Debug, Copy, Clone)]
13217pub struct CMNamedColor2Type {
13219 pub typeDescriptor: OSType,
13220 pub reserved: UInt32,
13221 pub vendorFlag: UInt32,
13222 pub count: UInt32,
13223 pub deviceChannelCount: UInt32,
13224 pub prefixName: [UInt8; 32usize],
13225 pub suffixName: [UInt8; 32usize],
13226 pub data: [::core::ffi::c_char; 1usize],
13227}
13228#[repr(C, packed(2))]
13229#[derive(Debug, Copy, Clone)]
13230pub struct CMNativeDisplayInfo {
13232 pub dataSize: UInt32,
13233 pub redPhosphor: CMFixedXYColor,
13234 pub greenPhosphor: CMFixedXYColor,
13235 pub bluePhosphor: CMFixedXYColor,
13236 pub whitePoint: CMFixedXYColor,
13237 pub redGammaValue: Fixed,
13238 pub greenGammaValue: Fixed,
13239 pub blueGammaValue: Fixed,
13240 pub gammaChannels: UInt16,
13241 pub gammaEntryCount: UInt16,
13242 pub gammaEntrySize: UInt16,
13243 pub gammaData: [::core::ffi::c_char; 1usize],
13244}
13245#[repr(C, packed(2))]
13246#[derive(Debug, Copy, Clone)]
13247pub struct CMNativeDisplayInfoType {
13249 pub typeDescriptor: OSType,
13250 pub reserved: UInt32,
13251 pub nativeDisplayInfo: CMNativeDisplayInfo,
13252}
13253#[repr(C, packed(2))]
13254#[derive(Debug, Copy, Clone)]
13255pub struct CMParametricCurveType {
13257 pub typeDescriptor: OSType,
13258 pub reserved: UInt32,
13259 pub functionType: UInt16,
13260 pub reserved2: UInt16,
13261 pub value: [Fixed; 1usize],
13262}
13263#[repr(C, packed(2))]
13264#[derive(Debug, Copy, Clone)]
13265pub struct CMTextDescriptionType {
13267 pub typeDescriptor: OSType,
13268 pub reserved: UInt32,
13269 pub ASCIICount: UInt32,
13270 pub ASCIIName: [UInt8; 2usize],
13271}
13272#[repr(C, packed(2))]
13273#[derive(Debug, Copy, Clone)]
13274pub struct CMTextType {
13276 pub typeDescriptor: OSType,
13277 pub reserved: UInt32,
13278 pub text: [UInt8; 1usize],
13279}
13280#[repr(C, packed(2))]
13281#[derive(Debug, Copy, Clone)]
13282pub struct CMUnicodeTextType {
13284 pub typeDescriptor: OSType,
13285 pub reserved: UInt32,
13286 pub text: [UniChar; 1usize],
13287}
13288#[repr(C, packed(2))]
13289#[derive(Debug, Copy, Clone)]
13290pub struct CMScreeningChannelRec {
13292 pub frequency: Fixed,
13293 pub angle: Fixed,
13294 pub spotFunction: UInt32,
13295}
13296#[repr(C, packed(2))]
13297#[derive(Debug, Copy, Clone)]
13298pub struct CMScreeningType {
13300 pub typeDescriptor: OSType,
13301 pub reserved: UInt32,
13302 pub screeningFlag: UInt32,
13303 pub channelCount: UInt32,
13304 pub channelInfo: [CMScreeningChannelRec; 1usize],
13305}
13306#[repr(C, packed(2))]
13307#[derive(Debug, Copy, Clone)]
13308pub struct CMSignatureType {
13310 pub typeDescriptor: OSType,
13311 pub reserved: UInt32,
13312 pub signature: OSType,
13313}
13314#[repr(C, packed(2))]
13315#[derive(Debug, Copy, Clone)]
13316pub struct CMS15Fixed16ArrayType {
13318 pub typeDescriptor: OSType,
13319 pub reserved: UInt32,
13320 pub value: [Fixed; 1usize],
13321}
13322#[repr(C, packed(2))]
13323#[derive(Debug, Copy, Clone)]
13324pub struct CMU16Fixed16ArrayType {
13326 pub typeDescriptor: OSType,
13327 pub reserved: UInt32,
13328 pub value: [UInt32; 1usize],
13329}
13330#[repr(C, packed(2))]
13331#[derive(Debug, Copy, Clone)]
13332pub struct CMUInt8ArrayType {
13334 pub typeDescriptor: OSType,
13335 pub reserved: UInt32,
13336 pub value: [UInt8; 1usize],
13337}
13338#[repr(C, packed(2))]
13339#[derive(Debug, Copy, Clone)]
13340pub struct CMUInt16ArrayType {
13342 pub typeDescriptor: OSType,
13343 pub reserved: UInt32,
13344 pub value: [UInt16; 1usize],
13345}
13346#[repr(C, packed(2))]
13347#[derive(Debug, Copy, Clone)]
13348pub struct CMUInt32ArrayType {
13350 pub typeDescriptor: OSType,
13351 pub reserved: UInt32,
13352 pub value: [UInt32; 1usize],
13353}
13354#[repr(C, packed(2))]
13355#[derive(Debug, Copy, Clone)]
13356pub struct CMUInt64ArrayType {
13358 pub typeDescriptor: OSType,
13359 pub reserved: UInt32,
13360 pub value: [UInt32; 1usize],
13361}
13362#[repr(C, packed(2))]
13363#[derive(Debug, Copy, Clone)]
13364pub struct CMViewingConditionsType {
13366 pub typeDescriptor: OSType,
13367 pub reserved: UInt32,
13368 pub illuminant: CMFixedXYZColor,
13369 pub surround: CMFixedXYZColor,
13370 pub stdIlluminant: UInt32,
13371}
13372#[repr(C, packed(2))]
13373#[derive(Debug, Copy, Clone)]
13374pub struct CMXYZType {
13376 pub typeDescriptor: OSType,
13377 pub reserved: UInt32,
13378 pub XYZ: [CMFixedXYZColor; 1usize],
13379}
13380#[repr(C, packed(2))]
13381#[derive(Debug, Copy, Clone)]
13382pub struct CMProfileSequenceDescType {
13384 pub typeDescriptor: OSType,
13385 pub reserved: UInt32,
13386 pub count: UInt32,
13387 pub data: [::core::ffi::c_char; 1usize],
13388}
13389#[repr(C, packed(2))]
13390#[derive(Debug, Copy, Clone)]
13391pub struct CMUcrBgType {
13393 pub typeDescriptor: OSType,
13394 pub reserved: UInt32,
13395 pub ucrCount: UInt32,
13396 pub ucrValues: [UInt16; 1usize],
13397}
13398#[repr(C, packed(2))]
13399#[derive(Debug, Copy, Clone)]
13400pub struct CMIntentCRDVMSize {
13402 pub renderingIntent: UInt32,
13403 pub VMSize: UInt32,
13404}
13405#[repr(C, packed(2))]
13406#[derive(Debug, Copy, Clone)]
13407pub struct CMPS2CRDVMSizeType {
13409 pub typeDescriptor: OSType,
13410 pub reserved: UInt32,
13411 pub count: UInt32,
13412 pub intentCRD: [CMIntentCRDVMSize; 1usize],
13413}
13414#[repr(C)]
13415#[derive(Debug, Copy, Clone)]
13416pub struct CMVideoCardGammaTable {
13418 pub channels: UInt16,
13419 pub entryCount: UInt16,
13420 pub entrySize: UInt16,
13421 pub data: [::core::ffi::c_char; 1usize],
13422}
13423#[repr(C, packed(2))]
13424#[derive(Debug, Copy, Clone)]
13425pub struct CMVideoCardGammaFormula {
13427 pub redGamma: Fixed,
13428 pub redMin: Fixed,
13429 pub redMax: Fixed,
13430 pub greenGamma: Fixed,
13431 pub greenMin: Fixed,
13432 pub greenMax: Fixed,
13433 pub blueGamma: Fixed,
13434 pub blueMin: Fixed,
13435 pub blueMax: Fixed,
13436}
13437#[repr(C, packed(2))]
13438#[derive(Copy, Clone)]
13439pub struct CMVideoCardGamma {
13441 pub tagType: UInt32,
13442 pub u: CMVideoCardGamma__bindgen_ty_1,
13443}
13444#[repr(C)]
13445#[derive(Copy, Clone)]
13446pub union CMVideoCardGamma__bindgen_ty_1 {
13447 pub table: CMVideoCardGammaTable,
13448 pub formula: CMVideoCardGammaFormula,
13449}
13450#[repr(C, packed(2))]
13451#[derive(Copy, Clone)]
13452pub struct CMVideoCardGammaType {
13454 pub typeDescriptor: OSType,
13455 pub reserved: UInt32,
13456 pub gamma: CMVideoCardGamma,
13457}
13458#[repr(C, packed(2))]
13459#[derive(Debug, Copy, Clone)]
13460pub struct CMMakeAndModel {
13462 pub manufacturer: OSType,
13463 pub model: UInt32,
13464 pub serialNumber: UInt32,
13465 pub manufactureDate: UInt32,
13466 pub reserved1: UInt32,
13467 pub reserved2: UInt32,
13468 pub reserved3: UInt32,
13469 pub reserved4: UInt32,
13470}
13471#[repr(C, packed(2))]
13472#[derive(Debug, Copy, Clone)]
13473pub struct CMMakeAndModelType {
13475 pub typeDescriptor: OSType,
13476 pub reserved: UInt32,
13477 pub makeAndModel: CMMakeAndModel,
13478}
13479#[repr(C, packed(2))]
13480#[derive(Debug, Copy, Clone)]
13481pub struct CMMultiLocalizedUniCodeEntryRec {
13483 pub languageCode: [::core::ffi::c_char; 2usize],
13484 pub regionCode: [::core::ffi::c_char; 2usize],
13485 pub textLength: UInt32,
13486 pub textOffset: UInt32,
13487}
13488#[repr(C, packed(2))]
13489#[derive(Debug, Copy, Clone)]
13490pub struct CMMultiLocalizedUniCodeType {
13492 pub typeDescriptor: OSType,
13493 pub reserved: UInt32,
13494 pub entryCount: UInt32,
13495 pub entrySize: UInt32,
13496}
13497#[repr(C)]
13498#[derive(Debug, Copy, Clone)]
13499pub struct OpaqueCMProfileRef {
13501 _unused: [u8; 0],
13502}
13503pub type CMProfileRef = *mut OpaqueCMProfileRef;
13505#[repr(C)]
13506#[derive(Debug, Copy, Clone)]
13507pub struct OpaqueCMWorldRef {
13509 _unused: [u8; 0],
13510}
13511pub type CMWorldRef = *mut OpaqueCMWorldRef;
13513pub type CMDisplayIDType = UInt32;
13515pub type CMChromaticAdaptation = UInt32;
13517pub type CMFlattenProcPtr = ::core::option::Option<
13519 unsafe extern "C" fn(
13520 command: SInt32,
13521 size: *mut ::core::ffi::c_long,
13522 data: *mut ::core::ffi::c_void,
13523 refCon: *mut ::core::ffi::c_void,
13524 ) -> OSErr,
13525>;
13526pub type CMFlattenUPP = CMFlattenProcPtr;
13528pub type CMBitmapCallBackProcPtr = ::core::option::Option<
13530 unsafe extern "C" fn(progress: SInt32, refCon: *mut ::core::ffi::c_void) -> Boolean,
13531>;
13532pub type CMBitmapCallBackUPP = CMBitmapCallBackProcPtr;
13534pub type CMConcatCallBackProcPtr = ::core::option::Option<
13536 unsafe extern "C" fn(progress: SInt32, refCon: *mut ::core::ffi::c_void) -> Boolean,
13537>;
13538pub type CMConcatCallBackUPP = CMConcatCallBackProcPtr;
13540#[repr(C)]
13541#[derive(Copy, Clone)]
13542pub union CMAppleProfileHeader {
13543 pub cm2: CM2Header,
13544 pub cm4: CM4Header,
13545}
13546#[repr(C)]
13547#[derive(Debug, Copy, Clone)]
13548pub struct CMConcatProfileSet {
13550 pub keyIndex: UInt16,
13551 pub count: UInt16,
13552 pub profileSet: [CMProfileRef; 1usize],
13553}
13554#[repr(C)]
13555#[derive(Debug, Copy, Clone)]
13556pub struct CMRGBColor {
13558 pub red: UInt16,
13559 pub green: UInt16,
13560 pub blue: UInt16,
13561}
13562#[repr(C)]
13563#[derive(Debug, Copy, Clone)]
13564pub struct CMCMYKColor {
13566 pub cyan: UInt16,
13567 pub magenta: UInt16,
13568 pub yellow: UInt16,
13569 pub black: UInt16,
13570}
13571#[repr(C)]
13572#[derive(Debug, Copy, Clone)]
13573pub struct CMCMYColor {
13575 pub cyan: UInt16,
13576 pub magenta: UInt16,
13577 pub yellow: UInt16,
13578}
13579#[repr(C)]
13580#[derive(Debug, Copy, Clone)]
13581pub struct CMHLSColor {
13583 pub hue: UInt16,
13584 pub lightness: UInt16,
13585 pub saturation: UInt16,
13586}
13587#[repr(C)]
13588#[derive(Debug, Copy, Clone)]
13589pub struct CMHSVColor {
13591 pub hue: UInt16,
13592 pub saturation: UInt16,
13593 pub value: UInt16,
13594}
13595#[repr(C)]
13596#[derive(Debug, Copy, Clone)]
13597pub struct CMLabColor {
13599 pub L: UInt16,
13600 pub a: UInt16,
13601 pub b: UInt16,
13602}
13603#[repr(C)]
13604#[derive(Debug, Copy, Clone)]
13605pub struct CMLuvColor {
13607 pub L: UInt16,
13608 pub u: UInt16,
13609 pub v: UInt16,
13610}
13611#[repr(C)]
13612#[derive(Debug, Copy, Clone)]
13613pub struct CMYxyColor {
13615 pub capY: UInt16,
13616 pub x: UInt16,
13617 pub y: UInt16,
13618}
13619#[repr(C)]
13620#[derive(Debug, Copy, Clone)]
13621pub struct CMGrayColor {
13623 pub gray: UInt16,
13624}
13625#[repr(C)]
13626#[derive(Debug, Copy, Clone)]
13627pub struct CMMultichannel5Color {
13629 pub components: [UInt8; 5usize],
13630}
13631#[repr(C)]
13632#[derive(Debug, Copy, Clone)]
13633pub struct CMMultichannel6Color {
13635 pub components: [UInt8; 6usize],
13636}
13637#[repr(C)]
13638#[derive(Debug, Copy, Clone)]
13639pub struct CMMultichannel7Color {
13641 pub components: [UInt8; 7usize],
13642}
13643#[repr(C)]
13644#[derive(Debug, Copy, Clone)]
13645pub struct CMMultichannel8Color {
13647 pub components: [UInt8; 8usize],
13648}
13649#[repr(C)]
13650#[derive(Debug, Copy, Clone)]
13651pub struct CMNamedColor {
13653 pub namedColorIndex: UInt32,
13654}
13655#[repr(C)]
13656#[derive(Copy, Clone)]
13657pub union CMColor {
13658 pub rgb: CMRGBColor,
13659 pub hsv: CMHSVColor,
13660 pub hls: CMHLSColor,
13661 pub XYZ: CMXYZColor,
13662 pub Lab: CMLabColor,
13663 pub Luv: CMLuvColor,
13664 pub Yxy: CMYxyColor,
13665 pub cmyk: CMCMYKColor,
13666 pub cmy: CMCMYColor,
13667 pub gray: CMGrayColor,
13668 pub mc5: CMMultichannel5Color,
13669 pub mc6: CMMultichannel6Color,
13670 pub mc7: CMMultichannel7Color,
13671 pub mc8: CMMultichannel8Color,
13672 pub namedColor: CMNamedColor,
13673}
13674#[repr(C)]
13675#[derive(Debug, Copy, Clone)]
13676pub struct CMMInfo {
13678 pub dataSize: usize,
13679 pub CMMType: OSType,
13680 pub CMMMfr: OSType,
13681 pub CMMVersion: UInt32,
13682 pub ASCIIName: [::core::ffi::c_uchar; 32usize],
13683 pub ASCIIDesc: [::core::ffi::c_uchar; 256usize],
13684 pub UniCodeNameCount: UniCharCount,
13685 pub UniCodeName: [UniChar; 32usize],
13686 pub UniCodeDescCount: UniCharCount,
13687 pub UniCodeDesc: [UniChar; 256usize],
13688}
13689pub type CMBitmapColorSpace = UInt32;
13691#[repr(C)]
13692#[derive(Debug, Copy, Clone)]
13693pub struct CMBitmap {
13695 pub image: *mut ::core::ffi::c_char,
13696 pub width: usize,
13697 pub height: usize,
13698 pub rowBytes: usize,
13699 pub pixelSize: usize,
13700 pub space: CMBitmapColorSpace,
13701 pub user1: UInt32,
13702 pub user2: UInt32,
13703}
13704#[repr(C)]
13705#[derive(Debug, Copy, Clone)]
13706pub struct CMHandleLocation {
13708 pub h: Handle,
13709}
13710#[repr(C)]
13711#[derive(Debug, Copy, Clone)]
13712pub struct CMPathLocation {
13714 pub path: [::core::ffi::c_char; 1024usize],
13715}
13716#[repr(C)]
13717#[derive(Debug, Copy, Clone)]
13718pub struct CMBufferLocation {
13720 pub buffer: *mut ::core::ffi::c_void,
13721 pub size: UInt32,
13722}
13723#[repr(C)]
13724#[derive(Copy, Clone)]
13725pub union CMProfLoc {
13726 pub handleLoc: CMHandleLocation,
13727 pub pathLoc: CMPathLocation,
13728 pub bufferLoc: CMBufferLocation,
13729}
13730#[repr(C)]
13731#[derive(Copy, Clone)]
13732pub struct CMProfileLocation {
13734 pub locType: ::core::ffi::c_short,
13735 pub u: CMProfLoc,
13736}
13737#[repr(C)]
13738#[derive(Copy, Clone)]
13739pub struct CMProfileIterateData {
13741 pub dataVersion: UInt32,
13742 pub header: CM2Header,
13743 pub code: ScriptCode,
13744 pub name: Str255,
13745 pub location: CMProfileLocation,
13746 pub uniCodeNameCount: UniCharCount,
13747 pub uniCodeName: *mut UniChar,
13748 pub asciiName: *mut ::core::ffi::c_uchar,
13749 pub makeAndModel: *mut CMMakeAndModel,
13750 pub digest: *mut CMProfileMD5,
13751}
13752pub type CMProfileIterateProcPtr = ::core::option::Option<
13754 unsafe extern "C" fn(
13755 iterateData: *mut CMProfileIterateData,
13756 refCon: *mut ::core::ffi::c_void,
13757 ) -> OSErr,
13758>;
13759pub type CMProfileIterateUPP = CMProfileIterateProcPtr;
13761pub type CMMIterateProcPtr = ::core::option::Option<
13763 unsafe extern "C" fn(iterateData: *mut CMMInfo, refCon: *mut ::core::ffi::c_void) -> OSErr,
13764>;
13765pub type CMMIterateUPP = CMMIterateProcPtr;
13767pub type CMLabToLabProcPtr = ::core::option::Option<
13769 unsafe extern "C" fn(L: *mut f32, a: *mut f32, b: *mut f32, refcon: *mut ::core::ffi::c_void),
13770>;
13771pub const CMFloatBitmapFlags_kCMFloatBitmapFlagsNone: CMFloatBitmapFlags = 0;
13773pub const CMFloatBitmapFlags_kCMFloatBitmapFlagsAlpha: CMFloatBitmapFlags = 1;
13775pub const CMFloatBitmapFlags_kCMFloatBitmapFlagsAlphaPremul: CMFloatBitmapFlags = 2;
13777pub const CMFloatBitmapFlags_kCMFloatBitmapFlagsRangeClipped: CMFloatBitmapFlags = 4;
13779pub type CMFloatBitmapFlags = ::core::ffi::c_uint;
13781#[repr(C)]
13782#[derive(Debug, Copy, Clone)]
13783pub struct CMFloatBitmap {
13785 pub version: ::core::ffi::c_ulong,
13786 pub buffers: [*mut f32; 16usize],
13787 pub height: usize,
13788 pub width: usize,
13789 pub rowStride: isize,
13790 pub colStride: isize,
13791 pub space: OSType,
13792 pub flags: CMFloatBitmapFlags,
13793}
13794pub type CMDeviceState = UInt32;
13796pub type CMDeviceID = UInt32;
13798pub type CMDeviceProfileID = UInt32;
13800pub type CMDeviceClass = OSType;
13802#[repr(C)]
13803#[derive(Debug, Copy, Clone)]
13804pub struct CMDeviceScope {
13806 pub deviceUser: CFStringRef,
13807 pub deviceHost: CFStringRef,
13808}
13809pub type CMDeviceProfileScope = CMDeviceScope;
13811#[repr(C)]
13812#[derive(Debug, Copy, Clone)]
13813pub struct CMDeviceInfo {
13815 pub dataVersion: UInt32,
13816 pub deviceClass: CMDeviceClass,
13817 pub deviceID: CMDeviceID,
13818 pub deviceScope: CMDeviceScope,
13819 pub deviceState: CMDeviceState,
13820 pub defaultProfileID: CMDeviceProfileID,
13821 pub deviceName: *mut CFDictionaryRef,
13822 pub profileCount: UInt32,
13823 pub reserved: UInt32,
13824}
13825pub type CMDeviceInfoPtr = *mut CMDeviceInfo;
13827#[repr(C)]
13828#[derive(Copy, Clone)]
13829pub struct CMDeviceProfileInfo {
13831 pub dataVersion: UInt32,
13832 pub profileID: CMDeviceProfileID,
13833 pub profileLoc: CMProfileLocation,
13834 pub profileName: CFDictionaryRef,
13835 pub reserved: UInt32,
13836}
13837#[repr(C)]
13838#[derive(Copy, Clone)]
13839pub struct NCMDeviceProfileInfo {
13841 pub dataVersion: UInt32,
13842 pub profileID: CMDeviceProfileID,
13843 pub profileLoc: CMProfileLocation,
13844 pub profileName: CFDictionaryRef,
13845 pub profileScope: CMDeviceProfileScope,
13846 pub reserved: UInt32,
13847}
13848#[repr(C)]
13849#[derive(Copy, Clone)]
13850pub struct CMDeviceProfileArray {
13852 pub profileCount: UInt32,
13853 pub profiles: [CMDeviceProfileInfo; 1usize],
13854}
13855pub type CMDeviceProfileArrayPtr = *mut CMDeviceProfileArray;
13857pub type CMIterateDeviceInfoProcPtr = ::core::option::Option<
13859 unsafe extern "C" fn(
13860 deviceInfo: *const CMDeviceInfo,
13861 refCon: *mut ::core::ffi::c_void,
13862 ) -> OSErr,
13863>;
13864pub type CMIterateDeviceProfileProcPtr = ::core::option::Option<
13866 unsafe extern "C" fn(
13867 deviceInfo: *const CMDeviceInfo,
13868 profileInfo: *const NCMDeviceProfileInfo,
13869 refCon: *mut ::core::ffi::c_void,
13870 ) -> OSErr,
13871>;
13872extern "C" {
13873pub static mut kCFErrorDomainCGImageMetadata: CFStringRef;
13875}
13876extern "C" {
13877pub static mut kCVImageBufferCGColorSpaceKey: CFStringRef;
13879}
13880extern "C" {
13881pub static mut kCVImageBufferCleanApertureKey: CFStringRef;
13883}
13884extern "C" {
13885pub static mut kCVImageBufferCleanApertureWidthKey: CFStringRef;
13887}
13888extern "C" {
13889pub static mut kCVImageBufferCleanApertureHeightKey: CFStringRef;
13891}
13892extern "C" {
13893pub static mut kCVImageBufferCleanApertureHorizontalOffsetKey: CFStringRef;
13895}
13896extern "C" {
13897pub static mut kCVImageBufferCleanApertureVerticalOffsetKey: CFStringRef;
13899}
13900extern "C" {
13901pub static mut kCVImageBufferPreferredCleanApertureKey: CFStringRef;
13903}
13904extern "C" {
13905pub static mut kCVImageBufferFieldCountKey: CFStringRef;
13907}
13908extern "C" {
13909pub static mut kCVImageBufferFieldDetailKey: CFStringRef;
13911}
13912extern "C" {
13913pub static mut kCVImageBufferFieldDetailTemporalTopFirst: CFStringRef;
13915}
13916extern "C" {
13917pub static mut kCVImageBufferFieldDetailTemporalBottomFirst: CFStringRef;
13919}
13920extern "C" {
13921pub static mut kCVImageBufferFieldDetailSpatialFirstLineEarly: CFStringRef;
13923}
13924extern "C" {
13925pub static mut kCVImageBufferFieldDetailSpatialFirstLineLate: CFStringRef;
13927}
13928extern "C" {
13929pub static mut kCVImageBufferPixelAspectRatioKey: CFStringRef;
13931}
13932extern "C" {
13933pub static mut kCVImageBufferPixelAspectRatioHorizontalSpacingKey: CFStringRef;
13935}
13936extern "C" {
13937pub static mut kCVImageBufferPixelAspectRatioVerticalSpacingKey: CFStringRef;
13939}
13940extern "C" {
13941pub static mut kCVImageBufferDisplayDimensionsKey: CFStringRef;
13943}
13944extern "C" {
13945pub static mut kCVImageBufferDisplayWidthKey: CFStringRef;
13947}
13948extern "C" {
13949pub static mut kCVImageBufferDisplayHeightKey: CFStringRef;
13951}
13952extern "C" {
13953pub static mut kCVImageBufferGammaLevelKey: CFStringRef;
13955}
13956extern "C" {
13957pub static mut kCVImageBufferICCProfileKey: CFStringRef;
13959}
13960extern "C" {
13961pub static mut kCVImageBufferYCbCrMatrixKey: CFStringRef;
13963}
13964extern "C" {
13965pub static mut kCVImageBufferYCbCrMatrix_ITU_R_709_2: CFStringRef;
13967}
13968extern "C" {
13969pub static mut kCVImageBufferYCbCrMatrix_ITU_R_601_4: CFStringRef;
13971}
13972extern "C" {
13973pub static mut kCVImageBufferYCbCrMatrix_SMPTE_240M_1995: CFStringRef;
13975}
13976extern "C" {
13977pub static mut kCVImageBufferYCbCrMatrix_DCI_P3: CFStringRef;
13979}
13980extern "C" {
13981pub static mut kCVImageBufferYCbCrMatrix_P3_D65: CFStringRef;
13983}
13984extern "C" {
13985pub static mut kCVImageBufferYCbCrMatrix_ITU_R_2020: CFStringRef;
13987}
13988extern "C" {
13989pub static mut kCVImageBufferColorPrimariesKey: CFStringRef;
13991}
13992extern "C" {
13993pub static mut kCVImageBufferColorPrimaries_ITU_R_709_2: CFStringRef;
13995}
13996extern "C" {
13997pub static mut kCVImageBufferColorPrimaries_EBU_3213: CFStringRef;
13999}
14000extern "C" {
14001pub static mut kCVImageBufferColorPrimaries_SMPTE_C: CFStringRef;
14003}
14004extern "C" {
14005pub static mut kCVImageBufferColorPrimaries_P22: CFStringRef;
14007}
14008extern "C" {
14009pub static mut kCVImageBufferColorPrimaries_DCI_P3: CFStringRef;
14011}
14012extern "C" {
14013pub static mut kCVImageBufferColorPrimaries_P3_D65: CFStringRef;
14015}
14016extern "C" {
14017pub static mut kCVImageBufferColorPrimaries_ITU_R_2020: CFStringRef;
14019}
14020extern "C" {
14021pub static mut kCVImageBufferTransferFunctionKey: CFStringRef;
14023}
14024extern "C" {
14025pub static mut kCVImageBufferTransferFunction_ITU_R_709_2: CFStringRef;
14027}
14028extern "C" {
14029pub static mut kCVImageBufferTransferFunction_SMPTE_240M_1995: CFStringRef;
14031}
14032extern "C" {
14033pub static mut kCVImageBufferTransferFunction_UseGamma: CFStringRef;
14035}
14036extern "C" {
14037pub static mut kCVImageBufferTransferFunction_EBU_3213: CFStringRef;
14039}
14040extern "C" {
14041pub static mut kCVImageBufferTransferFunction_SMPTE_C: CFStringRef;
14043}
14044extern "C" {
14045pub static mut kCVImageBufferTransferFunction_sRGB: CFStringRef;
14047}
14048extern "C" {
14049pub static mut kCVImageBufferTransferFunction_ITU_R_2020: CFStringRef;
14051}
14052extern "C" {
14053pub static mut kCVImageBufferTransferFunction_SMPTE_ST_428_1: CFStringRef;
14055}
14056extern "C" {
14057pub static mut kCVImageBufferTransferFunction_SMPTE_ST_2084_PQ: CFStringRef;
14059}
14060extern "C" {
14061pub static mut kCVImageBufferTransferFunction_ITU_R_2100_HLG: CFStringRef;
14063}
14064extern "C" {
14065pub static mut kCVImageBufferTransferFunction_Linear: CFStringRef;
14067}
14068extern "C" {
14069pub static mut kCVImageBufferChromaLocationTopFieldKey: CFStringRef;
14071}
14072extern "C" {
14073pub static mut kCVImageBufferChromaLocationBottomFieldKey: CFStringRef;
14075}
14076extern "C" {
14077pub static mut kCVImageBufferChromaLocation_Left: CFStringRef;
14079}
14080extern "C" {
14081pub static mut kCVImageBufferChromaLocation_Center: CFStringRef;
14083}
14084extern "C" {
14085pub static mut kCVImageBufferChromaLocation_TopLeft: CFStringRef;
14087}
14088extern "C" {
14089pub static mut kCVImageBufferChromaLocation_Top: CFStringRef;
14091}
14092extern "C" {
14093pub static mut kCVImageBufferChromaLocation_BottomLeft: CFStringRef;
14095}
14096extern "C" {
14097pub static mut kCVImageBufferChromaLocation_Bottom: CFStringRef;
14099}
14100extern "C" {
14101pub static mut kCVImageBufferChromaLocation_DV420: CFStringRef;
14103}
14104extern "C" {
14105pub static mut kCVImageBufferChromaSubsamplingKey: CFStringRef;
14107}
14108extern "C" {
14109pub static mut kCVImageBufferChromaSubsampling_420: CFStringRef;
14111}
14112extern "C" {
14113pub static mut kCVImageBufferChromaSubsampling_422: CFStringRef;
14115}
14116extern "C" {
14117pub static mut kCVImageBufferChromaSubsampling_411: CFStringRef;
14119}
14120extern "C" {
14121pub static mut kCVImageBufferAlphaChannelIsOpaque: CFStringRef;
14123}
14124extern "C" {
14125pub static mut kCVImageBufferAlphaChannelModeKey: CFStringRef;
14127}
14128extern "C" {
14129pub static mut kCVImageBufferAlphaChannelMode_StraightAlpha: CFStringRef;
14131}
14132extern "C" {
14133pub static mut kCVImageBufferAlphaChannelMode_PremultipliedAlpha: CFStringRef;
14135}
14136extern "C" {
14137pub static mut kCVImageBufferPostDecodeProcessingSequenceMetadataKey: CFStringRef;
14139}
14140extern "C" {
14141pub static mut kCVImageBufferPostDecodeProcessingFrameMetadataKey: CFStringRef;
14143}
14144extern "C" {
14145pub fn CVYCbCrMatrixGetIntegerCodePointForString(
14147 yCbCrMatrixString: CFStringRef,
14148 ) -> ::core::ffi::c_int;
14149}
14150extern "C" {
14151pub fn CVColorPrimariesGetIntegerCodePointForString(
14153 colorPrimariesString: CFStringRef,
14154 ) -> ::core::ffi::c_int;
14155}
14156extern "C" {
14157pub fn CVTransferFunctionGetIntegerCodePointForString(
14159 transferFunctionString: CFStringRef,
14160 ) -> ::core::ffi::c_int;
14161}
14162extern "C" {
14163pub fn CVYCbCrMatrixGetStringForIntegerCodePoint(
14165 yCbCrMatrixCodePoint: ::core::ffi::c_int,
14166 ) -> CFStringRef;
14167}
14168extern "C" {
14169pub fn CVColorPrimariesGetStringForIntegerCodePoint(
14171 colorPrimariesCodePoint: ::core::ffi::c_int,
14172 ) -> CFStringRef;
14173}
14174extern "C" {
14175pub fn CVTransferFunctionGetStringForIntegerCodePoint(
14177 transferFunctionCodePoint: ::core::ffi::c_int,
14178 ) -> CFStringRef;
14179}
14180pub type CVImageBufferRef = CVBufferRef;
14182extern "C" {
14183pub fn CVImageBufferGetEncodedSize(imageBuffer: CVImageBufferRef) -> CGSize;
14185}
14186extern "C" {
14187pub fn CVImageBufferGetDisplaySize(imageBuffer: CVImageBufferRef) -> CGSize;
14189}
14190extern "C" {
14191pub fn CVImageBufferGetCleanRect(imageBuffer: CVImageBufferRef) -> CGRect;
14193}
14194extern "C" {
14195pub fn CVImageBufferIsFlipped(imageBuffer: CVImageBufferRef) -> Boolean;
14197}
14198extern "C" {
14199pub fn CVImageBufferGetColorSpace(imageBuffer: CVImageBufferRef) -> CGColorSpaceRef;
14201}
14202extern "C" {
14203pub fn CVImageBufferCreateColorSpaceFromAttachments(
14205 attachments: CFDictionaryRef,
14206 ) -> CGColorSpaceRef;
14207}
14208extern "C" {
14209pub static mut kCVImageBufferMasteringDisplayColorVolumeKey: CFStringRef;
14211}
14212extern "C" {
14213pub static mut kCVImageBufferContentLightLevelInfoKey: CFStringRef;
14215}
14216extern "C" {
14217pub static mut kCVImageBufferAmbientViewingEnvironmentKey: CFStringRef;
14219}
14220extern "C" {
14221pub static mut kCVImageBufferSceneIlluminationKey: CFStringRef;
14223}
14224extern "C" {
14225pub static mut kCVImageBufferRegionOfInterestKey: CFStringRef;
14227}
14228extern "C" {
14229pub static mut kCVImageBufferLogTransferFunctionKey: CFStringRef;
14231}
14232extern "C" {
14233pub static mut kCVImageBufferLogTransferFunction_AppleLog: CFStringRef;
14235}
14236extern "C" {
14237pub static mut kCVImageBufferLogTransferFunction_AppleLog2: CFStringRef;
14239}
14240extern "C" {
14241pub static mut kCVImageBufferDisplayMaskRectangleKey: CFStringRef;
14243}
14244extern "C" {
14245pub static mut kCVImageBufferDisplayMaskRectangle_ReferenceRasterWidthKey: CFStringRef;
14247}
14248extern "C" {
14249pub static mut kCVImageBufferDisplayMaskRectangle_ReferenceRasterHeightKey: CFStringRef;
14251}
14252extern "C" {
14253pub static mut kCVImageBufferDisplayMaskRectangle_RectangleLeftKey: CFStringRef;
14255}
14256extern "C" {
14257pub static mut kCVImageBufferDisplayMaskRectangle_RectangleWidthKey: CFStringRef;
14259}
14260extern "C" {
14261pub static mut kCVImageBufferDisplayMaskRectangle_RectangleTopKey: CFStringRef;
14263}
14264extern "C" {
14265pub static mut kCVImageBufferDisplayMaskRectangle_RectangleHeightKey: CFStringRef;
14267}
14268extern "C" {
14269pub static mut kCVImageBufferDisplayMaskRectangleStereoLeftKey: CFStringRef;
14271}
14272extern "C" {
14273pub static mut kCVImageBufferDisplayMaskRectangleStereoRightKey: CFStringRef;
14275}
14276extern "C" {
14277pub static mut kCVImageBufferDisplayMaskRectangle_LeftEdgePointsKey: CFStringRef;
14279}
14280extern "C" {
14281pub static mut kCVImageBufferDisplayMaskRectangle_RightEdgePointsKey: CFStringRef;
14283}
14284pub const kCVPixelFormatType_1Monochrome: _bindgen_ty_1661 = 1;
14286pub const kCVPixelFormatType_2Indexed: _bindgen_ty_1661 = 2;
14288pub const kCVPixelFormatType_4Indexed: _bindgen_ty_1661 = 4;
14290pub const kCVPixelFormatType_8Indexed: _bindgen_ty_1661 = 8;
14292pub const kCVPixelFormatType_1IndexedGray_WhiteIsZero: _bindgen_ty_1661 = 33;
14294pub const kCVPixelFormatType_2IndexedGray_WhiteIsZero: _bindgen_ty_1661 = 34;
14296pub const kCVPixelFormatType_4IndexedGray_WhiteIsZero: _bindgen_ty_1661 = 36;
14298pub const kCVPixelFormatType_8IndexedGray_WhiteIsZero: _bindgen_ty_1661 = 40;
14300pub const kCVPixelFormatType_16BE555: _bindgen_ty_1661 = 16;
14302pub const kCVPixelFormatType_16LE555: _bindgen_ty_1661 = 1278555445;
14304pub const kCVPixelFormatType_16LE5551: _bindgen_ty_1661 = 892679473;
14306pub const kCVPixelFormatType_16BE565: _bindgen_ty_1661 = 1110783541;
14308pub const kCVPixelFormatType_16LE565: _bindgen_ty_1661 = 1278555701;
14310pub const kCVPixelFormatType_24RGB: _bindgen_ty_1661 = 24;
14312pub const kCVPixelFormatType_24BGR: _bindgen_ty_1661 = 842285639;
14314pub const kCVPixelFormatType_32ARGB: _bindgen_ty_1661 = 32;
14316pub const kCVPixelFormatType_32BGRA: _bindgen_ty_1661 = 1111970369;
14318pub const kCVPixelFormatType_32ABGR: _bindgen_ty_1661 = 1094862674;
14320pub const kCVPixelFormatType_32RGBA: _bindgen_ty_1661 = 1380401729;
14322pub const kCVPixelFormatType_64ARGB: _bindgen_ty_1661 = 1647719521;
14324pub const kCVPixelFormatType_64RGBALE: _bindgen_ty_1661 = 1815491698;
14326pub const kCVPixelFormatType_48RGB: _bindgen_ty_1661 = 1647589490;
14328pub const kCVPixelFormatType_32AlphaGray: _bindgen_ty_1661 = 1647522401;
14330pub const kCVPixelFormatType_16Gray: _bindgen_ty_1661 = 1647392359;
14332pub const kCVPixelFormatType_30RGB: _bindgen_ty_1661 = 1378955371;
14334pub const kCVPixelFormatType_30RGB_r210: _bindgen_ty_1661 = 1915892016;
14336pub const kCVPixelFormatType_422YpCbCr8: _bindgen_ty_1661 = 846624121;
14338pub const kCVPixelFormatType_4444YpCbCrA8: _bindgen_ty_1661 = 1983131704;
14340pub const kCVPixelFormatType_4444YpCbCrA8R: _bindgen_ty_1661 = 1916022840;
14342pub const kCVPixelFormatType_4444AYpCbCr8: _bindgen_ty_1661 = 2033463352;
14344pub const kCVPixelFormatType_4444AYpCbCr16: _bindgen_ty_1661 = 2033463606;
14346pub const kCVPixelFormatType_4444AYpCbCrFloat: _bindgen_ty_1661 = 1916036716;
14348pub const kCVPixelFormatType_444YpCbCr8: _bindgen_ty_1661 = 1983066168;
14350pub const kCVPixelFormatType_422YpCbCr16: _bindgen_ty_1661 = 1983000886;
14352pub const kCVPixelFormatType_422YpCbCr10: _bindgen_ty_1661 = 1983000880;
14354pub const kCVPixelFormatType_444YpCbCr10: _bindgen_ty_1661 = 1983131952;
14356pub const kCVPixelFormatType_420YpCbCr8Planar: _bindgen_ty_1661 = 2033463856;
14358pub const kCVPixelFormatType_420YpCbCr8PlanarFullRange: _bindgen_ty_1661 = 1714696752;
14360pub const kCVPixelFormatType_422YpCbCr_4A_8BiPlanar: _bindgen_ty_1661 = 1630697081;
14362pub const kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange: _bindgen_ty_1661 = 875704438;
14364pub const kCVPixelFormatType_420YpCbCr8BiPlanarFullRange: _bindgen_ty_1661 = 875704422;
14366pub const kCVPixelFormatType_422YpCbCr8BiPlanarVideoRange: _bindgen_ty_1661 = 875704950;
14368pub const kCVPixelFormatType_422YpCbCr8BiPlanarFullRange: _bindgen_ty_1661 = 875704934;
14370pub const kCVPixelFormatType_444YpCbCr8BiPlanarVideoRange: _bindgen_ty_1661 = 875836534;
14372pub const kCVPixelFormatType_444YpCbCr8BiPlanarFullRange: _bindgen_ty_1661 = 875836518;
14374pub const kCVPixelFormatType_422YpCbCr8_yuvs: _bindgen_ty_1661 = 2037741171;
14376pub const kCVPixelFormatType_422YpCbCr8FullRange: _bindgen_ty_1661 = 2037741158;
14378pub const kCVPixelFormatType_OneComponent8: _bindgen_ty_1661 = 1278226488;
14380pub const kCVPixelFormatType_TwoComponent8: _bindgen_ty_1661 = 843264056;
14382pub const kCVPixelFormatType_30RGBLEPackedWideGamut: _bindgen_ty_1661 = 1999843442;
14384pub const kCVPixelFormatType_ARGB2101010LEPacked: _bindgen_ty_1661 = 1815162994;
14386pub const kCVPixelFormatType_40ARGBLEWideGamut: _bindgen_ty_1661 = 1999908961;
14388pub const kCVPixelFormatType_40ARGBLEWideGamutPremultiplied: _bindgen_ty_1661 = 1999908973;
14390pub const kCVPixelFormatType_OneComponent10: _bindgen_ty_1661 = 1278226736;
14392pub const kCVPixelFormatType_OneComponent12: _bindgen_ty_1661 = 1278226738;
14394pub const kCVPixelFormatType_OneComponent16: _bindgen_ty_1661 = 1278226742;
14396pub const kCVPixelFormatType_TwoComponent16: _bindgen_ty_1661 = 843264310;
14398pub const kCVPixelFormatType_OneComponent16Half: _bindgen_ty_1661 = 1278226536;
14400pub const kCVPixelFormatType_OneComponent32Float: _bindgen_ty_1661 = 1278226534;
14402pub const kCVPixelFormatType_TwoComponent16Half: _bindgen_ty_1661 = 843264104;
14404pub const kCVPixelFormatType_TwoComponent32Float: _bindgen_ty_1661 = 843264102;
14406pub const kCVPixelFormatType_64RGBAHalf: _bindgen_ty_1661 = 1380411457;
14408pub const kCVPixelFormatType_128RGBAFloat: _bindgen_ty_1661 = 1380410945;
14410pub const kCVPixelFormatType_14Bayer_GRBG: _bindgen_ty_1661 = 1735549492;
14412pub const kCVPixelFormatType_14Bayer_RGGB: _bindgen_ty_1661 = 1919379252;
14414pub const kCVPixelFormatType_14Bayer_BGGR: _bindgen_ty_1661 = 1650943796;
14416pub const kCVPixelFormatType_14Bayer_GBRG: _bindgen_ty_1661 = 1734505012;
14418pub const kCVPixelFormatType_DisparityFloat16: _bindgen_ty_1661 = 1751411059;
14420pub const kCVPixelFormatType_DisparityFloat32: _bindgen_ty_1661 = 1717856627;
14422pub const kCVPixelFormatType_DepthFloat16: _bindgen_ty_1661 = 1751410032;
14424pub const kCVPixelFormatType_DepthFloat32: _bindgen_ty_1661 = 1717855600;
14426pub const kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange: _bindgen_ty_1661 = 2016686640;
14428pub const kCVPixelFormatType_422YpCbCr10BiPlanarVideoRange: _bindgen_ty_1661 = 2016686642;
14430pub const kCVPixelFormatType_444YpCbCr10BiPlanarVideoRange: _bindgen_ty_1661 = 2016687156;
14432pub const kCVPixelFormatType_420YpCbCr10BiPlanarFullRange: _bindgen_ty_1661 = 2019963440;
14434pub const kCVPixelFormatType_422YpCbCr10BiPlanarFullRange: _bindgen_ty_1661 = 2019963442;
14436pub const kCVPixelFormatType_444YpCbCr10BiPlanarFullRange: _bindgen_ty_1661 = 2019963956;
14438pub const kCVPixelFormatType_420YpCbCr8VideoRange_8A_TriPlanar: _bindgen_ty_1661 = 1982882104;
14440pub const kCVPixelFormatType_16VersatileBayer: _bindgen_ty_1661 = 1651519798;
14442pub const kCVPixelFormatType_96VersatileBayerPacked12: _bindgen_ty_1661 = 1651798066;
14444pub const kCVPixelFormatType_64RGBA_DownscaledProResRAW: _bindgen_ty_1661 = 1651521076;
14446pub const kCVPixelFormatType_422YpCbCr16BiPlanarVideoRange: _bindgen_ty_1661 = 1937125938;
14448pub const kCVPixelFormatType_444YpCbCr16BiPlanarVideoRange: _bindgen_ty_1661 = 1937126452;
14450pub const kCVPixelFormatType_444YpCbCr16VideoRange_16A_TriPlanar: _bindgen_ty_1661 = 1932812659;
14452pub const kCVPixelFormatType_30RGBLE_8A_BiPlanar: _bindgen_ty_1661 = 1647534392;
14454pub type _bindgen_ty_1661 = ::core::ffi::c_uint;
14456pub const kCVPixelFormatType_Lossless_32BGRA: _bindgen_ty_1662 = 641877825;
14458pub const kCVPixelFormatType_Lossless_64RGBAHalf: _bindgen_ty_1662 = 642934849;
14460pub const kCVPixelFormatType_Lossless_420YpCbCr8BiPlanarVideoRange: _bindgen_ty_1662 = 641234480;
14462pub const kCVPixelFormatType_Lossless_420YpCbCr8BiPlanarFullRange: _bindgen_ty_1662 = 641230384;
14464pub const kCVPixelFormatType_Lossless_420YpCbCr10PackedBiPlanarVideoRange: _bindgen_ty_1662 =
14466 645428784;
14467pub const kCVPixelFormatType_Lossless_422YpCbCr10PackedBiPlanarVideoRange: _bindgen_ty_1662 =
14469 645428786;
14470pub const kCVPixelFormatType_Lossless_420YpCbCr10PackedBiPlanarFullRange: _bindgen_ty_1662 =
14472 645424688;
14473pub const kCVPixelFormatType_Lossless_30RGBLE_8A_BiPlanar: _bindgen_ty_1662 = 643969848;
14475pub const kCVPixelFormatType_Lossless_30RGBLEPackedWideGamut: _bindgen_ty_1662 = 645346162;
14477pub type _bindgen_ty_1662 = ::core::ffi::c_uint;
14479pub const kCVPixelFormatType_Lossy_32BGRA: _bindgen_ty_1663 = 759318337;
14481pub const kCVPixelFormatType_Lossy_420YpCbCr8BiPlanarVideoRange: _bindgen_ty_1663 = 758674992;
14483pub const kCVPixelFormatType_Lossy_420YpCbCr8BiPlanarFullRange: _bindgen_ty_1663 = 758670896;
14485pub const kCVPixelFormatType_Lossy_420YpCbCr10PackedBiPlanarVideoRange: _bindgen_ty_1663 =
14487 762869296;
14488pub const kCVPixelFormatType_Lossy_422YpCbCr10PackedBiPlanarVideoRange: _bindgen_ty_1663 =
14490 762869298;
14491pub type _bindgen_ty_1663 = ::core::ffi::c_uint;
14493pub type CVPixelBufferLockFlags = CVOptionFlags;
14495pub const kCVPixelBufferLock_ReadOnly: _bindgen_ty_1664 = 1;
14497pub type _bindgen_ty_1664 = ::core::ffi::c_uint;
14499#[repr(C)]
14500#[derive(Debug, Copy, Clone)]
14501pub struct CVPlanarComponentInfo {
14503 pub offset: i32,
14504 pub rowBytes: u32,
14505}
14506#[repr(C)]
14507#[derive(Debug, Copy, Clone)]
14508pub struct CVPlanarPixelBufferInfo {
14510 pub componentInfo: [CVPlanarComponentInfo; 1usize],
14511}
14512#[repr(C)]
14513#[derive(Debug, Copy, Clone)]
14514pub struct CVPlanarPixelBufferInfo_YCbCrPlanar {
14516 pub componentInfoY: CVPlanarComponentInfo,
14517 pub componentInfoCb: CVPlanarComponentInfo,
14518 pub componentInfoCr: CVPlanarComponentInfo,
14519}
14520#[repr(C)]
14521#[derive(Debug, Copy, Clone)]
14522pub struct CVPlanarPixelBufferInfo_YCbCrBiPlanar {
14524 pub componentInfoY: CVPlanarComponentInfo,
14525 pub componentInfoCbCr: CVPlanarComponentInfo,
14526}
14527extern "C" {
14528pub static mut kCVPixelBufferPixelFormatTypeKey: CFStringRef;
14530}
14531extern "C" {
14532pub static mut kCVPixelBufferMemoryAllocatorKey: CFStringRef;
14534}
14535extern "C" {
14536pub static mut kCVPixelBufferWidthKey: CFStringRef;
14538}
14539extern "C" {
14540pub static mut kCVPixelBufferHeightKey: CFStringRef;
14542}
14543extern "C" {
14544pub static mut kCVPixelBufferExtendedPixelsLeftKey: CFStringRef;
14546}
14547extern "C" {
14548pub static mut kCVPixelBufferExtendedPixelsTopKey: CFStringRef;
14550}
14551extern "C" {
14552pub static mut kCVPixelBufferExtendedPixelsRightKey: CFStringRef;
14554}
14555extern "C" {
14556pub static mut kCVPixelBufferExtendedPixelsBottomKey: CFStringRef;
14558}
14559extern "C" {
14560pub static mut kCVPixelBufferBytesPerRowAlignmentKey: CFStringRef;
14562}
14563extern "C" {
14564pub static mut kCVPixelBufferCGBitmapContextCompatibilityKey: CFStringRef;
14566}
14567extern "C" {
14568pub static mut kCVPixelBufferCGImageCompatibilityKey: CFStringRef;
14570}
14571extern "C" {
14572pub static mut kCVPixelBufferOpenGLCompatibilityKey: CFStringRef;
14574}
14575extern "C" {
14576pub static mut kCVPixelBufferPlaneAlignmentKey: CFStringRef;
14578}
14579extern "C" {
14580pub static mut kCVPixelBufferIOSurfacePropertiesKey: CFStringRef;
14582}
14583extern "C" {
14584pub static mut kCVPixelBufferOpenGLESCompatibilityKey: CFStringRef;
14586}
14587extern "C" {
14588pub static mut kCVPixelBufferMetalCompatibilityKey: CFStringRef;
14590}
14591extern "C" {
14592pub static mut kCVPixelBufferOpenGLTextureCacheCompatibilityKey: CFStringRef;
14594}
14595extern "C" {
14596pub static mut kCVPixelBufferOpenGLESTextureCacheCompatibilityKey: CFStringRef;
14598}
14599extern "C" {
14600pub static mut kCVPixelBufferVersatileBayerKey_BayerPattern: CFStringRef;
14602}
14603pub const kCVVersatileBayer_BayerPattern_RGGB: _bindgen_ty_1665 = 0;
14605pub const kCVVersatileBayer_BayerPattern_GRBG: _bindgen_ty_1665 = 1;
14607pub const kCVVersatileBayer_BayerPattern_GBRG: _bindgen_ty_1665 = 2;
14609pub const kCVVersatileBayer_BayerPattern_BGGR: _bindgen_ty_1665 = 3;
14611pub type _bindgen_ty_1665 = ::core::ffi::c_uint;
14613extern "C" {
14614pub static mut kCVPixelBufferProResRAWKey_SenselSitingOffsets: CFStringRef;
14616}
14617extern "C" {
14618pub static mut kCVPixelBufferProResRAWKey_BlackLevel: CFStringRef;
14620}
14621extern "C" {
14622pub static mut kCVPixelBufferProResRAWKey_WhiteLevel: CFStringRef;
14624}
14625extern "C" {
14626pub static mut kCVPixelBufferProResRAWKey_WhiteBalanceCCT: CFStringRef;
14628}
14629extern "C" {
14630pub static mut kCVPixelBufferProResRAWKey_WhiteBalanceRedFactor: CFStringRef;
14632}
14633extern "C" {
14634pub static mut kCVPixelBufferProResRAWKey_WhiteBalanceBlueFactor: CFStringRef;
14636}
14637extern "C" {
14638pub static mut kCVPixelBufferProResRAWKey_ColorMatrix: CFStringRef;
14640}
14641extern "C" {
14642pub static mut kCVPixelBufferProResRAWKey_GainFactor: CFStringRef;
14644}
14645extern "C" {
14646pub static mut kCVPixelBufferProResRAWKey_RecommendedCrop: CFStringRef;
14648}
14649extern "C" {
14650pub static mut kCVPixelBufferProResRAWKey_MetadataExtension: CFStringRef;
14652}
14653extern "C" {
14654pub static mut kCVPixelBufferIOSurfacePurgeableKey: CFStringRef;
14656}
14657pub type CVPixelBufferRef = CVImageBufferRef;
14659extern "C" {
14660pub fn CVPixelBufferGetTypeID() -> CFTypeID;
14662}
14663extern "C" {
14664pub fn CVPixelBufferRetain(texture: CVPixelBufferRef) -> CVPixelBufferRef;
14666}
14667extern "C" {
14668pub fn CVPixelBufferRelease(texture: CVPixelBufferRef);
14670}
14671extern "C" {
14672pub fn CVPixelBufferCreateResolvedAttributesDictionary(
14674 allocator: CFAllocatorRef,
14675 attributes: CFArrayRef,
14676 resolvedDictionaryOut: *mut CFDictionaryRef,
14677 ) -> CVReturn;
14678}
14679extern "C" {
14680pub fn CVPixelBufferCreate(
14682 allocator: CFAllocatorRef,
14683 width: usize,
14684 height: usize,
14685 pixelFormatType: OSType,
14686 pixelBufferAttributes: CFDictionaryRef,
14687 pixelBufferOut: *mut CVPixelBufferRef,
14688 ) -> CVReturn;
14689}
14690pub type CVPixelBufferReleaseBytesCallback = ::core::option::Option<
14692 unsafe extern "C" fn(
14693 releaseRefCon: *mut ::core::ffi::c_void,
14694 baseAddress: *const ::core::ffi::c_void,
14695 ),
14696>;
14697extern "C" {
14698pub fn CVPixelBufferCreateWithBytes(
14700 allocator: CFAllocatorRef,
14701 width: usize,
14702 height: usize,
14703 pixelFormatType: OSType,
14704 baseAddress: *mut ::core::ffi::c_void,
14705 bytesPerRow: usize,
14706 releaseCallback: CVPixelBufferReleaseBytesCallback,
14707 releaseRefCon: *mut ::core::ffi::c_void,
14708 pixelBufferAttributes: CFDictionaryRef,
14709 pixelBufferOut: *mut CVPixelBufferRef,
14710 ) -> CVReturn;
14711}
14712pub type CVPixelBufferReleasePlanarBytesCallback = ::core::option::Option<
14714 unsafe extern "C" fn(
14715 releaseRefCon: *mut ::core::ffi::c_void,
14716 dataPtr: *const ::core::ffi::c_void,
14717 dataSize: usize,
14718 numberOfPlanes: usize,
14719 planeAddresses: *mut *const ::core::ffi::c_void,
14720 ),
14721>;
14722extern "C" {
14723pub fn CVPixelBufferCreateWithPlanarBytes(
14725 allocator: CFAllocatorRef,
14726 width: usize,
14727 height: usize,
14728 pixelFormatType: OSType,
14729 dataPtr: *mut ::core::ffi::c_void,
14730 dataSize: usize,
14731 numberOfPlanes: usize,
14732 planeBaseAddress: *mut *mut ::core::ffi::c_void,
14733 planeWidth: *mut usize,
14734 planeHeight: *mut usize,
14735 planeBytesPerRow: *mut usize,
14736 releaseCallback: CVPixelBufferReleasePlanarBytesCallback,
14737 releaseRefCon: *mut ::core::ffi::c_void,
14738 pixelBufferAttributes: CFDictionaryRef,
14739 pixelBufferOut: *mut CVPixelBufferRef,
14740 ) -> CVReturn;
14741}
14742extern "C" {
14743pub fn CVPixelBufferLockBaseAddress(
14745 pixelBuffer: CVPixelBufferRef,
14746 lockFlags: CVPixelBufferLockFlags,
14747 ) -> CVReturn;
14748}
14749extern "C" {
14750pub fn CVPixelBufferUnlockBaseAddress(
14752 pixelBuffer: CVPixelBufferRef,
14753 unlockFlags: CVPixelBufferLockFlags,
14754 ) -> CVReturn;
14755}
14756extern "C" {
14757pub fn CVPixelBufferGetWidth(pixelBuffer: CVPixelBufferRef) -> usize;
14759}
14760extern "C" {
14761pub fn CVPixelBufferGetHeight(pixelBuffer: CVPixelBufferRef) -> usize;
14763}
14764extern "C" {
14765pub fn CVPixelBufferGetPixelFormatType(pixelBuffer: CVPixelBufferRef) -> OSType;
14767}
14768extern "C" {
14769pub fn CVPixelBufferGetBaseAddress(pixelBuffer: CVPixelBufferRef) -> *mut ::core::ffi::c_void;
14771}
14772extern "C" {
14773pub fn CVPixelBufferGetBytesPerRow(pixelBuffer: CVPixelBufferRef) -> usize;
14775}
14776extern "C" {
14777pub fn CVPixelBufferGetDataSize(pixelBuffer: CVPixelBufferRef) -> usize;
14779}
14780extern "C" {
14781pub fn CVPixelBufferIsPlanar(pixelBuffer: CVPixelBufferRef) -> Boolean;
14783}
14784extern "C" {
14785pub fn CVPixelBufferGetPlaneCount(pixelBuffer: CVPixelBufferRef) -> usize;
14787}
14788extern "C" {
14789pub fn CVPixelBufferGetWidthOfPlane(pixelBuffer: CVPixelBufferRef, planeIndex: usize) -> usize;
14791}
14792extern "C" {
14793pub fn CVPixelBufferGetHeightOfPlane(pixelBuffer: CVPixelBufferRef, planeIndex: usize)
14795 -> usize;
14796}
14797extern "C" {
14798pub fn CVPixelBufferGetBaseAddressOfPlane(
14800 pixelBuffer: CVPixelBufferRef,
14801 planeIndex: usize,
14802 ) -> *mut ::core::ffi::c_void;
14803}
14804extern "C" {
14805pub fn CVPixelBufferGetBytesPerRowOfPlane(
14807 pixelBuffer: CVPixelBufferRef,
14808 planeIndex: usize,
14809 ) -> usize;
14810}
14811extern "C" {
14812pub fn CVPixelBufferGetExtendedPixels(
14814 pixelBuffer: CVPixelBufferRef,
14815 extraColumnsOnLeft: *mut usize,
14816 extraColumnsOnRight: *mut usize,
14817 extraRowsOnTop: *mut usize,
14818 extraRowsOnBottom: *mut usize,
14819 );
14820}
14821extern "C" {
14822pub fn CVPixelBufferFillExtendedPixels(pixelBuffer: CVPixelBufferRef) -> CVReturn;
14824}
14825extern "C" {
14826pub fn CVPixelBufferCopyCreationAttributes(pixelBuffer: CVPixelBufferRef) -> CFDictionaryRef;
14828}
14829extern "C" {
14830pub fn CVPixelBufferIsCompatibleWithAttributes(
14832 pixelBuffer: CVPixelBufferRef,
14833 attributes: CFDictionaryRef,
14834 ) -> Boolean;
14835}
14836pub type IOSurfaceID = u32;
14838pub type IOSurfaceLockOptions = u32;
14840pub const kIOSurfaceLockReadOnly: _bindgen_ty_1666 = 1;
14842pub const kIOSurfaceLockAvoidSync: _bindgen_ty_1666 = 2;
14844pub type _bindgen_ty_1666 = ::core::ffi::c_uint;
14846pub type IOSurfacePurgeabilityState = u32;
14848pub const kIOSurfacePurgeableNonVolatile: _bindgen_ty_1667 = 0;
14850pub const kIOSurfacePurgeableVolatile: _bindgen_ty_1667 = 1;
14852pub const kIOSurfacePurgeableEmpty: _bindgen_ty_1667 = 2;
14854pub const kIOSurfacePurgeableKeepCurrent: _bindgen_ty_1667 = 3;
14856pub type _bindgen_ty_1667 = ::core::ffi::c_uint;
14858pub const kIOSurfaceDefaultCache: _bindgen_ty_1668 = 0;
14860pub const kIOSurfaceInhibitCache: _bindgen_ty_1668 = 1;
14862pub const kIOSurfaceWriteThruCache: _bindgen_ty_1668 = 2;
14864pub const kIOSurfaceCopybackCache: _bindgen_ty_1668 = 3;
14866pub const kIOSurfaceWriteCombineCache: _bindgen_ty_1668 = 4;
14868pub const kIOSurfaceCopybackInnerCache: _bindgen_ty_1668 = 5;
14870pub type _bindgen_ty_1668 = ::core::ffi::c_uint;
14872pub const kIOSurfaceMapCacheShift: _bindgen_ty_1669 = 8;
14874pub const kIOSurfaceMapDefaultCache: _bindgen_ty_1669 = 0;
14876pub const kIOSurfaceMapInhibitCache: _bindgen_ty_1669 = 256;
14878pub const kIOSurfaceMapWriteThruCache: _bindgen_ty_1669 = 512;
14880pub const kIOSurfaceMapCopybackCache: _bindgen_ty_1669 = 768;
14882pub const kIOSurfaceMapWriteCombineCache: _bindgen_ty_1669 = 1024;
14884pub const kIOSurfaceMapCopybackInnerCache: _bindgen_ty_1669 = 1280;
14886pub type _bindgen_ty_1669 = ::core::ffi::c_uint;
14888extern "C" {
14889pub static kIOSurfaceAllocSize: CFStringRef;
14891}
14892extern "C" {
14893pub static kIOSurfaceWidth: CFStringRef;
14895}
14896extern "C" {
14897pub static kIOSurfaceHeight: CFStringRef;
14899}
14900extern "C" {
14901pub static kIOSurfaceBytesPerRow: CFStringRef;
14903}
14904extern "C" {
14905pub static kIOSurfaceBytesPerElement: CFStringRef;
14907}
14908extern "C" {
14909pub static kIOSurfaceElementWidth: CFStringRef;
14911}
14912extern "C" {
14913pub static kIOSurfaceElementHeight: CFStringRef;
14915}
14916extern "C" {
14917pub static kIOSurfaceOffset: CFStringRef;
14919}
14920extern "C" {
14921pub static kIOSurfacePlaneInfo: CFStringRef;
14923}
14924extern "C" {
14925pub static kIOSurfacePlaneWidth: CFStringRef;
14927}
14928extern "C" {
14929pub static kIOSurfacePlaneHeight: CFStringRef;
14931}
14932extern "C" {
14933pub static kIOSurfacePlaneBytesPerRow: CFStringRef;
14935}
14936extern "C" {
14937pub static kIOSurfacePlaneOffset: CFStringRef;
14939}
14940extern "C" {
14941pub static kIOSurfacePlaneSize: CFStringRef;
14943}
14944extern "C" {
14945pub static kIOSurfacePlaneBase: CFStringRef;
14947}
14948extern "C" {
14949pub static kIOSurfacePlaneBitsPerElement: CFStringRef;
14951}
14952extern "C" {
14953pub static kIOSurfacePlaneBytesPerElement: CFStringRef;
14955}
14956extern "C" {
14957pub static kIOSurfacePlaneElementWidth: CFStringRef;
14959}
14960extern "C" {
14961pub static kIOSurfacePlaneElementHeight: CFStringRef;
14963}
14964extern "C" {
14965pub static kIOSurfaceCacheMode: CFStringRef;
14967}
14968extern "C" {
14969pub static kIOSurfaceIsGlobal: CFStringRef;
14971}
14972extern "C" {
14973pub static kIOSurfacePixelFormat: CFStringRef;
14975}
14976extern "C" {
14977pub static kIOSurfacePixelSizeCastingAllowed: CFStringRef;
14979}
14980extern "C" {
14981pub static kIOSurfacePlaneComponentBitDepths: CFStringRef;
14983}
14984extern "C" {
14985pub static kIOSurfacePlaneComponentBitOffsets: CFStringRef;
14987}
14988extern "C" {
14989pub static kIOSurfaceName: CFStringRef;
14991}
14992pub type IOSurfaceComponentName = i32;
14994pub const kIOSurfaceComponentNameUnknown: _bindgen_ty_1670 = 0;
14996pub const kIOSurfaceComponentNameAlpha: _bindgen_ty_1670 = 1;
14998pub const kIOSurfaceComponentNameRed: _bindgen_ty_1670 = 2;
15000pub const kIOSurfaceComponentNameGreen: _bindgen_ty_1670 = 3;
15002pub const kIOSurfaceComponentNameBlue: _bindgen_ty_1670 = 4;
15004pub const kIOSurfaceComponentNameLuma: _bindgen_ty_1670 = 5;
15006pub const kIOSurfaceComponentNameChromaRed: _bindgen_ty_1670 = 6;
15008pub const kIOSurfaceComponentNameChromaBlue: _bindgen_ty_1670 = 7;
15010pub type _bindgen_ty_1670 = ::core::ffi::c_uint;
15012extern "C" {
15013pub static kIOSurfacePlaneComponentNames: CFStringRef;
15015}
15016pub type IOSurfaceComponentType = i32;
15018pub const kIOSurfaceComponentTypeUnknown: _bindgen_ty_1671 = 0;
15020pub const kIOSurfaceComponentTypeUnsignedInteger: _bindgen_ty_1671 = 1;
15022pub const kIOSurfaceComponentTypeSignedInteger: _bindgen_ty_1671 = 2;
15024pub const kIOSurfaceComponentTypeFloat: _bindgen_ty_1671 = 3;
15026pub const kIOSurfaceComponentTypeSignedNormalized: _bindgen_ty_1671 = 4;
15028pub type _bindgen_ty_1671 = ::core::ffi::c_uint;
15030extern "C" {
15031pub static kIOSurfacePlaneComponentTypes: CFStringRef;
15033}
15034pub type IOSurfaceComponentRange = i32;
15036pub const kIOSurfaceComponentRangeUnknown: _bindgen_ty_1672 = 0;
15038pub const kIOSurfaceComponentRangeFullRange: _bindgen_ty_1672 = 1;
15040pub const kIOSurfaceComponentRangeVideoRange: _bindgen_ty_1672 = 2;
15042pub const kIOSurfaceComponentRangeWideRange: _bindgen_ty_1672 = 3;
15044pub type _bindgen_ty_1672 = ::core::ffi::c_uint;
15046extern "C" {
15047pub static kIOSurfacePlaneComponentRanges: CFStringRef;
15049}
15050pub type IOSurfaceSubsampling = i32;
15052pub const kIOSurfaceSubsamplingUnknown: _bindgen_ty_1673 = 0;
15054pub const kIOSurfaceSubsamplingNone: _bindgen_ty_1673 = 1;
15056pub const kIOSurfaceSubsampling422: _bindgen_ty_1673 = 2;
15058pub const kIOSurfaceSubsampling420: _bindgen_ty_1673 = 3;
15060pub const kIOSurfaceSubsampling411: _bindgen_ty_1673 = 4;
15062pub type _bindgen_ty_1673 = ::core::ffi::c_uint;
15064extern "C" {
15065pub static kIOSurfaceSubsampling: CFStringRef;
15067}
15068extern "C" {
15069pub fn IOSurfaceGetTypeID() -> CFTypeID;
15071}
15072extern "C" {
15073pub fn IOSurfaceCreate(properties: CFDictionaryRef) -> IOSurfaceRef;
15075}
15076extern "C" {
15077pub fn IOSurfaceLookup(csid: IOSurfaceID) -> IOSurfaceRef;
15079}
15080extern "C" {
15081pub fn IOSurfaceGetID(buffer: IOSurfaceRef) -> IOSurfaceID;
15083}
15084extern "C" {
15085pub fn IOSurfaceLock(
15087 buffer: IOSurfaceRef,
15088 options: IOSurfaceLockOptions,
15089 seed: *mut u32,
15090 ) -> kern_return_t;
15091}
15092extern "C" {
15093pub fn IOSurfaceUnlock(
15095 buffer: IOSurfaceRef,
15096 options: IOSurfaceLockOptions,
15097 seed: *mut u32,
15098 ) -> kern_return_t;
15099}
15100extern "C" {
15101pub fn IOSurfaceGetAllocSize(buffer: IOSurfaceRef) -> usize;
15103}
15104extern "C" {
15105pub fn IOSurfaceGetWidth(buffer: IOSurfaceRef) -> usize;
15107}
15108extern "C" {
15109pub fn IOSurfaceGetHeight(buffer: IOSurfaceRef) -> usize;
15111}
15112extern "C" {
15113pub fn IOSurfaceGetBytesPerElement(buffer: IOSurfaceRef) -> usize;
15115}
15116extern "C" {
15117pub fn IOSurfaceGetBytesPerRow(buffer: IOSurfaceRef) -> usize;
15119}
15120extern "C" {
15121pub fn IOSurfaceGetBaseAddress(buffer: IOSurfaceRef) -> *mut ::core::ffi::c_void;
15123}
15124extern "C" {
15125pub fn IOSurfaceGetElementWidth(buffer: IOSurfaceRef) -> usize;
15127}
15128extern "C" {
15129pub fn IOSurfaceGetElementHeight(buffer: IOSurfaceRef) -> usize;
15131}
15132extern "C" {
15133pub fn IOSurfaceGetPixelFormat(buffer: IOSurfaceRef) -> OSType;
15135}
15136extern "C" {
15137pub fn IOSurfaceGetSeed(buffer: IOSurfaceRef) -> u32;
15139}
15140extern "C" {
15141pub fn IOSurfaceGetPlaneCount(buffer: IOSurfaceRef) -> usize;
15143}
15144extern "C" {
15145pub fn IOSurfaceGetWidthOfPlane(buffer: IOSurfaceRef, planeIndex: usize) -> usize;
15147}
15148extern "C" {
15149pub fn IOSurfaceGetHeightOfPlane(buffer: IOSurfaceRef, planeIndex: usize) -> usize;
15151}
15152extern "C" {
15153pub fn IOSurfaceGetBytesPerElementOfPlane(buffer: IOSurfaceRef, planeIndex: usize) -> usize;
15155}
15156extern "C" {
15157pub fn IOSurfaceGetBytesPerRowOfPlane(buffer: IOSurfaceRef, planeIndex: usize) -> usize;
15159}
15160extern "C" {
15161pub fn IOSurfaceGetBaseAddressOfPlane(
15163 buffer: IOSurfaceRef,
15164 planeIndex: usize,
15165 ) -> *mut ::core::ffi::c_void;
15166}
15167extern "C" {
15168pub fn IOSurfaceGetElementWidthOfPlane(buffer: IOSurfaceRef, planeIndex: usize) -> usize;
15170}
15171extern "C" {
15172pub fn IOSurfaceGetElementHeightOfPlane(buffer: IOSurfaceRef, planeIndex: usize) -> usize;
15174}
15175extern "C" {
15176pub fn IOSurfaceGetNumberOfComponentsOfPlane(buffer: IOSurfaceRef, planeIndex: usize) -> usize;
15178}
15179extern "C" {
15180pub fn IOSurfaceGetNameOfComponentOfPlane(
15182 buffer: IOSurfaceRef,
15183 planeIndex: usize,
15184 componentIndex: usize,
15185 ) -> IOSurfaceComponentName;
15186}
15187extern "C" {
15188pub fn IOSurfaceGetTypeOfComponentOfPlane(
15190 buffer: IOSurfaceRef,
15191 planeIndex: usize,
15192 componentIndex: usize,
15193 ) -> IOSurfaceComponentType;
15194}
15195extern "C" {
15196pub fn IOSurfaceGetRangeOfComponentOfPlane(
15198 buffer: IOSurfaceRef,
15199 planeIndex: usize,
15200 componentIndex: usize,
15201 ) -> IOSurfaceComponentRange;
15202}
15203extern "C" {
15204pub fn IOSurfaceGetBitDepthOfComponentOfPlane(
15206 buffer: IOSurfaceRef,
15207 planeIndex: usize,
15208 componentIndex: usize,
15209 ) -> usize;
15210}
15211extern "C" {
15212pub fn IOSurfaceGetBitOffsetOfComponentOfPlane(
15214 buffer: IOSurfaceRef,
15215 planeIndex: usize,
15216 componentIndex: usize,
15217 ) -> usize;
15218}
15219extern "C" {
15220pub fn IOSurfaceGetSubsampling(buffer: IOSurfaceRef) -> IOSurfaceSubsampling;
15222}
15223extern "C" {
15224pub static kIOSurfaceColorSpace: CFStringRef;
15226}
15227extern "C" {
15228pub static kIOSurfaceICCProfile: CFStringRef;
15230}
15231extern "C" {
15232pub static kIOSurfaceContentHeadroom: CFStringRef;
15234}
15235extern "C" {
15236pub fn IOSurfaceSetValue(buffer: IOSurfaceRef, key: CFStringRef, value: CFTypeRef);
15238}
15239extern "C" {
15240pub fn IOSurfaceCopyValue(buffer: IOSurfaceRef, key: CFStringRef) -> CFTypeRef;
15242}
15243extern "C" {
15244pub fn IOSurfaceRemoveValue(buffer: IOSurfaceRef, key: CFStringRef);
15246}
15247extern "C" {
15248pub fn IOSurfaceSetValues(buffer: IOSurfaceRef, keysAndValues: CFDictionaryRef);
15250}
15251extern "C" {
15252pub fn IOSurfaceCopyAllValues(buffer: IOSurfaceRef) -> CFDictionaryRef;
15254}
15255extern "C" {
15256pub fn IOSurfaceRemoveAllValues(buffer: IOSurfaceRef);
15258}
15259extern "C" {
15260pub fn IOSurfaceCreateMachPort(buffer: IOSurfaceRef) -> mach_port_t;
15262}
15263extern "C" {
15264pub fn IOSurfaceLookupFromMachPort(port: mach_port_t) -> IOSurfaceRef;
15266}
15267extern "C" {
15268pub fn IOSurfaceGetPropertyMaximum(property: CFStringRef) -> usize;
15270}
15271extern "C" {
15272pub fn IOSurfaceGetPropertyAlignment(property: CFStringRef) -> usize;
15274}
15275extern "C" {
15276pub fn IOSurfaceAlignProperty(property: CFStringRef, value: usize) -> usize;
15278}
15279extern "C" {
15280pub fn IOSurfaceIncrementUseCount(buffer: IOSurfaceRef);
15282}
15283extern "C" {
15284pub fn IOSurfaceDecrementUseCount(buffer: IOSurfaceRef);
15286}
15287extern "C" {
15288pub fn IOSurfaceGetUseCount(buffer: IOSurfaceRef) -> i32;
15290}
15291extern "C" {
15292pub fn IOSurfaceIsInUse(buffer: IOSurfaceRef) -> Boolean;
15294}
15295extern "C" {
15296pub fn IOSurfaceAllowsPixelSizeCasting(buffer: IOSurfaceRef) -> Boolean;
15298}
15299extern "C" {
15300pub fn IOSurfaceSetPurgeable(
15302 buffer: IOSurfaceRef,
15303 newState: u32,
15304 oldState: *mut u32,
15305 ) -> kern_return_t;
15306}
15307pub type IOSurfaceMemoryLedgerTags = ::core::ffi::c_int;
15309pub const kIOSurfaceMemoryLedgerTagDefault: _bindgen_ty_1674 = 1;
15311pub const kIOSurfaceMemoryLedgerTagNetwork: _bindgen_ty_1674 = 2;
15313pub const kIOSurfaceMemoryLedgerTagMedia: _bindgen_ty_1674 = 3;
15315pub const kIOSurfaceMemoryLedgerTagGraphics: _bindgen_ty_1674 = 4;
15317pub const kIOSurfaceMemoryLedgerTagNeural: _bindgen_ty_1674 = 5;
15319pub type _bindgen_ty_1674 = ::core::ffi::c_uint;
15321pub type IOSurfaceMemoryLedgerFlags = u32;
15323pub const kIOSurfaceMemoryLedgerFlagNoFootprint: _bindgen_ty_1675 = 1;
15325pub type _bindgen_ty_1675 = ::core::ffi::c_uint;
15327extern "C" {
15328pub fn IOSurfaceSetOwnershipIdentity(
15330 buffer: IOSurfaceRef,
15331 task_id_token: task_id_token_t,
15332 newLedgerTag: ::core::ffi::c_int,
15333 newLedgerOptions: u32,
15334 ) -> kern_return_t;
15335}
15336extern "C" {
15337pub fn IOSurfaceCreateXPCObject(aSurface: IOSurfaceRef) -> xpc_object_t;
15339}
15340extern "C" {
15341pub fn IOSurfaceLookupFromXPCObject(xobj: xpc_object_t) -> IOSurfaceRef;
15343}
15344extern "C" {
15345pub static mut kCVPixelBufferIOSurfaceOpenGLTextureCompatibilityKey: CFStringRef;
15347}
15348extern "C" {
15349pub static mut kCVPixelBufferIOSurfaceOpenGLFBOCompatibilityKey: CFStringRef;
15351}
15352extern "C" {
15353pub static mut kCVPixelBufferIOSurfaceCoreAnimationCompatibilityKey: CFStringRef;
15355}
15356extern "C" {
15357pub static mut kCVPixelBufferIOSurfaceOpenGLESTextureCompatibilityKey: CFStringRef;
15359}
15360extern "C" {
15361pub static mut kCVPixelBufferIOSurfaceOpenGLESFBOCompatibilityKey: CFStringRef;
15363}
15364extern "C" {
15365pub fn CVPixelBufferGetIOSurface(pixelBuffer: CVPixelBufferRef) -> IOSurfaceRef;
15367}
15368extern "C" {
15369pub fn CVPixelBufferCreateWithIOSurface(
15371 allocator: CFAllocatorRef,
15372 surface: IOSurfaceRef,
15373 pixelBufferAttributes: CFDictionaryRef,
15374 pixelBufferOut: *mut CVPixelBufferRef,
15375 ) -> CVReturn;
15376}
15377#[repr(C)]
15378#[derive(Debug, Copy, Clone)]
15379pub struct __CVPixelBufferPool {
15381 _unused: [u8; 0],
15382}
15383pub type CVPixelBufferPoolRef = *mut __CVPixelBufferPool;
15385extern "C" {
15386pub static mut kCVPixelBufferPoolMinimumBufferCountKey: CFStringRef;
15388}
15389extern "C" {
15390pub static mut kCVPixelBufferPoolMaximumBufferAgeKey: CFStringRef;
15392}
15393extern "C" {
15394pub fn CVPixelBufferPoolGetTypeID() -> CFTypeID;
15396}
15397extern "C" {
15398pub fn CVPixelBufferPoolRetain(pixelBufferPool: CVPixelBufferPoolRef) -> CVPixelBufferPoolRef;
15400}
15401extern "C" {
15402pub fn CVPixelBufferPoolRelease(pixelBufferPool: CVPixelBufferPoolRef);
15404}
15405extern "C" {
15406pub fn CVPixelBufferPoolCreate(
15408 allocator: CFAllocatorRef,
15409 poolAttributes: CFDictionaryRef,
15410 pixelBufferAttributes: CFDictionaryRef,
15411 poolOut: *mut CVPixelBufferPoolRef,
15412 ) -> CVReturn;
15413}
15414extern "C" {
15415pub fn CVPixelBufferPoolGetAttributes(pool: CVPixelBufferPoolRef) -> CFDictionaryRef;
15417}
15418extern "C" {
15419pub fn CVPixelBufferPoolGetPixelBufferAttributes(pool: CVPixelBufferPoolRef)
15421 -> CFDictionaryRef;
15422}
15423extern "C" {
15424pub fn CVPixelBufferPoolCreatePixelBuffer(
15426 allocator: CFAllocatorRef,
15427 pixelBufferPool: CVPixelBufferPoolRef,
15428 pixelBufferOut: *mut CVPixelBufferRef,
15429 ) -> CVReturn;
15430}
15431extern "C" {
15432pub fn CVPixelBufferPoolCreatePixelBufferWithAuxAttributes(
15434 allocator: CFAllocatorRef,
15435 pixelBufferPool: CVPixelBufferPoolRef,
15436 auxAttributes: CFDictionaryRef,
15437 pixelBufferOut: *mut CVPixelBufferRef,
15438 ) -> CVReturn;
15439}
15440extern "C" {
15441pub static mut kCVPixelBufferPoolAllocationThresholdKey: CFStringRef;
15443}
15444extern "C" {
15445pub static mut kCVPixelBufferPoolFreeBufferNotification: CFStringRef;
15447}
15448pub type CVPixelBufferPoolFlushFlags = CVOptionFlags;
15450pub const kCVPixelBufferPoolFlushExcessBuffers: _bindgen_ty_1676 = 1;
15452pub type _bindgen_ty_1676 = ::core::ffi::c_uint;
15454extern "C" {
15455pub fn CVPixelBufferPoolFlush(pool: CVPixelBufferPoolRef, options: CVPixelBufferPoolFlushFlags);
15457}
15458extern "C" {
15459pub static mut kCVOpenGLBufferWidth: CFStringRef;
15461}
15462extern "C" {
15463pub static mut kCVOpenGLBufferHeight: CFStringRef;
15465}
15466extern "C" {
15467pub static mut kCVOpenGLBufferTarget: CFStringRef;
15469}
15470extern "C" {
15471pub static mut kCVOpenGLBufferInternalFormat: CFStringRef;
15473}
15474extern "C" {
15475pub static mut kCVOpenGLBufferMaximumMipmapLevel: CFStringRef;
15477}
15478pub type CVOpenGLBufferRef = CVImageBufferRef;
15480extern "C" {
15481pub fn CVOpenGLBufferGetTypeID() -> CFTypeID;
15483}
15484extern "C" {
15485pub fn CVOpenGLBufferRetain(buffer: CVOpenGLBufferRef) -> CVOpenGLBufferRef;
15487}
15488extern "C" {
15489pub fn CVOpenGLBufferRelease(buffer: CVOpenGLBufferRef);
15491}
15492extern "C" {
15493pub fn CVOpenGLBufferCreate(
15495 allocator: CFAllocatorRef,
15496 width: usize,
15497 height: usize,
15498 attributes: CFDictionaryRef,
15499 bufferOut: *mut CVOpenGLBufferRef,
15500 ) -> CVReturn;
15501}
15502extern "C" {
15503pub fn CVOpenGLBufferGetAttributes(openGLBuffer: CVOpenGLBufferRef) -> CFDictionaryRef;
15505}
15506extern "C" {
15507pub fn CVOpenGLBufferAttach(
15509 openGLBuffer: CVOpenGLBufferRef,
15510 cglContext: CGLContextObj,
15511 face: GLenum,
15512 level: GLint,
15513 screen: GLint,
15514 ) -> CVReturn;
15515}
15516#[repr(C)]
15517#[derive(Debug, Copy, Clone)]
15518pub struct __CVOpenGLBufferPool {
15520 _unused: [u8; 0],
15521}
15522pub type CVOpenGLBufferPoolRef = *mut __CVOpenGLBufferPool;
15524extern "C" {
15525pub static mut kCVOpenGLBufferPoolMinimumBufferCountKey: CFStringRef;
15527}
15528extern "C" {
15529pub static mut kCVOpenGLBufferPoolMaximumBufferAgeKey: CFStringRef;
15531}
15532extern "C" {
15533pub fn CVOpenGLBufferPoolGetTypeID() -> CFTypeID;
15535}
15536extern "C" {
15537pub fn CVOpenGLBufferPoolRetain(
15539 openGLBufferPool: CVOpenGLBufferPoolRef,
15540 ) -> CVOpenGLBufferPoolRef;
15541}
15542extern "C" {
15543pub fn CVOpenGLBufferPoolRelease(openGLBufferPool: CVOpenGLBufferPoolRef);
15545}
15546extern "C" {
15547pub fn CVOpenGLBufferPoolCreate(
15549 allocator: CFAllocatorRef,
15550 poolAttributes: CFDictionaryRef,
15551 openGLBufferAttributes: CFDictionaryRef,
15552 poolOut: *mut CVOpenGLBufferPoolRef,
15553 ) -> CVReturn;
15554}
15555extern "C" {
15556pub fn CVOpenGLBufferPoolGetAttributes(pool: CVOpenGLBufferPoolRef) -> CFDictionaryRef;
15558}
15559extern "C" {
15560pub fn CVOpenGLBufferPoolGetOpenGLBufferAttributes(
15562 pool: CVOpenGLBufferPoolRef,
15563 ) -> CFDictionaryRef;
15564}
15565extern "C" {
15566pub fn CVOpenGLBufferPoolCreateOpenGLBuffer(
15568 allocator: CFAllocatorRef,
15569 openGLBufferPool: CVOpenGLBufferPoolRef,
15570 openGLBufferOut: *mut CVOpenGLBufferRef,
15571 ) -> CVReturn;
15572}
15573pub type CVOpenGLTextureRef = CVImageBufferRef;
15575extern "C" {
15576pub fn CVOpenGLTextureGetTypeID() -> CFTypeID;
15578}
15579extern "C" {
15580pub fn CVOpenGLTextureRetain(texture: CVOpenGLTextureRef) -> CVOpenGLTextureRef;
15582}
15583extern "C" {
15584pub fn CVOpenGLTextureRelease(texture: CVOpenGLTextureRef);
15586}
15587extern "C" {
15588pub fn CVOpenGLTextureGetTarget(image: CVOpenGLTextureRef) -> GLenum;
15590}
15591extern "C" {
15592pub fn CVOpenGLTextureGetName(image: CVOpenGLTextureRef) -> GLuint;
15594}
15595extern "C" {
15596pub fn CVOpenGLTextureIsFlipped(image: CVOpenGLTextureRef) -> Boolean;
15598}
15599extern "C" {
15600pub fn CVOpenGLTextureGetCleanTexCoords(
15602 image: CVOpenGLTextureRef,
15603 lowerLeft: *mut GLfloat,
15604 lowerRight: *mut GLfloat,
15605 upperRight: *mut GLfloat,
15606 upperLeft: *mut GLfloat,
15607 );
15608}
15609#[repr(C)]
15610#[derive(Debug, Copy, Clone)]
15611pub struct __CVOpenGLTextureCache {
15613 _unused: [u8; 0],
15614}
15615pub type CVOpenGLTextureCacheRef = *mut __CVOpenGLTextureCache;
15617extern "C" {
15618pub static mut kCVOpenGLTextureCacheChromaSamplingModeKey: CFStringRef;
15620}
15621extern "C" {
15622pub static mut kCVOpenGLTextureCacheChromaSamplingModeAutomatic: CFStringRef;
15624}
15625extern "C" {
15626pub static mut kCVOpenGLTextureCacheChromaSamplingModeHighestQuality: CFStringRef;
15628}
15629extern "C" {
15630pub static mut kCVOpenGLTextureCacheChromaSamplingModeBestPerformance: CFStringRef;
15632}
15633extern "C" {
15634pub fn CVOpenGLTextureCacheGetTypeID() -> CFTypeID;
15636}
15637extern "C" {
15638pub fn CVOpenGLTextureCacheRetain(
15640 textureCache: CVOpenGLTextureCacheRef,
15641 ) -> CVOpenGLTextureCacheRef;
15642}
15643extern "C" {
15644pub fn CVOpenGLTextureCacheRelease(textureCache: CVOpenGLTextureCacheRef);
15646}
15647extern "C" {
15648pub fn CVOpenGLTextureCacheCreate(
15650 allocator: CFAllocatorRef,
15651 cacheAttributes: CFDictionaryRef,
15652 cglContext: CGLContextObj,
15653 cglPixelFormat: CGLPixelFormatObj,
15654 textureAttributes: CFDictionaryRef,
15655 cacheOut: *mut CVOpenGLTextureCacheRef,
15656 ) -> CVReturn;
15657}
15658extern "C" {
15659pub fn CVOpenGLTextureCacheCreateTextureFromImage(
15661 allocator: CFAllocatorRef,
15662 textureCache: CVOpenGLTextureCacheRef,
15663 sourceImage: CVImageBufferRef,
15664 attributes: CFDictionaryRef,
15665 textureOut: *mut CVOpenGLTextureRef,
15666 ) -> CVReturn;
15667}
15668extern "C" {
15669pub fn CVOpenGLTextureCacheFlush(textureCache: CVOpenGLTextureCacheRef, options: CVOptionFlags);
15671}
15672extern "C" {
15673pub static mut kCVMetalTextureUsage: CFStringRef;
15675}
15676extern "C" {
15677pub static mut kCVMetalTextureStorageMode: CFStringRef;
15679}
15680extern "C" {
15681pub static mut kCVMetalTextureCacheMaximumTextureAgeKey: CFStringRef;
15683}
15684pub type CVMetalBufferRef = CVBufferRef;
15686extern "C" {
15687pub fn CVMetalBufferGetTypeID() -> CFTypeID;
15689}
15690extern "C" {
15691pub static mut kCVMetalBufferCacheMaximumBufferAgeKey: CFStringRef;
15693}
15694#[repr(C)]
15695#[derive(Debug, Copy, Clone)]
15696pub struct __CVMetalBufferCache {
15698 _unused: [u8; 0],
15699}
15700pub type CVMetalBufferCacheRef = *mut __CVMetalBufferCache;
15702extern "C" {
15703pub fn CVMetalBufferCacheGetTypeID() -> CFTypeID;
15705}
15706extern "C" {
15707pub fn CVMetalBufferCacheCreateBufferFromImage(
15709 allocator: CFAllocatorRef,
15710 bufferCache: CVMetalBufferCacheRef,
15711 imageBuffer: CVImageBufferRef,
15712 bufferOut: *mut CVMetalBufferRef,
15713 ) -> CVReturn;
15714}
15715extern "C" {
15716pub fn CVMetalBufferCacheFlush(bufferCache: CVMetalBufferCacheRef, options: CVOptionFlags);
15718}
15719extern "C" {
15720pub static mut kCVPixelFormatName: CFStringRef;
15722}
15723extern "C" {
15724pub static mut kCVPixelFormatConstant: CFStringRef;
15726}
15727extern "C" {
15728pub static mut kCVPixelFormatCodecType: CFStringRef;
15730}
15731extern "C" {
15732pub static mut kCVPixelFormatFourCC: CFStringRef;
15734}
15735extern "C" {
15736pub static mut kCVPixelFormatContainsAlpha: CFStringRef;
15738}
15739extern "C" {
15740pub static mut kCVPixelFormatContainsYCbCr: CFStringRef;
15742}
15743extern "C" {
15744pub static mut kCVPixelFormatContainsRGB: CFStringRef;
15746}
15747extern "C" {
15748pub static mut kCVPixelFormatContainsGrayscale: CFStringRef;
15750}
15751extern "C" {
15752pub static mut kCVPixelFormatContainsSenselArray: CFStringRef;
15754}
15755extern "C" {
15756pub static mut kCVPixelFormatComponentRange: CFStringRef;
15758}
15759extern "C" {
15760pub static mut kCVPixelFormatComponentRange_VideoRange: CFStringRef;
15762}
15763extern "C" {
15764pub static mut kCVPixelFormatComponentRange_FullRange: CFStringRef;
15766}
15767extern "C" {
15768pub static mut kCVPixelFormatComponentRange_WideRange: CFStringRef;
15770}
15771extern "C" {
15772pub static mut kCVPixelFormatPlanes: CFStringRef;
15774}
15775extern "C" {
15776pub static mut kCVPixelFormatBlockWidth: CFStringRef;
15778}
15779extern "C" {
15780pub static mut kCVPixelFormatBlockHeight: CFStringRef;
15782}
15783extern "C" {
15784pub static mut kCVPixelFormatBitsPerBlock: CFStringRef;
15786}
15787extern "C" {
15788pub static mut kCVPixelFormatBitsPerComponent: CFStringRef;
15790}
15791extern "C" {
15792pub static mut kCVPixelFormatBlockHorizontalAlignment: CFStringRef;
15794}
15795extern "C" {
15796pub static mut kCVPixelFormatBlockVerticalAlignment: CFStringRef;
15798}
15799extern "C" {
15800pub static mut kCVPixelFormatBlackBlock: CFStringRef;
15802}
15803extern "C" {
15804pub static mut kCVPixelFormatHorizontalSubsampling: CFStringRef;
15806}
15807extern "C" {
15808pub static mut kCVPixelFormatVerticalSubsampling: CFStringRef;
15810}
15811extern "C" {
15812pub static mut kCVPixelFormatOpenGLFormat: CFStringRef;
15814}
15815extern "C" {
15816pub static mut kCVPixelFormatOpenGLType: CFStringRef;
15818}
15819extern "C" {
15820pub static mut kCVPixelFormatOpenGLInternalFormat: CFStringRef;
15822}
15823extern "C" {
15824pub static mut kCVPixelFormatCGBitmapInfo: CFStringRef;
15826}
15827extern "C" {
15828pub static mut kCVPixelFormatQDCompatibility: CFStringRef;
15830}
15831extern "C" {
15832pub static mut kCVPixelFormatCGBitmapContextCompatibility: CFStringRef;
15834}
15835extern "C" {
15836pub static mut kCVPixelFormatCGImageCompatibility: CFStringRef;
15838}
15839extern "C" {
15840pub static mut kCVPixelFormatOpenGLCompatibility: CFStringRef;
15842}
15843extern "C" {
15844pub static mut kCVPixelFormatOpenGLESCompatibility: CFStringRef;
15846}
15847pub type CVFillExtendedPixelsCallBack = ::core::option::Option<
15849 unsafe extern "C" fn(
15850 pixelBuffer: CVPixelBufferRef,
15851 refCon: *mut ::core::ffi::c_void,
15852 ) -> Boolean,
15853>;
15854#[repr(C)]
15855#[derive(Debug, Copy, Clone)]
15856pub struct CVFillExtendedPixelsCallBackData {
15858 pub version: CFIndex,
15859 pub fillCallBack: CVFillExtendedPixelsCallBack,
15860 pub refCon: *mut ::core::ffi::c_void,
15861}
15862extern "C" {
15863pub static mut kCVPixelFormatFillExtendedPixelsCallback: CFStringRef;
15865}
15866extern "C" {
15867pub fn CVPixelFormatDescriptionCreateWithPixelFormatType(
15869 allocator: CFAllocatorRef,
15870 pixelFormat: OSType,
15871 ) -> CFDictionaryRef;
15872}
15873extern "C" {
15874pub fn CVPixelFormatDescriptionArrayCreateWithAllPixelFormatTypes(
15876 allocator: CFAllocatorRef,
15877 ) -> CFArrayRef;
15878}
15879extern "C" {
15880pub fn CVPixelFormatDescriptionRegisterDescriptionWithPixelFormatType(
15882 description: CFDictionaryRef,
15883 pixelFormat: OSType,
15884 );
15885}
15886extern "C" {
15887pub fn CVPixelFormatTypeCopyFourCharCodeString(pixelFormat: OSType) -> CFStringRef;
15889}
15890extern "C" {
15891pub fn CVIsCompressedPixelFormatAvailable(pixelFormatType: OSType) -> Boolean;
15893}
15894pub const kCMFormatDescriptionError_InvalidParameter: _bindgen_ty_1677 = -12710;
15896pub const kCMFormatDescriptionError_AllocationFailed: _bindgen_ty_1677 = -12711;
15898pub const kCMFormatDescriptionError_ValueNotAvailable: _bindgen_ty_1677 = -12718;
15900pub type _bindgen_ty_1677 = ::core::ffi::c_int;
15902#[repr(C)]
15903#[derive(Debug, Copy, Clone)]
15904pub struct opaqueCMFormatDescription {
15906 _unused: [u8; 0],
15907}
15908pub type CMFormatDescriptionRef = *const opaqueCMFormatDescription;
15910pub type CMMediaType = FourCharCode;
15912pub const kCMMediaType_Video: _bindgen_ty_1678 = 1986618469;
15914pub const kCMMediaType_Audio: _bindgen_ty_1678 = 1936684398;
15916pub const kCMMediaType_Muxed: _bindgen_ty_1678 = 1836415096;
15918pub const kCMMediaType_Text: _bindgen_ty_1678 = 1952807028;
15920pub const kCMMediaType_ClosedCaption: _bindgen_ty_1678 = 1668047728;
15922pub const kCMMediaType_Subtitle: _bindgen_ty_1678 = 1935832172;
15924pub const kCMMediaType_TimeCode: _bindgen_ty_1678 = 1953325924;
15926pub const kCMMediaType_Metadata: _bindgen_ty_1678 = 1835365473;
15928pub const kCMMediaType_TaggedBufferGroup: _bindgen_ty_1678 = 1952606066;
15930pub type _bindgen_ty_1678 = ::core::ffi::c_uint;
15932pub const kCMMediaType_AuxiliaryPicture: _bindgen_ty_1679 = 1635088502;
15934pub type _bindgen_ty_1679 = ::core::ffi::c_uint;
15936extern "C" {
15937pub fn CMFormatDescriptionCreate(
15939 allocator: CFAllocatorRef,
15940 mediaType: CMMediaType,
15941 mediaSubType: FourCharCode,
15942 extensions: CFDictionaryRef,
15943 formatDescriptionOut: *mut CMFormatDescriptionRef,
15944 ) -> OSStatus;
15945}
15946extern "C" {
15947pub fn CMFormatDescriptionGetTypeID() -> CFTypeID;
15949}
15950extern "C" {
15951pub fn CMFormatDescriptionEqual(
15953 formatDescription: CMFormatDescriptionRef,
15954 otherFormatDescription: CMFormatDescriptionRef,
15955 ) -> Boolean;
15956}
15957extern "C" {
15958pub fn CMFormatDescriptionEqualIgnoringExtensionKeys(
15960 formatDescription: CMFormatDescriptionRef,
15961 otherFormatDescription: CMFormatDescriptionRef,
15962 formatDescriptionExtensionKeysToIgnore: CFTypeRef,
15963 sampleDescriptionExtensionAtomKeysToIgnore: CFTypeRef,
15964 ) -> Boolean;
15965}
15966extern "C" {
15967pub fn CMFormatDescriptionGetMediaType(desc: CMFormatDescriptionRef) -> CMMediaType;
15969}
15970extern "C" {
15971pub fn CMFormatDescriptionGetMediaSubType(desc: CMFormatDescriptionRef) -> FourCharCode;
15973}
15974extern "C" {
15975pub fn CMFormatDescriptionGetExtensions(desc: CMFormatDescriptionRef) -> CFDictionaryRef;
15977}
15978extern "C" {
15979pub static kCMFormatDescriptionExtension_OriginalCompressionSettings: CFStringRef;
15981}
15982extern "C" {
15983pub static kCMFormatDescriptionExtension_SampleDescriptionExtensionAtoms: CFStringRef;
15985}
15986extern "C" {
15987pub static kCMFormatDescriptionExtension_VerbatimSampleDescription: CFStringRef;
15989}
15990extern "C" {
15991pub static kCMFormatDescriptionExtension_VerbatimISOSampleEntry: CFStringRef;
15993}
15994extern "C" {
15995pub fn CMFormatDescriptionGetExtension(
15997 desc: CMFormatDescriptionRef,
15998 extensionKey: CFStringRef,
15999 ) -> CFPropertyListRef;
16000}
16001pub type CMAudioCodecType = FourCharCode;
16003pub const kCMAudioCodecType_AAC_LCProtected: _bindgen_ty_1680 = 1885430115;
16005pub const kCMAudioCodecType_AAC_AudibleProtected: _bindgen_ty_1680 = 1633771875;
16007pub type _bindgen_ty_1680 = ::core::ffi::c_uint;
16009pub type CMAudioFormatDescriptionRef = CMFormatDescriptionRef;
16011extern "C" {
16012pub fn CMAudioFormatDescriptionCreate(
16014 allocator: CFAllocatorRef,
16015 asbd: *const AudioStreamBasicDescription,
16016 layoutSize: usize,
16017 layout: *const AudioChannelLayout,
16018 magicCookieSize: usize,
16019 magicCookie: *const ::core::ffi::c_void,
16020 extensions: CFDictionaryRef,
16021 formatDescriptionOut: *mut CMAudioFormatDescriptionRef,
16022 ) -> OSStatus;
16023}
16024extern "C" {
16025pub fn CMAudioFormatDescriptionGetStreamBasicDescription(
16027 desc: CMAudioFormatDescriptionRef,
16028 ) -> *const AudioStreamBasicDescription;
16029}
16030extern "C" {
16031pub fn CMAudioFormatDescriptionGetMagicCookie(
16033 desc: CMAudioFormatDescriptionRef,
16034 sizeOut: *mut usize,
16035 ) -> *const ::core::ffi::c_void;
16036}
16037extern "C" {
16038pub fn CMAudioFormatDescriptionGetChannelLayout(
16040 desc: CMAudioFormatDescriptionRef,
16041 sizeOut: *mut usize,
16042 ) -> *const AudioChannelLayout;
16043}
16044extern "C" {
16045pub fn CMAudioFormatDescriptionGetFormatList(
16047 desc: CMAudioFormatDescriptionRef,
16048 sizeOut: *mut usize,
16049 ) -> *const AudioFormatListItem;
16050}
16051extern "C" {
16052pub fn CMAudioFormatDescriptionGetRichestDecodableFormat(
16054 desc: CMAudioFormatDescriptionRef,
16055 ) -> *const AudioFormatListItem;
16056}
16057extern "C" {
16058pub fn CMAudioFormatDescriptionGetMostCompatibleFormat(
16060 desc: CMAudioFormatDescriptionRef,
16061 ) -> *const AudioFormatListItem;
16062}
16063extern "C" {
16064pub fn CMAudioFormatDescriptionCreateSummary(
16066 allocator: CFAllocatorRef,
16067 formatDescriptionArray: CFArrayRef,
16068 flags: u32,
16069 formatDescriptionOut: *mut CMAudioFormatDescriptionRef,
16070 ) -> OSStatus;
16071}
16072pub type CMAudioFormatDescriptionMask = u32;
16074pub const kCMAudioFormatDescriptionMask_StreamBasicDescription: _bindgen_ty_1681 = 1;
16076pub const kCMAudioFormatDescriptionMask_MagicCookie: _bindgen_ty_1681 = 2;
16078pub const kCMAudioFormatDescriptionMask_ChannelLayout: _bindgen_ty_1681 = 4;
16080pub const kCMAudioFormatDescriptionMask_Extensions: _bindgen_ty_1681 = 8;
16082pub const kCMAudioFormatDescriptionMask_All: _bindgen_ty_1681 = 15;
16084pub type _bindgen_ty_1681 = ::core::ffi::c_uint;
16086extern "C" {
16087pub fn CMAudioFormatDescriptionEqual(
16089 formatDescription: CMAudioFormatDescriptionRef,
16090 otherFormatDescription: CMAudioFormatDescriptionRef,
16091 equalityMask: CMAudioFormatDescriptionMask,
16092 equalityMaskOut: *mut CMAudioFormatDescriptionMask,
16093 ) -> Boolean;
16094}
16095pub type CMVideoFormatDescriptionRef = CMFormatDescriptionRef;
16097pub type CMPixelFormatType = FourCharCode;
16099pub const kCMPixelFormat_32ARGB: _bindgen_ty_1682 = 32;
16101pub const kCMPixelFormat_32BGRA: _bindgen_ty_1682 = 1111970369;
16103pub const kCMPixelFormat_24RGB: _bindgen_ty_1682 = 24;
16105pub const kCMPixelFormat_16BE555: _bindgen_ty_1682 = 16;
16107pub const kCMPixelFormat_16BE565: _bindgen_ty_1682 = 1110783541;
16109pub const kCMPixelFormat_16LE555: _bindgen_ty_1682 = 1278555445;
16111pub const kCMPixelFormat_16LE565: _bindgen_ty_1682 = 1278555701;
16113pub const kCMPixelFormat_16LE5551: _bindgen_ty_1682 = 892679473;
16115pub const kCMPixelFormat_422YpCbCr8: _bindgen_ty_1682 = 846624121;
16117pub const kCMPixelFormat_422YpCbCr8_yuvs: _bindgen_ty_1682 = 2037741171;
16119pub const kCMPixelFormat_444YpCbCr8: _bindgen_ty_1682 = 1983066168;
16121pub const kCMPixelFormat_4444YpCbCrA8: _bindgen_ty_1682 = 1983131704;
16123pub const kCMPixelFormat_422YpCbCr16: _bindgen_ty_1682 = 1983000886;
16125pub const kCMPixelFormat_422YpCbCr10: _bindgen_ty_1682 = 1983000880;
16127pub const kCMPixelFormat_444YpCbCr10: _bindgen_ty_1682 = 1983131952;
16129pub const kCMPixelFormat_8IndexedGray_WhiteIsZero: _bindgen_ty_1682 = 40;
16131pub type _bindgen_ty_1682 = ::core::ffi::c_uint;
16133pub type CMVideoCodecType = FourCharCode;
16135pub const kCMVideoCodecType_422YpCbCr8: _bindgen_ty_1683 = 846624121;
16137pub const kCMVideoCodecType_Animation: _bindgen_ty_1683 = 1919706400;
16139pub const kCMVideoCodecType_Cinepak: _bindgen_ty_1683 = 1668704612;
16141pub const kCMVideoCodecType_JPEG: _bindgen_ty_1683 = 1785750887;
16143pub const kCMVideoCodecType_JPEG_OpenDML: _bindgen_ty_1683 = 1684890161;
16145pub const kCMVideoCodecType_JPEG_XL: _bindgen_ty_1683 = 1786276963;
16147pub const kCMVideoCodecType_SorensonVideo: _bindgen_ty_1683 = 1398165809;
16149pub const kCMVideoCodecType_SorensonVideo3: _bindgen_ty_1683 = 1398165811;
16151pub const kCMVideoCodecType_H263: _bindgen_ty_1683 = 1748121139;
16153pub const kCMVideoCodecType_H264: _bindgen_ty_1683 = 1635148593;
16155pub const kCMVideoCodecType_HEVC: _bindgen_ty_1683 = 1752589105;
16157pub const kCMVideoCodecType_HEVCWithAlpha: _bindgen_ty_1683 = 1836415073;
16159pub const kCMVideoCodecType_DolbyVisionHEVC: _bindgen_ty_1683 = 1685481521;
16161pub const kCMVideoCodecType_MPEG4Video: _bindgen_ty_1683 = 1836070006;
16163pub const kCMVideoCodecType_MPEG2Video: _bindgen_ty_1683 = 1836069494;
16165pub const kCMVideoCodecType_MPEG1Video: _bindgen_ty_1683 = 1836069238;
16167pub const kCMVideoCodecType_VP9: _bindgen_ty_1683 = 1987063865;
16169pub const kCMVideoCodecType_DVCNTSC: _bindgen_ty_1683 = 1685480224;
16171pub const kCMVideoCodecType_DVCPAL: _bindgen_ty_1683 = 1685480304;
16173pub const kCMVideoCodecType_DVCProPAL: _bindgen_ty_1683 = 1685483632;
16175pub const kCMVideoCodecType_DVCPro50NTSC: _bindgen_ty_1683 = 1685468526;
16177pub const kCMVideoCodecType_DVCPro50PAL: _bindgen_ty_1683 = 1685468528;
16179pub const kCMVideoCodecType_DVCPROHD720p60: _bindgen_ty_1683 = 1685481584;
16181pub const kCMVideoCodecType_DVCPROHD720p50: _bindgen_ty_1683 = 1685481585;
16183pub const kCMVideoCodecType_DVCPROHD1080i60: _bindgen_ty_1683 = 1685481526;
16185pub const kCMVideoCodecType_DVCPROHD1080i50: _bindgen_ty_1683 = 1685481525;
16187pub const kCMVideoCodecType_DVCPROHD1080p30: _bindgen_ty_1683 = 1685481523;
16189pub const kCMVideoCodecType_DVCPROHD1080p25: _bindgen_ty_1683 = 1685481522;
16191pub const kCMVideoCodecType_AppleProRes4444XQ: _bindgen_ty_1683 = 1634743416;
16193pub const kCMVideoCodecType_AppleProRes4444: _bindgen_ty_1683 = 1634743400;
16195pub const kCMVideoCodecType_AppleProRes422HQ: _bindgen_ty_1683 = 1634755432;
16197pub const kCMVideoCodecType_AppleProRes422: _bindgen_ty_1683 = 1634755438;
16199pub const kCMVideoCodecType_AppleProRes422LT: _bindgen_ty_1683 = 1634755443;
16201pub const kCMVideoCodecType_AppleProRes422Proxy: _bindgen_ty_1683 = 1634755439;
16203pub const kCMVideoCodecType_AppleProResRAW: _bindgen_ty_1683 = 1634759278;
16205pub const kCMVideoCodecType_AppleProResRAWHQ: _bindgen_ty_1683 = 1634759272;
16207pub const kCMVideoCodecType_DisparityHEVC: _bindgen_ty_1683 = 1684632424;
16209pub const kCMVideoCodecType_DepthHEVC: _bindgen_ty_1683 = 1684369512;
16211pub const kCMVideoCodecType_AV1: _bindgen_ty_1683 = 1635135537;
16213pub type _bindgen_ty_1683 = ::core::ffi::c_uint;
16215#[repr(C)]
16216#[derive(Debug, Copy, Clone)]
16217pub struct CMVideoDimensions {
16219 pub width: i32,
16220 pub height: i32,
16221}
16222extern "C" {
16223pub static kCMFormatDescriptionExtension_FormatName: CFStringRef;
16225}
16226extern "C" {
16227pub static kCMFormatDescriptionExtension_Depth: CFStringRef;
16229}
16230extern "C" {
16231pub static kCMFormatDescriptionExtension_CleanAperture: CFStringRef;
16233}
16234extern "C" {
16235pub static kCMFormatDescriptionKey_CleanApertureWidth: CFStringRef;
16237}
16238extern "C" {
16239pub static kCMFormatDescriptionKey_CleanApertureHeight: CFStringRef;
16241}
16242extern "C" {
16243pub static kCMFormatDescriptionKey_CleanApertureHorizontalOffset: CFStringRef;
16245}
16246extern "C" {
16247pub static kCMFormatDescriptionKey_CleanApertureVerticalOffset: CFStringRef;
16249}
16250extern "C" {
16251pub static kCMFormatDescriptionKey_CleanApertureWidthRational: CFStringRef;
16253}
16254extern "C" {
16255pub static kCMFormatDescriptionKey_CleanApertureHeightRational: CFStringRef;
16257}
16258extern "C" {
16259pub static kCMFormatDescriptionKey_CleanApertureHorizontalOffsetRational: CFStringRef;
16261}
16262extern "C" {
16263pub static kCMFormatDescriptionKey_CleanApertureVerticalOffsetRational: CFStringRef;
16265}
16266extern "C" {
16267pub static kCMFormatDescriptionExtension_FieldCount: CFStringRef;
16269}
16270extern "C" {
16271pub static kCMFormatDescriptionExtension_FieldDetail: CFStringRef;
16273}
16274extern "C" {
16275pub static kCMFormatDescriptionFieldDetail_TemporalTopFirst: CFStringRef;
16277}
16278extern "C" {
16279pub static kCMFormatDescriptionFieldDetail_TemporalBottomFirst: CFStringRef;
16281}
16282extern "C" {
16283pub static kCMFormatDescriptionFieldDetail_SpatialFirstLineEarly: CFStringRef;
16285}
16286extern "C" {
16287pub static kCMFormatDescriptionFieldDetail_SpatialFirstLineLate: CFStringRef;
16289}
16290extern "C" {
16291pub static kCMFormatDescriptionExtension_PixelAspectRatio: CFStringRef;
16293}
16294extern "C" {
16295pub static kCMFormatDescriptionKey_PixelAspectRatioHorizontalSpacing: CFStringRef;
16297}
16298extern "C" {
16299pub static kCMFormatDescriptionKey_PixelAspectRatioVerticalSpacing: CFStringRef;
16301}
16302extern "C" {
16303pub static kCMFormatDescriptionExtension_ColorPrimaries: CFStringRef;
16305}
16306extern "C" {
16307pub static kCMFormatDescriptionColorPrimaries_ITU_R_709_2: CFStringRef;
16309}
16310extern "C" {
16311pub static kCMFormatDescriptionColorPrimaries_EBU_3213: CFStringRef;
16313}
16314extern "C" {
16315pub static kCMFormatDescriptionColorPrimaries_SMPTE_C: CFStringRef;
16317}
16318extern "C" {
16319pub static kCMFormatDescriptionColorPrimaries_DCI_P3: CFStringRef;
16321}
16322extern "C" {
16323pub static kCMFormatDescriptionColorPrimaries_P3_D65: CFStringRef;
16325}
16326extern "C" {
16327pub static kCMFormatDescriptionColorPrimaries_ITU_R_2020: CFStringRef;
16329}
16330extern "C" {
16331pub static kCMFormatDescriptionColorPrimaries_P22: CFStringRef;
16333}
16334extern "C" {
16335pub static kCMFormatDescriptionExtension_TransferFunction: CFStringRef;
16337}
16338extern "C" {
16339pub static kCMFormatDescriptionTransferFunction_ITU_R_709_2: CFStringRef;
16341}
16342extern "C" {
16343pub static kCMFormatDescriptionTransferFunction_SMPTE_240M_1995: CFStringRef;
16345}
16346extern "C" {
16347pub static kCMFormatDescriptionTransferFunction_UseGamma: CFStringRef;
16349}
16350extern "C" {
16351pub static kCMFormatDescriptionTransferFunction_ITU_R_2020: CFStringRef;
16353}
16354extern "C" {
16355pub static kCMFormatDescriptionTransferFunction_SMPTE_ST_428_1: CFStringRef;
16357}
16358extern "C" {
16359pub static kCMFormatDescriptionTransferFunction_SMPTE_ST_2084_PQ: CFStringRef;
16361}
16362extern "C" {
16363pub static kCMFormatDescriptionTransferFunction_ITU_R_2100_HLG: CFStringRef;
16365}
16366extern "C" {
16367pub static kCMFormatDescriptionTransferFunction_Linear: CFStringRef;
16369}
16370extern "C" {
16371pub static kCMFormatDescriptionTransferFunction_sRGB: CFStringRef;
16373}
16374extern "C" {
16375pub static kCMFormatDescriptionExtension_GammaLevel: CFStringRef;
16377}
16378extern "C" {
16379pub static kCMFormatDescriptionExtension_YCbCrMatrix: CFStringRef;
16381}
16382extern "C" {
16383pub static kCMFormatDescriptionYCbCrMatrix_ITU_R_709_2: CFStringRef;
16385}
16386extern "C" {
16387pub static kCMFormatDescriptionYCbCrMatrix_ITU_R_601_4: CFStringRef;
16389}
16390extern "C" {
16391pub static kCMFormatDescriptionYCbCrMatrix_SMPTE_240M_1995: CFStringRef;
16393}
16394extern "C" {
16395pub static kCMFormatDescriptionYCbCrMatrix_ITU_R_2020: CFStringRef;
16397}
16398extern "C" {
16399pub static kCMFormatDescriptionExtension_FullRangeVideo: CFStringRef;
16401}
16402extern "C" {
16403pub static kCMFormatDescriptionExtension_ICCProfile: CFStringRef;
16405}
16406extern "C" {
16407pub static kCMFormatDescriptionExtension_BytesPerRow: CFStringRef;
16409}
16410extern "C" {
16411pub static kCMFormatDescriptionExtension_ChromaLocationTopField: CFStringRef;
16413}
16414extern "C" {
16415pub static kCMFormatDescriptionExtension_ChromaLocationBottomField: CFStringRef;
16417}
16418extern "C" {
16419pub static kCMFormatDescriptionChromaLocation_Left: CFStringRef;
16421}
16422extern "C" {
16423pub static kCMFormatDescriptionChromaLocation_Center: CFStringRef;
16425}
16426extern "C" {
16427pub static kCMFormatDescriptionChromaLocation_TopLeft: CFStringRef;
16429}
16430extern "C" {
16431pub static kCMFormatDescriptionChromaLocation_Top: CFStringRef;
16433}
16434extern "C" {
16435pub static kCMFormatDescriptionChromaLocation_BottomLeft: CFStringRef;
16437}
16438extern "C" {
16439pub static kCMFormatDescriptionChromaLocation_Bottom: CFStringRef;
16441}
16442extern "C" {
16443pub static kCMFormatDescriptionChromaLocation_DV420: CFStringRef;
16445}
16446extern "C" {
16447pub static kCMFormatDescriptionConformsToMPEG2VideoProfile: CFStringRef;
16449}
16450extern "C" {
16451pub static kCMFormatDescriptionExtension_ProtectedContentOriginalFormat: CFStringRef;
16453}
16454pub const kCMMPEG2VideoProfile_HDV_720p30: _bindgen_ty_1684 = 1751414321;
16456pub const kCMMPEG2VideoProfile_HDV_1080i60: _bindgen_ty_1684 = 1751414322;
16458pub const kCMMPEG2VideoProfile_HDV_1080i50: _bindgen_ty_1684 = 1751414323;
16460pub const kCMMPEG2VideoProfile_HDV_720p24: _bindgen_ty_1684 = 1751414324;
16462pub const kCMMPEG2VideoProfile_HDV_720p25: _bindgen_ty_1684 = 1751414325;
16464pub const kCMMPEG2VideoProfile_HDV_1080p24: _bindgen_ty_1684 = 1751414326;
16466pub const kCMMPEG2VideoProfile_HDV_1080p25: _bindgen_ty_1684 = 1751414327;
16468pub const kCMMPEG2VideoProfile_HDV_1080p30: _bindgen_ty_1684 = 1751414328;
16470pub const kCMMPEG2VideoProfile_HDV_720p60: _bindgen_ty_1684 = 1751414329;
16472pub const kCMMPEG2VideoProfile_HDV_720p50: _bindgen_ty_1684 = 1751414369;
16474pub const kCMMPEG2VideoProfile_XDCAM_HD_1080i60_VBR35: _bindgen_ty_1684 = 2019849778;
16476pub const kCMMPEG2VideoProfile_XDCAM_HD_1080i50_VBR35: _bindgen_ty_1684 = 2019849779;
16478pub const kCMMPEG2VideoProfile_XDCAM_HD_1080p24_VBR35: _bindgen_ty_1684 = 2019849782;
16480pub const kCMMPEG2VideoProfile_XDCAM_HD_1080p25_VBR35: _bindgen_ty_1684 = 2019849783;
16482pub const kCMMPEG2VideoProfile_XDCAM_HD_1080p30_VBR35: _bindgen_ty_1684 = 2019849784;
16484pub const kCMMPEG2VideoProfile_XDCAM_EX_720p24_VBR35: _bindgen_ty_1684 = 2019849780;
16486pub const kCMMPEG2VideoProfile_XDCAM_EX_720p25_VBR35: _bindgen_ty_1684 = 2019849781;
16488pub const kCMMPEG2VideoProfile_XDCAM_EX_720p30_VBR35: _bindgen_ty_1684 = 2019849777;
16490pub const kCMMPEG2VideoProfile_XDCAM_EX_720p50_VBR35: _bindgen_ty_1684 = 2019849825;
16492pub const kCMMPEG2VideoProfile_XDCAM_EX_720p60_VBR35: _bindgen_ty_1684 = 2019849785;
16494pub const kCMMPEG2VideoProfile_XDCAM_EX_1080i60_VBR35: _bindgen_ty_1684 = 2019849826;
16496pub const kCMMPEG2VideoProfile_XDCAM_EX_1080i50_VBR35: _bindgen_ty_1684 = 2019849827;
16498pub const kCMMPEG2VideoProfile_XDCAM_EX_1080p24_VBR35: _bindgen_ty_1684 = 2019849828;
16500pub const kCMMPEG2VideoProfile_XDCAM_EX_1080p25_VBR35: _bindgen_ty_1684 = 2019849829;
16502pub const kCMMPEG2VideoProfile_XDCAM_EX_1080p30_VBR35: _bindgen_ty_1684 = 2019849830;
16504pub const kCMMPEG2VideoProfile_XDCAM_HD422_720p50_CBR50: _bindgen_ty_1684 = 2019833185;
16506pub const kCMMPEG2VideoProfile_XDCAM_HD422_720p60_CBR50: _bindgen_ty_1684 = 2019833145;
16508pub const kCMMPEG2VideoProfile_XDCAM_HD422_1080i60_CBR50: _bindgen_ty_1684 = 2019833186;
16510pub const kCMMPEG2VideoProfile_XDCAM_HD422_1080i50_CBR50: _bindgen_ty_1684 = 2019833187;
16512pub const kCMMPEG2VideoProfile_XDCAM_HD422_1080p24_CBR50: _bindgen_ty_1684 = 2019833188;
16514pub const kCMMPEG2VideoProfile_XDCAM_HD422_1080p25_CBR50: _bindgen_ty_1684 = 2019833189;
16516pub const kCMMPEG2VideoProfile_XDCAM_HD422_1080p30_CBR50: _bindgen_ty_1684 = 2019833190;
16518pub const kCMMPEG2VideoProfile_XDCAM_HD_540p: _bindgen_ty_1684 = 2019846244;
16520pub const kCMMPEG2VideoProfile_XDCAM_HD422_540p: _bindgen_ty_1684 = 2019846194;
16522pub const kCMMPEG2VideoProfile_XDCAM_HD422_720p24_CBR50: _bindgen_ty_1684 = 2019833140;
16524pub const kCMMPEG2VideoProfile_XDCAM_HD422_720p25_CBR50: _bindgen_ty_1684 = 2019833141;
16526pub const kCMMPEG2VideoProfile_XDCAM_HD422_720p30_CBR50: _bindgen_ty_1684 = 2019833137;
16528pub const kCMMPEG2VideoProfile_XF: _bindgen_ty_1684 = 2019981873;
16530pub type _bindgen_ty_1684 = ::core::ffi::c_uint;
16532extern "C" {
16533pub static kCMFormatDescriptionExtension_TemporalQuality: CFStringRef;
16535}
16536extern "C" {
16537pub static kCMFormatDescriptionExtension_SpatialQuality: CFStringRef;
16539}
16540extern "C" {
16541pub static kCMFormatDescriptionExtension_VerbatimImageDescription: CFStringRef;
16543}
16544extern "C" {
16545pub static kCMFormatDescriptionExtension_Version: CFStringRef;
16547}
16548extern "C" {
16549pub static kCMFormatDescriptionExtension_RevisionLevel: CFStringRef;
16551}
16552extern "C" {
16553pub static kCMFormatDescriptionExtension_Vendor: CFStringRef;
16555}
16556extern "C" {
16557pub static kCMFormatDescriptionVendor_Apple: CFStringRef;
16559}
16560extern "C" {
16561pub static kCMFormatDescriptionExtension_MasteringDisplayColorVolume: CFStringRef;
16563}
16564extern "C" {
16565pub static kCMFormatDescriptionExtension_ContentLightLevelInfo: CFStringRef;
16567}
16568extern "C" {
16569pub static kCMFormatDescriptionExtension_ContentColorVolume: CFStringRef;
16571}
16572extern "C" {
16573pub static kCMFormatDescriptionExtension_AlternativeTransferCharacteristics: CFStringRef;
16575}
16576extern "C" {
16577pub static kCMFormatDescriptionExtension_AuxiliaryTypeInfo: CFStringRef;
16579}
16580extern "C" {
16581pub static kCMFormatDescriptionExtension_AlphaChannelMode: CFStringRef;
16583}
16584extern "C" {
16585pub static kCMFormatDescriptionAlphaChannelMode_StraightAlpha: CFStringRef;
16587}
16588extern "C" {
16589pub static kCMFormatDescriptionAlphaChannelMode_PremultipliedAlpha: CFStringRef;
16591}
16592extern "C" {
16593pub static kCMFormatDescriptionExtension_ContainsAlphaChannel: CFStringRef;
16595}
16596extern "C" {
16597pub static kCMFormatDescriptionExtension_BitsPerComponent: CFStringRef;
16599}
16600extern "C" {
16601pub static kCMFormatDescriptionExtension_HorizontalFieldOfView: CFStringRef;
16603}
16604extern "C" {
16605pub static kCMFormatDescriptionExtension_LogTransferFunction: CFStringRef;
16607}
16608extern "C" {
16609pub static kCMFormatDescriptionLogTransferFunction_AppleLog: CFStringRef;
16611}
16612extern "C" {
16613pub static kCMFormatDescriptionExtension_HeroEye: CFStringRef;
16615}
16616extern "C" {
16617pub static kCMFormatDescriptionHeroEye_Left: CFStringRef;
16619}
16620extern "C" {
16621pub static kCMFormatDescriptionHeroEye_Right: CFStringRef;
16623}
16624extern "C" {
16625pub static kCMFormatDescriptionExtension_StereoCameraBaseline: CFStringRef;
16627}
16628extern "C" {
16629pub static kCMFormatDescriptionExtension_HorizontalDisparityAdjustment: CFStringRef;
16631}
16632extern "C" {
16633pub static kCMFormatDescriptionExtension_HasLeftStereoEyeView: CFStringRef;
16635}
16636extern "C" {
16637pub static kCMFormatDescriptionExtension_HasRightStereoEyeView: CFStringRef;
16639}
16640extern "C" {
16641pub static kCMFormatDescriptionExtension_HasAdditionalViews: CFStringRef;
16643}
16644extern "C" {
16645pub static kCMFormatDescriptionExtension_ProjectionKind: CFStringRef;
16647}
16648extern "C" {
16649pub static kCMFormatDescriptionProjectionKind_Rectilinear: CFStringRef;
16651}
16652extern "C" {
16653pub static kCMFormatDescriptionProjectionKind_Equirectangular: CFStringRef;
16655}
16656extern "C" {
16657pub static kCMFormatDescriptionProjectionKind_HalfEquirectangular: CFStringRef;
16659}
16660extern "C" {
16661pub static kCMFormatDescriptionProjectionKind_ParametricImmersive: CFStringRef;
16663}
16664extern "C" {
16665pub static kCMFormatDescriptionProjectionKind_AppleImmersiveVideo: CFStringRef;
16667}
16668extern "C" {
16669pub static kCMFormatDescriptionExtension_ViewPackingKind: CFStringRef;
16671}
16672extern "C" {
16673pub static kCMFormatDescriptionViewPackingKind_SideBySide: CFStringRef;
16675}
16676extern "C" {
16677pub static kCMFormatDescriptionViewPackingKind_OverUnder: CFStringRef;
16679}
16680extern "C" {
16681pub static kCMFormatDescriptionExtension_CameraCalibrationDataLensCollection: CFStringRef;
16683}
16684extern "C" {
16685pub static kCMFormatDescriptionCameraCalibration_LensAlgorithmKind: CFStringRef;
16687}
16688extern "C" {
16689pub static kCMFormatDescriptionCameraCalibrationLensAlgorithmKind_ParametricLens: CFStringRef;
16691}
16692extern "C" {
16693pub static kCMFormatDescriptionCameraCalibration_LensDomain: CFStringRef;
16695}
16696extern "C" {
16697pub static kCMFormatDescriptionCameraCalibrationLensDomain_Color: CFStringRef;
16699}
16700extern "C" {
16701pub static kCMFormatDescriptionCameraCalibration_LensIdentifier: CFStringRef;
16703}
16704extern "C" {
16705pub static kCMFormatDescriptionCameraCalibration_LensRole: CFStringRef;
16707}
16708extern "C" {
16709pub static kCMFormatDescriptionCameraCalibrationLensRole_Mono: CFStringRef;
16711}
16712extern "C" {
16713pub static kCMFormatDescriptionCameraCalibrationLensRole_Left: CFStringRef;
16715}
16716extern "C" {
16717pub static kCMFormatDescriptionCameraCalibrationLensRole_Right: CFStringRef;
16719}
16720extern "C" {
16721pub static kCMFormatDescriptionCameraCalibration_LensDistortions: CFStringRef;
16723}
16724extern "C" {
16725pub static kCMFormatDescriptionCameraCalibration_LensFrameAdjustmentsPolynomialX: CFStringRef;
16727}
16728extern "C" {
16729pub static kCMFormatDescriptionCameraCalibration_LensFrameAdjustmentsPolynomialY: CFStringRef;
16731}
16732extern "C" {
16733pub static kCMFormatDescriptionCameraCalibration_RadialAngleLimit: CFStringRef;
16735}
16736extern "C" {
16737pub static kCMFormatDescriptionCameraCalibration_IntrinsicMatrix: CFStringRef;
16739}
16740extern "C" {
16741pub static kCMFormatDescriptionCameraCalibration_IntrinsicMatrixProjectionOffset: CFStringRef;
16743}
16744extern "C" {
16745pub static kCMFormatDescriptionCameraCalibration_IntrinsicMatrixReferenceDimensions:
16747 CFStringRef;
16748}
16749extern "C" {
16750pub static kCMFormatDescriptionCameraCalibration_ExtrinsicOriginSource: CFStringRef;
16752}
16753extern "C" {
16754pub static kCMFormatDescriptionCameraCalibrationExtrinsicOriginSource_StereoCameraSystemBaseline:
16756 CFStringRef;
16757}
16758extern "C" {
16759pub static kCMFormatDescriptionCameraCalibration_ExtrinsicOrientationQuaternion: CFStringRef;
16761}
16762extern "C" {
16763pub static kCMFormatDescriptionExtension_ConvertedFromExternalSphericalTags: CFStringRef;
16765}
16766extern "C" {
16767pub fn CMVideoFormatDescriptionCreate(
16769 allocator: CFAllocatorRef,
16770 codecType: CMVideoCodecType,
16771 width: i32,
16772 height: i32,
16773 extensions: CFDictionaryRef,
16774 formatDescriptionOut: *mut CMVideoFormatDescriptionRef,
16775 ) -> OSStatus;
16776}
16777extern "C" {
16778pub fn CMVideoFormatDescriptionCreateForImageBuffer(
16780 allocator: CFAllocatorRef,
16781 imageBuffer: CVImageBufferRef,
16782 formatDescriptionOut: *mut CMVideoFormatDescriptionRef,
16783 ) -> OSStatus;
16784}
16785extern "C" {
16786pub fn CMVideoFormatDescriptionCreateFromH264ParameterSets(
16788 allocator: CFAllocatorRef,
16789 parameterSetCount: usize,
16790 parameterSetPointers: *const *const u8,
16791 parameterSetSizes: *const usize,
16792 NALUnitHeaderLength: ::core::ffi::c_int,
16793 formatDescriptionOut: *mut CMFormatDescriptionRef,
16794 ) -> OSStatus;
16795}
16796extern "C" {
16797pub fn CMVideoFormatDescriptionCreateFromHEVCParameterSets(
16799 allocator: CFAllocatorRef,
16800 parameterSetCount: usize,
16801 parameterSetPointers: *const *const u8,
16802 parameterSetSizes: *const usize,
16803 NALUnitHeaderLength: ::core::ffi::c_int,
16804 extensions: CFDictionaryRef,
16805 formatDescriptionOut: *mut CMFormatDescriptionRef,
16806 ) -> OSStatus;
16807}
16808extern "C" {
16809pub fn CMVideoFormatDescriptionGetH264ParameterSetAtIndex(
16811 videoDesc: CMFormatDescriptionRef,
16812 parameterSetIndex: usize,
16813 parameterSetPointerOut: *mut *const u8,
16814 parameterSetSizeOut: *mut usize,
16815 parameterSetCountOut: *mut usize,
16816 NALUnitHeaderLengthOut: *mut ::core::ffi::c_int,
16817 ) -> OSStatus;
16818}
16819extern "C" {
16820pub fn CMVideoFormatDescriptionGetHEVCParameterSetAtIndex(
16822 videoDesc: CMFormatDescriptionRef,
16823 parameterSetIndex: usize,
16824 parameterSetPointerOut: *mut *const u8,
16825 parameterSetSizeOut: *mut usize,
16826 parameterSetCountOut: *mut usize,
16827 NALUnitHeaderLengthOut: *mut ::core::ffi::c_int,
16828 ) -> OSStatus;
16829}
16830extern "C" {
16831pub fn CMVideoFormatDescriptionGetDimensions(
16833 videoDesc: CMVideoFormatDescriptionRef,
16834 ) -> CMVideoDimensions;
16835}
16836extern "C" {
16837pub fn CMVideoFormatDescriptionGetPresentationDimensions(
16839 videoDesc: CMVideoFormatDescriptionRef,
16840 usePixelAspectRatio: Boolean,
16841 useCleanAperture: Boolean,
16842 ) -> CGSize;
16843}
16844extern "C" {
16845pub fn CMVideoFormatDescriptionGetCleanAperture(
16847 videoDesc: CMVideoFormatDescriptionRef,
16848 originIsAtTopLeft: Boolean,
16849 ) -> CGRect;
16850}
16851extern "C" {
16852pub fn CMVideoFormatDescriptionGetExtensionKeysCommonWithImageBuffers() -> CFArrayRef;
16854}
16855extern "C" {
16856pub fn CMVideoFormatDescriptionMatchesImageBuffer(
16858 desc: CMVideoFormatDescriptionRef,
16859 imageBuffer: CVImageBufferRef,
16860 ) -> Boolean;
16861}
16862extern "C" {
16863pub fn CMVideoFormatDescriptionCopyTagCollectionArray(
16865 formatDescription: CMVideoFormatDescriptionRef,
16866 tagCollectionsOut: *mut CFArrayRef,
16867 ) -> OSStatus;
16868}
16869pub type CMTaggedBufferGroupFormatDescriptionRef = CMFormatDescriptionRef;
16871pub type CMTaggedBufferGroupFormatType = FourCharCode;
16873pub const kCMTaggedBufferGroupFormatType_TaggedBufferGroup: _bindgen_ty_1685 = 1952606066;
16875pub type _bindgen_ty_1685 = ::core::ffi::c_uint;
16877pub type CMMuxedFormatDescriptionRef = CMFormatDescriptionRef;
16879pub type CMMuxedStreamType = FourCharCode;
16881pub const kCMMuxedStreamType_MPEG1System: _bindgen_ty_1686 = 1836069235;
16883pub const kCMMuxedStreamType_MPEG2Transport: _bindgen_ty_1686 = 1836069492;
16885pub const kCMMuxedStreamType_MPEG2Program: _bindgen_ty_1686 = 1836069488;
16887pub const kCMMuxedStreamType_DV: _bindgen_ty_1686 = 1685463072;
16889pub const kCMMuxedStreamType_EmbeddedDeviceScreenRecording: _bindgen_ty_1686 = 1769173536;
16891pub type _bindgen_ty_1686 = ::core::ffi::c_uint;
16893extern "C" {
16894pub fn CMMuxedFormatDescriptionCreate(
16896 allocator: CFAllocatorRef,
16897 muxType: CMMuxedStreamType,
16898 extensions: CFDictionaryRef,
16899 formatDescriptionOut: *mut CMMuxedFormatDescriptionRef,
16900 ) -> OSStatus;
16901}
16902pub type CMClosedCaptionFormatDescriptionRef = CMFormatDescriptionRef;
16904pub type CMClosedCaptionFormatType = FourCharCode;
16906pub const kCMClosedCaptionFormatType_CEA608: _bindgen_ty_1687 = 1664495672;
16908pub const kCMClosedCaptionFormatType_CEA708: _bindgen_ty_1687 = 1664561208;
16910pub const kCMClosedCaptionFormatType_ATSC: _bindgen_ty_1687 = 1635017571;
16912pub type _bindgen_ty_1687 = ::core::ffi::c_uint;
16914pub type CMTextFormatDescriptionRef = CMFormatDescriptionRef;
16916pub type CMTextFormatType = FourCharCode;
16918pub const kCMTextFormatType_QTText: _bindgen_ty_1688 = 1952807028;
16920pub const kCMTextFormatType_3GText: _bindgen_ty_1688 = 1954034535;
16922pub type _bindgen_ty_1688 = ::core::ffi::c_uint;
16924pub type CMTextDisplayFlags = u32;
16926pub const kCMTextDisplayFlag_scrollIn: _bindgen_ty_1689 = 32;
16928pub const kCMTextDisplayFlag_scrollOut: _bindgen_ty_1689 = 64;
16930pub const kCMTextDisplayFlag_scrollDirectionMask: _bindgen_ty_1689 = 384;
16932pub const kCMTextDisplayFlag_scrollDirection_bottomToTop: _bindgen_ty_1689 = 0;
16934pub const kCMTextDisplayFlag_scrollDirection_rightToLeft: _bindgen_ty_1689 = 128;
16936pub const kCMTextDisplayFlag_scrollDirection_topToBottom: _bindgen_ty_1689 = 256;
16938pub const kCMTextDisplayFlag_scrollDirection_leftToRight: _bindgen_ty_1689 = 384;
16940pub const kCMTextDisplayFlag_continuousKaraoke: _bindgen_ty_1689 = 2048;
16942pub const kCMTextDisplayFlag_writeTextVertically: _bindgen_ty_1689 = 131072;
16944pub const kCMTextDisplayFlag_fillTextRegion: _bindgen_ty_1689 = 262144;
16946pub const kCMTextDisplayFlag_obeySubtitleFormatting: _bindgen_ty_1689 = 536870912;
16948pub const kCMTextDisplayFlag_forcedSubtitlesPresent: _bindgen_ty_1689 = 1073741824;
16950pub const kCMTextDisplayFlag_allSubtitlesForced: _bindgen_ty_1689 = 2147483648;
16952pub type _bindgen_ty_1689 = ::core::ffi::c_uint;
16954pub type CMTextJustificationValue = i8;
16956pub const kCMTextJustification_left_top: _bindgen_ty_1690 = 0;
16958pub const kCMTextJustification_centered: _bindgen_ty_1690 = 1;
16960pub const kCMTextJustification_bottom_right: _bindgen_ty_1690 = -1;
16962pub type _bindgen_ty_1690 = ::core::ffi::c_int;
16964extern "C" {
16965pub static kCMTextFormatDescriptionExtension_DisplayFlags: CFStringRef;
16967}
16968extern "C" {
16969pub static kCMTextFormatDescriptionExtension_BackgroundColor: CFStringRef;
16971}
16972extern "C" {
16973pub static kCMTextFormatDescriptionColor_Red: CFStringRef;
16975}
16976extern "C" {
16977pub static kCMTextFormatDescriptionColor_Green: CFStringRef;
16979}
16980extern "C" {
16981pub static kCMTextFormatDescriptionColor_Blue: CFStringRef;
16983}
16984extern "C" {
16985pub static kCMTextFormatDescriptionColor_Alpha: CFStringRef;
16987}
16988extern "C" {
16989pub static kCMTextFormatDescriptionExtension_DefaultTextBox: CFStringRef;
16991}
16992extern "C" {
16993pub static kCMTextFormatDescriptionRect_Top: CFStringRef;
16995}
16996extern "C" {
16997pub static kCMTextFormatDescriptionRect_Left: CFStringRef;
16999}
17000extern "C" {
17001pub static kCMTextFormatDescriptionRect_Bottom: CFStringRef;
17003}
17004extern "C" {
17005pub static kCMTextFormatDescriptionRect_Right: CFStringRef;
17007}
17008extern "C" {
17009pub static kCMTextFormatDescriptionExtension_DefaultStyle: CFStringRef;
17011}
17012extern "C" {
17013pub static kCMTextFormatDescriptionStyle_StartChar: CFStringRef;
17015}
17016extern "C" {
17017pub static kCMTextFormatDescriptionStyle_Font: CFStringRef;
17019}
17020extern "C" {
17021pub static kCMTextFormatDescriptionStyle_FontFace: CFStringRef;
17023}
17024extern "C" {
17025pub static kCMTextFormatDescriptionStyle_ForegroundColor: CFStringRef;
17027}
17028extern "C" {
17029pub static kCMTextFormatDescriptionStyle_FontSize: CFStringRef;
17031}
17032extern "C" {
17033pub static kCMTextFormatDescriptionExtension_HorizontalJustification: CFStringRef;
17035}
17036extern "C" {
17037pub static kCMTextFormatDescriptionExtension_VerticalJustification: CFStringRef;
17039}
17040extern "C" {
17041pub static kCMTextFormatDescriptionStyle_EndChar: CFStringRef;
17043}
17044extern "C" {
17045pub static kCMTextFormatDescriptionExtension_FontTable: CFStringRef;
17047}
17048extern "C" {
17049pub static kCMTextFormatDescriptionExtension_TextJustification: CFStringRef;
17051}
17052extern "C" {
17053pub static kCMTextFormatDescriptionStyle_Height: CFStringRef;
17055}
17056extern "C" {
17057pub static kCMTextFormatDescriptionStyle_Ascent: CFStringRef;
17059}
17060extern "C" {
17061pub static kCMTextFormatDescriptionExtension_DefaultFontName: CFStringRef;
17063}
17064extern "C" {
17065pub static mut kCMFormatDescriptionExtension_AmbientViewingEnvironment: CFStringRef;
17067}
17068extern "C" {
17069pub fn CMTextFormatDescriptionGetDisplayFlags(
17071 desc: CMFormatDescriptionRef,
17072 displayFlagsOut: *mut CMTextDisplayFlags,
17073 ) -> OSStatus;
17074}
17075extern "C" {
17076pub fn CMTextFormatDescriptionGetJustification(
17078 desc: CMFormatDescriptionRef,
17079 horizontaJustificationlOut: *mut CMTextJustificationValue,
17080 verticalJustificationOut: *mut CMTextJustificationValue,
17081 ) -> OSStatus;
17082}
17083extern "C" {
17084pub fn CMTextFormatDescriptionGetDefaultTextBox(
17086 desc: CMFormatDescriptionRef,
17087 originIsAtTopLeft: Boolean,
17088 heightOfTextTrack: CGFloat,
17089 defaultTextBoxOut: *mut CGRect,
17090 ) -> OSStatus;
17091}
17092extern "C" {
17093pub fn CMTextFormatDescriptionGetDefaultStyle(
17095 desc: CMFormatDescriptionRef,
17096 localFontIDOut: *mut u16,
17097 boldOut: *mut Boolean,
17098 italicOut: *mut Boolean,
17099 underlineOut: *mut Boolean,
17100 fontSizeOut: *mut CGFloat,
17101 colorComponentsOut: *mut CGFloat,
17102 ) -> OSStatus;
17103}
17104extern "C" {
17105pub fn CMTextFormatDescriptionGetFontName(
17107 desc: CMFormatDescriptionRef,
17108 localFontID: u16,
17109 fontNameOut: *mut CFStringRef,
17110 ) -> OSStatus;
17111}
17112pub type CMSubtitleFormatType = FourCharCode;
17114pub const kCMSubtitleFormatType_3GText: _bindgen_ty_1691 = 1954034535;
17116pub const kCMSubtitleFormatType_WebVTT: _bindgen_ty_1691 = 2004251764;
17118pub type _bindgen_ty_1691 = ::core::ffi::c_uint;
17120pub type CMTimeCodeFormatDescriptionRef = CMFormatDescriptionRef;
17122pub type CMTimeCodeFormatType = FourCharCode;
17124pub const kCMTimeCodeFormatType_TimeCode32: _bindgen_ty_1692 = 1953325924;
17126pub const kCMTimeCodeFormatType_TimeCode64: _bindgen_ty_1692 = 1952658996;
17128pub const kCMTimeCodeFormatType_Counter32: _bindgen_ty_1692 = 1668166450;
17130pub const kCMTimeCodeFormatType_Counter64: _bindgen_ty_1692 = 1668167220;
17132pub type _bindgen_ty_1692 = ::core::ffi::c_uint;
17134pub const kCMTimeCodeFlag_DropFrame: _bindgen_ty_1693 = 1;
17136pub const kCMTimeCodeFlag_24HourMax: _bindgen_ty_1693 = 2;
17138pub const kCMTimeCodeFlag_NegTimesOK: _bindgen_ty_1693 = 4;
17140pub type _bindgen_ty_1693 = ::core::ffi::c_uint;
17142extern "C" {
17143pub fn CMTimeCodeFormatDescriptionCreate(
17145 allocator: CFAllocatorRef,
17146 timeCodeFormatType: CMTimeCodeFormatType,
17147 frameDuration: CMTime,
17148 frameQuanta: u32,
17149 flags: u32,
17150 extensions: CFDictionaryRef,
17151 formatDescriptionOut: *mut CMTimeCodeFormatDescriptionRef,
17152 ) -> OSStatus;
17153}
17154extern "C" {
17155pub fn CMTimeCodeFormatDescriptionGetFrameDuration(
17157 timeCodeFormatDescription: CMTimeCodeFormatDescriptionRef,
17158 ) -> CMTime;
17159}
17160extern "C" {
17161pub fn CMTimeCodeFormatDescriptionGetFrameQuanta(
17163 timeCodeFormatDescription: CMTimeCodeFormatDescriptionRef,
17164 ) -> u32;
17165}
17166extern "C" {
17167pub fn CMTimeCodeFormatDescriptionGetTimeCodeFlags(desc: CMTimeCodeFormatDescriptionRef)
17169 -> u32;
17170}
17171extern "C" {
17172pub static kCMTimeCodeFormatDescriptionExtension_SourceReferenceName: CFStringRef;
17174}
17175extern "C" {
17176pub static kCMTimeCodeFormatDescriptionKey_Value: CFStringRef;
17178}
17179extern "C" {
17180pub static kCMTimeCodeFormatDescriptionKey_LangCode: CFStringRef;
17182}
17183pub type CMMetadataFormatDescriptionRef = CMFormatDescriptionRef;
17185pub type CMMetadataFormatType = FourCharCode;
17187pub const kCMMetadataFormatType_ICY: _bindgen_ty_1694 = 1768126752;
17189pub const kCMMetadataFormatType_ID3: _bindgen_ty_1694 = 1768174368;
17191pub const kCMMetadataFormatType_Boxed: _bindgen_ty_1694 = 1835360888;
17193pub const kCMMetadataFormatType_EMSG: _bindgen_ty_1694 = 1701671783;
17195pub type _bindgen_ty_1694 = ::core::ffi::c_uint;
17197extern "C" {
17198pub static kCMFormatDescriptionExtensionKey_MetadataKeyTable: CFStringRef;
17200}
17201extern "C" {
17202pub static kCMMetadataFormatDescriptionKey_Namespace: CFStringRef;
17204}
17205extern "C" {
17206pub static kCMMetadataFormatDescriptionKey_Value: CFStringRef;
17208}
17209extern "C" {
17210pub static kCMMetadataFormatDescriptionKey_LocalID: CFStringRef;
17212}
17213extern "C" {
17214pub static kCMMetadataFormatDescriptionKey_DataType: CFStringRef;
17216}
17217extern "C" {
17218pub static kCMMetadataFormatDescriptionKey_DataTypeNamespace: CFStringRef;
17220}
17221extern "C" {
17222pub static kCMMetadataFormatDescriptionKey_ConformingDataTypes: CFStringRef;
17224}
17225extern "C" {
17226pub static kCMMetadataFormatDescriptionKey_LanguageTag: CFStringRef;
17228}
17229extern "C" {
17230pub static kCMMetadataFormatDescriptionKey_StructuralDependency: CFStringRef;
17232}
17233extern "C" {
17234pub static kCMMetadataFormatDescriptionKey_SetupData: CFStringRef;
17236}
17237extern "C" {
17238pub static kCMMetadataFormatDescription_StructuralDependencyKey_DependencyIsInvalidFlag:
17240 CFStringRef;
17241}
17242extern "C" {
17243pub static kCMMetadataFormatDescriptionMetadataSpecificationKey_Identifier: CFStringRef;
17245}
17246extern "C" {
17247pub static kCMMetadataFormatDescriptionMetadataSpecificationKey_DataType: CFStringRef;
17249}
17250extern "C" {
17251pub static kCMMetadataFormatDescriptionMetadataSpecificationKey_ExtendedLanguageTag:
17253 CFStringRef;
17254}
17255extern "C" {
17256pub static kCMMetadataFormatDescriptionMetadataSpecificationKey_StructuralDependency:
17258 CFStringRef;
17259}
17260extern "C" {
17261pub static kCMMetadataFormatDescriptionMetadataSpecificationKey_SetupData: CFStringRef;
17263}
17264extern "C" {
17265pub fn CMMetadataFormatDescriptionCreateWithKeys(
17267 allocator: CFAllocatorRef,
17268 metadataType: CMMetadataFormatType,
17269 keys: CFArrayRef,
17270 formatDescriptionOut: *mut CMMetadataFormatDescriptionRef,
17271 ) -> OSStatus;
17272}
17273extern "C" {
17274pub fn CMMetadataFormatDescriptionCreateWithMetadataSpecifications(
17276 allocator: CFAllocatorRef,
17277 metadataType: CMMetadataFormatType,
17278 metadataSpecifications: CFArrayRef,
17279 formatDescriptionOut: *mut CMMetadataFormatDescriptionRef,
17280 ) -> OSStatus;
17281}
17282extern "C" {
17283pub fn CMMetadataFormatDescriptionCreateWithMetadataFormatDescriptionAndMetadataSpecifications(
17285 allocator: CFAllocatorRef,
17286 sourceDescription: CMMetadataFormatDescriptionRef,
17287 metadataSpecifications: CFArrayRef,
17288 formatDescriptionOut: *mut CMMetadataFormatDescriptionRef,
17289 ) -> OSStatus;
17290}
17291extern "C" {
17292pub fn CMMetadataFormatDescriptionCreateByMergingMetadataFormatDescriptions(
17294 allocator: CFAllocatorRef,
17295 sourceDescription: CMMetadataFormatDescriptionRef,
17296 otherSourceDescription: CMMetadataFormatDescriptionRef,
17297 formatDescriptionOut: *mut CMMetadataFormatDescriptionRef,
17298 ) -> OSStatus;
17299}
17300extern "C" {
17301pub fn CMMetadataFormatDescriptionGetKeyWithLocalID(
17303 desc: CMMetadataFormatDescriptionRef,
17304 localKeyID: OSType,
17305 ) -> CFDictionaryRef;
17306}
17307extern "C" {
17308pub fn CMMetadataFormatDescriptionGetIdentifiers(
17310 desc: CMMetadataFormatDescriptionRef,
17311 ) -> CFArrayRef;
17312}
17313pub type CMAttachmentBearerRef = CFTypeRef;
17315pub type CMAttachmentMode = u32;
17317pub const kCMAttachmentMode_ShouldNotPropagate: _bindgen_ty_1695 = 0;
17319pub const kCMAttachmentMode_ShouldPropagate: _bindgen_ty_1695 = 1;
17321pub type _bindgen_ty_1695 = ::core::ffi::c_uint;
17323extern "C" {
17324pub fn CMSetAttachment(
17326 target: CMAttachmentBearerRef,
17327 key: CFStringRef,
17328 value: CFTypeRef,
17329 attachmentMode: CMAttachmentMode,
17330 );
17331}
17332extern "C" {
17333pub fn CMGetAttachment(
17335 target: CMAttachmentBearerRef,
17336 key: CFStringRef,
17337 attachmentModeOut: *mut CMAttachmentMode,
17338 ) -> CFTypeRef;
17339}
17340extern "C" {
17341pub fn CMRemoveAttachment(target: CMAttachmentBearerRef, key: CFStringRef);
17343}
17344extern "C" {
17345pub fn CMRemoveAllAttachments(target: CMAttachmentBearerRef);
17347}
17348extern "C" {
17349pub fn CMCopyDictionaryOfAttachments(
17351 allocator: CFAllocatorRef,
17352 target: CMAttachmentBearerRef,
17353 attachmentMode: CMAttachmentMode,
17354 ) -> CFDictionaryRef;
17355}
17356extern "C" {
17357pub fn CMSetAttachments(
17359 target: CMAttachmentBearerRef,
17360 theAttachments: CFDictionaryRef,
17361 attachmentMode: CMAttachmentMode,
17362 );
17363}
17364extern "C" {
17365pub fn CMPropagateAttachments(
17367 source: CMAttachmentBearerRef,
17368 destination: CMAttachmentBearerRef,
17369 );
17370}
17371pub const kCMBlockBufferNoErr: _bindgen_ty_1696 = 0;
17373pub const kCMBlockBufferStructureAllocationFailedErr: _bindgen_ty_1696 = -12700;
17375pub const kCMBlockBufferBlockAllocationFailedErr: _bindgen_ty_1696 = -12701;
17377pub const kCMBlockBufferBadCustomBlockSourceErr: _bindgen_ty_1696 = -12702;
17379pub const kCMBlockBufferBadOffsetParameterErr: _bindgen_ty_1696 = -12703;
17381pub const kCMBlockBufferBadLengthParameterErr: _bindgen_ty_1696 = -12704;
17383pub const kCMBlockBufferBadPointerParameterErr: _bindgen_ty_1696 = -12705;
17385pub const kCMBlockBufferEmptyBBufErr: _bindgen_ty_1696 = -12706;
17387pub const kCMBlockBufferUnallocatedBlockErr: _bindgen_ty_1696 = -12707;
17389pub const kCMBlockBufferInsufficientSpaceErr: _bindgen_ty_1696 = -12708;
17391pub type _bindgen_ty_1696 = ::core::ffi::c_int;
17393pub type CMBlockBufferFlags = u32;
17395pub const kCMBlockBufferAssureMemoryNowFlag: _bindgen_ty_1697 = 1;
17397pub const kCMBlockBufferAlwaysCopyDataFlag: _bindgen_ty_1697 = 2;
17399pub const kCMBlockBufferDontOptimizeDepthFlag: _bindgen_ty_1697 = 4;
17401pub const kCMBlockBufferPermitEmptyReferenceFlag: _bindgen_ty_1697 = 8;
17403pub type _bindgen_ty_1697 = ::core::ffi::c_uint;
17405#[repr(C)]
17406#[derive(Debug, Copy, Clone)]
17407pub struct OpaqueCMBlockBuffer {
17409 _unused: [u8; 0],
17410}
17411pub type CMBlockBufferRef = *mut OpaqueCMBlockBuffer;
17413#[repr(C, packed(4))]
17414#[derive(Debug, Copy, Clone)]
17415pub struct CMBlockBufferCustomBlockSource {
17417 pub version: u32,
17418 pub AllocateBlock: ::core::option::Option<
17419 unsafe extern "C" fn(
17420 refcon: *mut ::core::ffi::c_void,
17421 sizeInBytes: usize,
17422 ) -> *mut ::core::ffi::c_void,
17423 >,
17424 pub FreeBlock: ::core::option::Option<
17425 unsafe extern "C" fn(
17426 refcon: *mut ::core::ffi::c_void,
17427 doomedMemoryBlock: *mut ::core::ffi::c_void,
17428 sizeInBytes: usize,
17429 ),
17430 >,
17431 pub refCon: *mut ::core::ffi::c_void,
17432}
17433pub const kCMBlockBufferCustomBlockSourceVersion: _bindgen_ty_1698 = 0;
17435pub type _bindgen_ty_1698 = ::core::ffi::c_uint;
17437extern "C" {
17438pub fn CMBlockBufferCreateEmpty(
17440 structureAllocator: CFAllocatorRef,
17441 subBlockCapacity: u32,
17442 flags: CMBlockBufferFlags,
17443 blockBufferOut: *mut CMBlockBufferRef,
17444 ) -> OSStatus;
17445}
17446extern "C" {
17447pub fn CMBlockBufferCreateWithMemoryBlock(
17449 structureAllocator: CFAllocatorRef,
17450 memoryBlock: *mut ::core::ffi::c_void,
17451 blockLength: usize,
17452 blockAllocator: CFAllocatorRef,
17453 customBlockSource: *const CMBlockBufferCustomBlockSource,
17454 offsetToData: usize,
17455 dataLength: usize,
17456 flags: CMBlockBufferFlags,
17457 blockBufferOut: *mut CMBlockBufferRef,
17458 ) -> OSStatus;
17459}
17460extern "C" {
17461pub fn CMBlockBufferCreateWithBufferReference(
17463 structureAllocator: CFAllocatorRef,
17464 bufferReference: CMBlockBufferRef,
17465 offsetToData: usize,
17466 dataLength: usize,
17467 flags: CMBlockBufferFlags,
17468 blockBufferOut: *mut CMBlockBufferRef,
17469 ) -> OSStatus;
17470}
17471extern "C" {
17472pub fn CMBlockBufferCreateContiguous(
17474 structureAllocator: CFAllocatorRef,
17475 sourceBuffer: CMBlockBufferRef,
17476 blockAllocator: CFAllocatorRef,
17477 customBlockSource: *const CMBlockBufferCustomBlockSource,
17478 offsetToData: usize,
17479 dataLength: usize,
17480 flags: CMBlockBufferFlags,
17481 blockBufferOut: *mut CMBlockBufferRef,
17482 ) -> OSStatus;
17483}
17484extern "C" {
17485pub fn CMBlockBufferGetTypeID() -> CFTypeID;
17487}
17488extern "C" {
17489pub fn CMBlockBufferAppendMemoryBlock(
17491 theBuffer: CMBlockBufferRef,
17492 memoryBlock: *mut ::core::ffi::c_void,
17493 blockLength: usize,
17494 blockAllocator: CFAllocatorRef,
17495 customBlockSource: *const CMBlockBufferCustomBlockSource,
17496 offsetToData: usize,
17497 dataLength: usize,
17498 flags: CMBlockBufferFlags,
17499 ) -> OSStatus;
17500}
17501extern "C" {
17502pub fn CMBlockBufferAppendBufferReference(
17504 theBuffer: CMBlockBufferRef,
17505 targetBBuf: CMBlockBufferRef,
17506 offsetToData: usize,
17507 dataLength: usize,
17508 flags: CMBlockBufferFlags,
17509 ) -> OSStatus;
17510}
17511extern "C" {
17512pub fn CMBlockBufferAssureBlockMemory(theBuffer: CMBlockBufferRef) -> OSStatus;
17514}
17515extern "C" {
17516pub fn CMBlockBufferAccessDataBytes(
17518 theBuffer: CMBlockBufferRef,
17519 offset: usize,
17520 length: usize,
17521 temporaryBlock: *mut ::core::ffi::c_void,
17522 returnedPointerOut: *mut *mut ::core::ffi::c_char,
17523 ) -> OSStatus;
17524}
17525extern "C" {
17526pub fn CMBlockBufferCopyDataBytes(
17528 theSourceBuffer: CMBlockBufferRef,
17529 offsetToData: usize,
17530 dataLength: usize,
17531 destination: *mut ::core::ffi::c_void,
17532 ) -> OSStatus;
17533}
17534extern "C" {
17535pub fn CMBlockBufferReplaceDataBytes(
17537 sourceBytes: *const ::core::ffi::c_void,
17538 destinationBuffer: CMBlockBufferRef,
17539 offsetIntoDestination: usize,
17540 dataLength: usize,
17541 ) -> OSStatus;
17542}
17543extern "C" {
17544pub fn CMBlockBufferFillDataBytes(
17546 fillByte: ::core::ffi::c_char,
17547 destinationBuffer: CMBlockBufferRef,
17548 offsetIntoDestination: usize,
17549 dataLength: usize,
17550 ) -> OSStatus;
17551}
17552extern "C" {
17553pub fn CMBlockBufferGetDataPointer(
17555 theBuffer: CMBlockBufferRef,
17556 offset: usize,
17557 lengthAtOffsetOut: *mut usize,
17558 totalLengthOut: *mut usize,
17559 dataPointerOut: *mut *mut ::core::ffi::c_char,
17560 ) -> OSStatus;
17561}
17562extern "C" {
17563pub fn CMBlockBufferGetDataLength(theBuffer: CMBlockBufferRef) -> usize;
17565}
17566extern "C" {
17567pub fn CMBlockBufferIsRangeContiguous(
17569 theBuffer: CMBlockBufferRef,
17570 offset: usize,
17571 length: usize,
17572 ) -> Boolean;
17573}
17574extern "C" {
17575pub fn CMBlockBufferIsEmpty(theBuffer: CMBlockBufferRef) -> Boolean;
17577}
17578pub const kCMFormatDescriptionBridgeError_InvalidParameter: _bindgen_ty_1699 = -12712;
17580pub const kCMFormatDescriptionBridgeError_AllocationFailed: _bindgen_ty_1699 = -12713;
17582pub const kCMFormatDescriptionBridgeError_InvalidSerializedSampleDescription: _bindgen_ty_1699 =
17584 -12714;
17585pub const kCMFormatDescriptionBridgeError_InvalidFormatDescription: _bindgen_ty_1699 = -12715;
17587pub const kCMFormatDescriptionBridgeError_IncompatibleFormatDescription: _bindgen_ty_1699 = -12716;
17589pub const kCMFormatDescriptionBridgeError_UnsupportedSampleDescriptionFlavor: _bindgen_ty_1699 =
17591 -12717;
17592pub const kCMFormatDescriptionBridgeError_InvalidSlice: _bindgen_ty_1699 = -12719;
17594pub type _bindgen_ty_1699 = ::core::ffi::c_int;
17596pub type CMImageDescriptionFlavor = CFStringRef;
17598extern "C" {
17599pub static kCMImageDescriptionFlavor_QuickTimeMovie: CMImageDescriptionFlavor;
17601}
17602extern "C" {
17603pub static kCMImageDescriptionFlavor_ISOFamily: CMImageDescriptionFlavor;
17605}
17606extern "C" {
17607pub static kCMImageDescriptionFlavor_3GPFamily: CMImageDescriptionFlavor;
17609}
17610extern "C" {
17611pub static kCMImageDescriptionFlavor_ISOFamilyWithAppleExtensions: CMImageDescriptionFlavor;
17613}
17614extern "C" {
17615pub fn CMVideoFormatDescriptionCreateFromBigEndianImageDescriptionData(
17617 allocator: CFAllocatorRef,
17618 imageDescriptionData: *const u8,
17619 size: usize,
17620 stringEncoding: CFStringEncoding,
17621 flavor: CMImageDescriptionFlavor,
17622 formatDescriptionOut: *mut CMVideoFormatDescriptionRef,
17623 ) -> OSStatus;
17624}
17625extern "C" {
17626pub fn CMVideoFormatDescriptionCreateFromBigEndianImageDescriptionBlockBuffer(
17628 allocator: CFAllocatorRef,
17629 imageDescriptionBlockBuffer: CMBlockBufferRef,
17630 stringEncoding: CFStringEncoding,
17631 flavor: CMImageDescriptionFlavor,
17632 formatDescriptionOut: *mut CMVideoFormatDescriptionRef,
17633 ) -> OSStatus;
17634}
17635extern "C" {
17636pub fn CMVideoFormatDescriptionCopyAsBigEndianImageDescriptionBlockBuffer(
17638 allocator: CFAllocatorRef,
17639 videoFormatDescription: CMVideoFormatDescriptionRef,
17640 stringEncoding: CFStringEncoding,
17641 flavor: CMImageDescriptionFlavor,
17642 blockBufferOut: *mut CMBlockBufferRef,
17643 ) -> OSStatus;
17644}
17645extern "C" {
17646pub fn CMSwapBigEndianImageDescriptionToHost(
17648 imageDescriptionData: *mut u8,
17649 imageDescriptionSize: usize,
17650 ) -> OSStatus;
17651}
17652extern "C" {
17653pub fn CMSwapHostEndianImageDescriptionToBig(
17655 imageDescriptionData: *mut u8,
17656 imageDescriptionSize: usize,
17657 ) -> OSStatus;
17658}
17659pub type CMSoundDescriptionFlavor = CFStringRef;
17661extern "C" {
17662pub static kCMSoundDescriptionFlavor_QuickTimeMovie: CMSoundDescriptionFlavor;
17664}
17665extern "C" {
17666pub static kCMSoundDescriptionFlavor_QuickTimeMovieV2: CMSoundDescriptionFlavor;
17668}
17669extern "C" {
17670pub static kCMSoundDescriptionFlavor_ISOFamily: CMSoundDescriptionFlavor;
17672}
17673extern "C" {
17674pub static kCMSoundDescriptionFlavor_3GPFamily: CMSoundDescriptionFlavor;
17676}
17677extern "C" {
17678pub fn CMAudioFormatDescriptionCreateFromBigEndianSoundDescriptionData(
17680 allocator: CFAllocatorRef,
17681 soundDescriptionData: *const u8,
17682 size: usize,
17683 flavor: CMSoundDescriptionFlavor,
17684 formatDescriptionOut: *mut CMAudioFormatDescriptionRef,
17685 ) -> OSStatus;
17686}
17687extern "C" {
17688pub fn CMAudioFormatDescriptionCreateFromBigEndianSoundDescriptionBlockBuffer(
17690 allocator: CFAllocatorRef,
17691 soundDescriptionBlockBuffer: CMBlockBufferRef,
17692 flavor: CMSoundDescriptionFlavor,
17693 formatDescriptionOut: *mut CMAudioFormatDescriptionRef,
17694 ) -> OSStatus;
17695}
17696extern "C" {
17697pub fn CMAudioFormatDescriptionCopyAsBigEndianSoundDescriptionBlockBuffer(
17699 allocator: CFAllocatorRef,
17700 audioFormatDescription: CMAudioFormatDescriptionRef,
17701 flavor: CMSoundDescriptionFlavor,
17702 blockBufferOut: *mut CMBlockBufferRef,
17703 ) -> OSStatus;
17704}
17705extern "C" {
17706pub fn CMDoesBigEndianSoundDescriptionRequireLegacyCBRSampleTableLayout(
17708 soundDescriptionBlockBuffer: CMBlockBufferRef,
17709 flavor: CMSoundDescriptionFlavor,
17710 ) -> Boolean;
17711}
17712extern "C" {
17713pub fn CMSwapBigEndianSoundDescriptionToHost(
17715 soundDescriptionData: *mut u8,
17716 soundDescriptionSize: usize,
17717 ) -> OSStatus;
17718}
17719extern "C" {
17720pub fn CMSwapHostEndianSoundDescriptionToBig(
17722 soundDescriptionData: *mut u8,
17723 soundDescriptionSize: usize,
17724 ) -> OSStatus;
17725}
17726pub type CMTextDescriptionFlavor = CFStringRef;
17728extern "C" {
17729pub fn CMTextFormatDescriptionCreateFromBigEndianTextDescriptionData(
17731 allocator: CFAllocatorRef,
17732 textDescriptionData: *const u8,
17733 size: usize,
17734 flavor: CMTextDescriptionFlavor,
17735 mediaType: CMMediaType,
17736 formatDescriptionOut: *mut CMTextFormatDescriptionRef,
17737 ) -> OSStatus;
17738}
17739extern "C" {
17740pub fn CMTextFormatDescriptionCreateFromBigEndianTextDescriptionBlockBuffer(
17742 allocator: CFAllocatorRef,
17743 textDescriptionBlockBuffer: CMBlockBufferRef,
17744 flavor: CMTextDescriptionFlavor,
17745 mediaType: CMMediaType,
17746 formatDescriptionOut: *mut CMTextFormatDescriptionRef,
17747 ) -> OSStatus;
17748}
17749extern "C" {
17750pub fn CMTextFormatDescriptionCopyAsBigEndianTextDescriptionBlockBuffer(
17752 allocator: CFAllocatorRef,
17753 textFormatDescription: CMTextFormatDescriptionRef,
17754 flavor: CMTextDescriptionFlavor,
17755 blockBufferOut: *mut CMBlockBufferRef,
17756 ) -> OSStatus;
17757}
17758extern "C" {
17759pub fn CMSwapBigEndianTextDescriptionToHost(
17761 textDescriptionData: *mut u8,
17762 textDescriptionSize: usize,
17763 ) -> OSStatus;
17764}
17765extern "C" {
17766pub fn CMSwapHostEndianTextDescriptionToBig(
17768 textDescriptionData: *mut u8,
17769 textDescriptionSize: usize,
17770 ) -> OSStatus;
17771}
17772pub type CMClosedCaptionDescriptionFlavor = CFStringRef;
17774extern "C" {
17775pub fn CMClosedCaptionFormatDescriptionCreateFromBigEndianClosedCaptionDescriptionData(
17777 allocator: CFAllocatorRef,
17778 closedCaptionDescriptionData: *const u8,
17779 size: usize,
17780 flavor: CMClosedCaptionDescriptionFlavor,
17781 formatDescriptionOut: *mut CMClosedCaptionFormatDescriptionRef,
17782 ) -> OSStatus;
17783}
17784extern "C" {
17785pub fn CMClosedCaptionFormatDescriptionCreateFromBigEndianClosedCaptionDescriptionBlockBuffer(
17787 allocator: CFAllocatorRef,
17788 closedCaptionDescriptionBlockBuffer: CMBlockBufferRef,
17789 flavor: CMClosedCaptionDescriptionFlavor,
17790 formatDescriptionOut: *mut CMClosedCaptionFormatDescriptionRef,
17791 ) -> OSStatus;
17792}
17793extern "C" {
17794pub fn CMClosedCaptionFormatDescriptionCopyAsBigEndianClosedCaptionDescriptionBlockBuffer(
17796 allocator: CFAllocatorRef,
17797 closedCaptionFormatDescription: CMClosedCaptionFormatDescriptionRef,
17798 flavor: CMClosedCaptionDescriptionFlavor,
17799 blockBufferOut: *mut CMBlockBufferRef,
17800 ) -> OSStatus;
17801}
17802extern "C" {
17803pub fn CMSwapBigEndianClosedCaptionDescriptionToHost(
17805 closedCaptionDescriptionData: *mut u8,
17806 closedCaptionDescriptionSize: usize,
17807 ) -> OSStatus;
17808}
17809extern "C" {
17810pub fn CMSwapHostEndianClosedCaptionDescriptionToBig(
17812 closedCaptionDescriptionData: *mut u8,
17813 closedCaptionDescriptionSize: usize,
17814 ) -> OSStatus;
17815}
17816pub type CMTimeCodeDescriptionFlavor = CFStringRef;
17818extern "C" {
17819pub fn CMTimeCodeFormatDescriptionCreateFromBigEndianTimeCodeDescriptionData(
17821 allocator: CFAllocatorRef,
17822 timeCodeDescriptionData: *const u8,
17823 size: usize,
17824 flavor: CMTimeCodeDescriptionFlavor,
17825 formatDescriptionOut: *mut CMTimeCodeFormatDescriptionRef,
17826 ) -> OSStatus;
17827}
17828extern "C" {
17829pub fn CMTimeCodeFormatDescriptionCreateFromBigEndianTimeCodeDescriptionBlockBuffer(
17831 allocator: CFAllocatorRef,
17832 timeCodeDescriptionBlockBuffer: CMBlockBufferRef,
17833 flavor: CMTimeCodeDescriptionFlavor,
17834 formatDescriptionOut: *mut CMTimeCodeFormatDescriptionRef,
17835 ) -> OSStatus;
17836}
17837extern "C" {
17838pub fn CMTimeCodeFormatDescriptionCopyAsBigEndianTimeCodeDescriptionBlockBuffer(
17840 allocator: CFAllocatorRef,
17841 timeCodeFormatDescription: CMTimeCodeFormatDescriptionRef,
17842 flavor: CMTimeCodeDescriptionFlavor,
17843 blockBufferOut: *mut CMBlockBufferRef,
17844 ) -> OSStatus;
17845}
17846extern "C" {
17847pub fn CMSwapBigEndianTimeCodeDescriptionToHost(
17849 timeCodeDescriptionData: *mut u8,
17850 timeCodeDescriptionSize: usize,
17851 ) -> OSStatus;
17852}
17853extern "C" {
17854pub fn CMSwapHostEndianTimeCodeDescriptionToBig(
17856 timeCodeDescriptionData: *mut u8,
17857 timeCodeDescriptionSize: usize,
17858 ) -> OSStatus;
17859}
17860pub type CMMetadataDescriptionFlavor = CFStringRef;
17862extern "C" {
17863pub fn CMMetadataFormatDescriptionCreateFromBigEndianMetadataDescriptionData(
17865 allocator: CFAllocatorRef,
17866 metadataDescriptionData: *const u8,
17867 size: usize,
17868 flavor: CMMetadataDescriptionFlavor,
17869 formatDescriptionOut: *mut CMMetadataFormatDescriptionRef,
17870 ) -> OSStatus;
17871}
17872extern "C" {
17873pub fn CMMetadataFormatDescriptionCreateFromBigEndianMetadataDescriptionBlockBuffer(
17875 allocator: CFAllocatorRef,
17876 metadataDescriptionBlockBuffer: CMBlockBufferRef,
17877 flavor: CMMetadataDescriptionFlavor,
17878 formatDescriptionOut: *mut CMMetadataFormatDescriptionRef,
17879 ) -> OSStatus;
17880}
17881extern "C" {
17882pub fn CMMetadataFormatDescriptionCopyAsBigEndianMetadataDescriptionBlockBuffer(
17884 allocator: CFAllocatorRef,
17885 metadataFormatDescription: CMMetadataFormatDescriptionRef,
17886 flavor: CMMetadataDescriptionFlavor,
17887 blockBufferOut: *mut CMBlockBufferRef,
17888 ) -> OSStatus;
17889}
17890extern "C" {
17891pub fn CMSwapBigEndianMetadataDescriptionToHost(
17893 metadataDescriptionData: *mut u8,
17894 metadataDescriptionSize: usize,
17895 ) -> OSStatus;
17896}
17897extern "C" {
17898pub fn CMSwapHostEndianMetadataDescriptionToBig(
17900 metadataDescriptionData: *mut u8,
17901 metadataDescriptionSize: usize,
17902 ) -> OSStatus;
17903}
17904pub const kCMBufferQueueError_AllocationFailed: _bindgen_ty_1700 = -12760;
17906pub const kCMBufferQueueError_RequiredParameterMissing: _bindgen_ty_1700 = -12761;
17908pub const kCMBufferQueueError_InvalidCMBufferCallbacksStruct: _bindgen_ty_1700 = -12762;
17910pub const kCMBufferQueueError_EnqueueAfterEndOfData: _bindgen_ty_1700 = -12763;
17912pub const kCMBufferQueueError_QueueIsFull: _bindgen_ty_1700 = -12764;
17914pub const kCMBufferQueueError_BadTriggerDuration: _bindgen_ty_1700 = -12765;
17916pub const kCMBufferQueueError_CannotModifyQueueFromTriggerCallback: _bindgen_ty_1700 = -12766;
17918pub const kCMBufferQueueError_InvalidTriggerCondition: _bindgen_ty_1700 = -12767;
17920pub const kCMBufferQueueError_InvalidTriggerToken: _bindgen_ty_1700 = -12768;
17922pub const kCMBufferQueueError_InvalidBuffer: _bindgen_ty_1700 = -12769;
17924pub type _bindgen_ty_1700 = ::core::ffi::c_int;
17926#[repr(C)]
17927#[derive(Debug, Copy, Clone)]
17928pub struct opaqueCMBufferQueue {
17930 _unused: [u8; 0],
17931}
17932pub type CMBufferQueueRef = *mut opaqueCMBufferQueue;
17934pub type CMBufferRef = CFTypeRef;
17936pub type CMBufferGetTimeCallback = ::core::option::Option<
17938 unsafe extern "C" fn(buf: CMBufferRef, refcon: *mut ::core::ffi::c_void) -> CMTime,
17939>;
17940pub type CMBufferGetTimeHandler = *mut ::core::ffi::c_void;
17942pub type CMBufferGetBooleanCallback = ::core::option::Option<
17944 unsafe extern "C" fn(buf: CMBufferRef, refcon: *mut ::core::ffi::c_void) -> Boolean,
17945>;
17946pub type CMBufferGetBooleanHandler = *mut ::core::ffi::c_void;
17948pub type CMBufferCompareCallback = ::core::option::Option<
17950 unsafe extern "C" fn(
17951 buf1: CMBufferRef,
17952 buf2: CMBufferRef,
17953 refcon: *mut ::core::ffi::c_void,
17954 ) -> CFComparisonResult,
17955>;
17956pub type CMBufferCompareHandler = *mut ::core::ffi::c_void;
17958pub type CMBufferGetSizeCallback = ::core::option::Option<
17960 unsafe extern "C" fn(buf: CMBufferRef, refcon: *mut ::core::ffi::c_void) -> usize,
17961>;
17962pub type CMBufferGetSizeHandler = *mut ::core::ffi::c_void;
17964#[repr(C, packed(4))]
17965#[derive(Debug, Copy, Clone)]
17966pub struct CMBufferCallbacks {
17968 pub version: u32,
17969 pub refcon: *mut ::core::ffi::c_void,
17970 pub getDecodeTimeStamp: CMBufferGetTimeCallback,
17971 pub getPresentationTimeStamp: CMBufferGetTimeCallback,
17972 pub getDuration: CMBufferGetTimeCallback,
17973 pub isDataReady: CMBufferGetBooleanCallback,
17974 pub compare: CMBufferCompareCallback,
17975 pub dataBecameReadyNotification: CFStringRef,
17976 pub getSize: CMBufferGetSizeCallback,
17977}
17978#[repr(C)]
17979#[derive(Debug, Copy, Clone)]
17980pub struct CMBufferHandlers {
17982 pub version: usize,
17983 pub getDecodeTimeStamp: CMBufferGetTimeHandler,
17984 pub getPresentationTimeStamp: CMBufferGetTimeHandler,
17985 pub getDuration: CMBufferGetTimeHandler,
17986 pub isDataReady: CMBufferGetBooleanHandler,
17987 pub compare: CMBufferCompareHandler,
17988 pub dataBecameReadyNotification: CFStringRef,
17989 pub getSize: CMBufferGetSizeHandler,
17990}
17991extern "C" {
17992pub fn CMBufferQueueGetCallbacksForUnsortedSampleBuffers() -> *const CMBufferCallbacks;
17994}
17995extern "C" {
17996pub fn CMBufferQueueGetCallbacksForSampleBuffersSortedByOutputPTS() -> *const CMBufferCallbacks;
17998}
17999extern "C" {
18000pub fn CMBufferQueueCreate(
18002 allocator: CFAllocatorRef,
18003 capacity: CMItemCount,
18004 callbacks: *const CMBufferCallbacks,
18005 queueOut: *mut CMBufferQueueRef,
18006 ) -> OSStatus;
18007}
18008extern "C" {
18009pub fn CMBufferQueueCreateWithHandlers(
18011 allocator: CFAllocatorRef,
18012 capacity: CMItemCount,
18013 handlers: *const CMBufferHandlers,
18014 queueOut: *mut CMBufferQueueRef,
18015 ) -> OSStatus;
18016}
18017extern "C" {
18018pub fn CMBufferQueueGetTypeID() -> CFTypeID;
18020}
18021extern "C" {
18022pub fn CMBufferQueueEnqueue(queue: CMBufferQueueRef, buf: CMBufferRef) -> OSStatus;
18024}
18025extern "C" {
18026pub fn CMBufferQueueDequeueAndRetain(queue: CMBufferQueueRef) -> CMBufferRef;
18028}
18029extern "C" {
18030pub fn CMBufferQueueDequeueIfDataReadyAndRetain(queue: CMBufferQueueRef) -> CMBufferRef;
18032}
18033extern "C" {
18034pub fn CMBufferQueueGetHead(queue: CMBufferQueueRef) -> CMBufferRef;
18036}
18037extern "C" {
18038pub fn CMBufferQueueCopyHead(queue: CMBufferQueueRef) -> CMBufferRef;
18040}
18041extern "C" {
18042pub fn CMBufferQueueIsEmpty(queue: CMBufferQueueRef) -> Boolean;
18044}
18045extern "C" {
18046pub fn CMBufferQueueMarkEndOfData(queue: CMBufferQueueRef) -> OSStatus;
18048}
18049extern "C" {
18050pub fn CMBufferQueueContainsEndOfData(queue: CMBufferQueueRef) -> Boolean;
18052}
18053extern "C" {
18054pub fn CMBufferQueueIsAtEndOfData(queue: CMBufferQueueRef) -> Boolean;
18056}
18057extern "C" {
18058pub fn CMBufferQueueReset(queue: CMBufferQueueRef) -> OSStatus;
18060}
18061extern "C" {
18062pub fn CMBufferQueueResetWithCallback(
18064 queue: CMBufferQueueRef,
18065 callback: ::core::option::Option<
18066 unsafe extern "C" fn(buffer: CMBufferRef, refcon: *mut ::core::ffi::c_void),
18067 >,
18068 refcon: *mut ::core::ffi::c_void,
18069 ) -> OSStatus;
18070}
18071extern "C" {
18072pub fn CMBufferQueueGetBufferCount(queue: CMBufferQueueRef) -> CMItemCount;
18074}
18075extern "C" {
18076pub fn CMBufferQueueGetDuration(queue: CMBufferQueueRef) -> CMTime;
18078}
18079extern "C" {
18080pub fn CMBufferQueueGetMinDecodeTimeStamp(queue: CMBufferQueueRef) -> CMTime;
18082}
18083extern "C" {
18084pub fn CMBufferQueueGetFirstDecodeTimeStamp(queue: CMBufferQueueRef) -> CMTime;
18086}
18087extern "C" {
18088pub fn CMBufferQueueGetMinPresentationTimeStamp(queue: CMBufferQueueRef) -> CMTime;
18090}
18091extern "C" {
18092pub fn CMBufferQueueGetFirstPresentationTimeStamp(queue: CMBufferQueueRef) -> CMTime;
18094}
18095extern "C" {
18096pub fn CMBufferQueueGetMaxPresentationTimeStamp(queue: CMBufferQueueRef) -> CMTime;
18098}
18099extern "C" {
18100pub fn CMBufferQueueGetEndPresentationTimeStamp(queue: CMBufferQueueRef) -> CMTime;
18102}
18103extern "C" {
18104pub fn CMBufferQueueGetTotalSize(queue: CMBufferQueueRef) -> usize;
18106}
18107#[repr(C)]
18108#[derive(Debug, Copy, Clone)]
18109pub struct opaqueCMBufferQueueTriggerToken {
18111 _unused: [u8; 0],
18112}
18113pub type CMBufferQueueTriggerToken = *mut opaqueCMBufferQueueTriggerToken;
18115pub type CMBufferQueueTriggerCallback = ::core::option::Option<
18117 unsafe extern "C" fn(
18118 triggerRefcon: *mut ::core::ffi::c_void,
18119 triggerToken: CMBufferQueueTriggerToken,
18120 ),
18121>;
18122pub type CMBufferQueueTriggerHandler = *mut ::core::ffi::c_void;
18124pub type CMBufferQueueTriggerCondition = i32;
18126pub const kCMBufferQueueTrigger_WhenDurationBecomesLessThan: _bindgen_ty_1701 = 1;
18128pub const kCMBufferQueueTrigger_WhenDurationBecomesLessThanOrEqualTo: _bindgen_ty_1701 = 2;
18130pub const kCMBufferQueueTrigger_WhenDurationBecomesGreaterThan: _bindgen_ty_1701 = 3;
18132pub const kCMBufferQueueTrigger_WhenDurationBecomesGreaterThanOrEqualTo: _bindgen_ty_1701 = 4;
18134pub const kCMBufferQueueTrigger_WhenMinPresentationTimeStampChanges: _bindgen_ty_1701 = 5;
18136pub const kCMBufferQueueTrigger_WhenMaxPresentationTimeStampChanges: _bindgen_ty_1701 = 6;
18138pub const kCMBufferQueueTrigger_WhenDataBecomesReady: _bindgen_ty_1701 = 7;
18140pub const kCMBufferQueueTrigger_WhenEndOfDataReached: _bindgen_ty_1701 = 8;
18142pub const kCMBufferQueueTrigger_WhenReset: _bindgen_ty_1701 = 9;
18144pub const kCMBufferQueueTrigger_WhenBufferCountBecomesLessThan: _bindgen_ty_1701 = 10;
18146pub const kCMBufferQueueTrigger_WhenBufferCountBecomesGreaterThan: _bindgen_ty_1701 = 11;
18148pub const kCMBufferQueueTrigger_WhenDurationBecomesGreaterThanOrEqualToAndBufferCountBecomesGreaterThan : _bindgen_ty_1701 = 12 ;
18150pub type _bindgen_ty_1701 = ::core::ffi::c_uint;
18152extern "C" {
18153pub fn CMBufferQueueInstallTrigger(
18155 queue: CMBufferQueueRef,
18156 callback: CMBufferQueueTriggerCallback,
18157 refcon: *mut ::core::ffi::c_void,
18158 condition: CMBufferQueueTriggerCondition,
18159 time: CMTime,
18160 triggerTokenOut: *mut CMBufferQueueTriggerToken,
18161 ) -> OSStatus;
18162}
18163extern "C" {
18164pub fn CMBufferQueueInstallTriggerWithIntegerThreshold(
18166 queue: CMBufferQueueRef,
18167 callback: CMBufferQueueTriggerCallback,
18168 refcon: *mut ::core::ffi::c_void,
18169 condition: CMBufferQueueTriggerCondition,
18170 threshold: CMItemCount,
18171 triggerTokenOut: *mut CMBufferQueueTriggerToken,
18172 ) -> OSStatus;
18173}
18174extern "C" {
18175pub fn CMBufferQueueInstallTriggerHandler(
18177 queue: CMBufferQueueRef,
18178 condition: CMBufferQueueTriggerCondition,
18179 time: CMTime,
18180 triggerTokenOut: *mut CMBufferQueueTriggerToken,
18181 handler: CMBufferQueueTriggerHandler,
18182 ) -> OSStatus;
18183}
18184extern "C" {
18185pub fn CMBufferQueueInstallTriggerHandlerWithIntegerThreshold(
18187 queue: CMBufferQueueRef,
18188 condition: CMBufferQueueTriggerCondition,
18189 threshold: CMItemCount,
18190 triggerTokenOut: *mut CMBufferQueueTriggerToken,
18191 handler: CMBufferQueueTriggerHandler,
18192 ) -> OSStatus;
18193}
18194extern "C" {
18195pub fn CMBufferQueueRemoveTrigger(
18197 queue: CMBufferQueueRef,
18198 triggerToken: CMBufferQueueTriggerToken,
18199 ) -> OSStatus;
18200}
18201extern "C" {
18202pub fn CMBufferQueueTestTrigger(
18204 queue: CMBufferQueueRef,
18205 triggerToken: CMBufferQueueTriggerToken,
18206 ) -> Boolean;
18207}
18208extern "C" {
18209pub fn CMBufferQueueCallForEachBuffer(
18211 queue: CMBufferQueueRef,
18212 callback: ::core::option::Option<
18213 unsafe extern "C" fn(buffer: CMBufferRef, refcon: *mut ::core::ffi::c_void) -> OSStatus,
18214 >,
18215 refcon: *mut ::core::ffi::c_void,
18216 ) -> OSStatus;
18217}
18218pub type CMBufferValidationCallback = ::core::option::Option<
18220 unsafe extern "C" fn(
18221 queue: CMBufferQueueRef,
18222 buf: CMBufferRef,
18223 validationRefCon: *mut ::core::ffi::c_void,
18224 ) -> OSStatus,
18225>;
18226pub type CMBufferValidationHandler = *mut ::core::ffi::c_void;
18228extern "C" {
18229pub fn CMBufferQueueSetValidationCallback(
18231 queue: CMBufferQueueRef,
18232 callback: CMBufferValidationCallback,
18233 refcon: *mut ::core::ffi::c_void,
18234 ) -> OSStatus;
18235}
18236extern "C" {
18237pub fn CMBufferQueueSetValidationHandler(
18239 queue: CMBufferQueueRef,
18240 handler: CMBufferValidationHandler,
18241 ) -> OSStatus;
18242}
18243pub const kCMSampleBufferError_AllocationFailed: _bindgen_ty_1702 = -12730;
18245pub const kCMSampleBufferError_RequiredParameterMissing: _bindgen_ty_1702 = -12731;
18247pub const kCMSampleBufferError_AlreadyHasDataBuffer: _bindgen_ty_1702 = -12732;
18249pub const kCMSampleBufferError_BufferNotReady: _bindgen_ty_1702 = -12733;
18251pub const kCMSampleBufferError_SampleIndexOutOfRange: _bindgen_ty_1702 = -12734;
18253pub const kCMSampleBufferError_BufferHasNoSampleSizes: _bindgen_ty_1702 = -12735;
18255pub const kCMSampleBufferError_BufferHasNoSampleTimingInfo: _bindgen_ty_1702 = -12736;
18257pub const kCMSampleBufferError_ArrayTooSmall: _bindgen_ty_1702 = -12737;
18259pub const kCMSampleBufferError_InvalidEntryCount: _bindgen_ty_1702 = -12738;
18261pub const kCMSampleBufferError_CannotSubdivide: _bindgen_ty_1702 = -12739;
18263pub const kCMSampleBufferError_SampleTimingInfoInvalid: _bindgen_ty_1702 = -12740;
18265pub const kCMSampleBufferError_InvalidMediaTypeForOperation: _bindgen_ty_1702 = -12741;
18267pub const kCMSampleBufferError_InvalidSampleData: _bindgen_ty_1702 = -12742;
18269pub const kCMSampleBufferError_InvalidMediaFormat: _bindgen_ty_1702 = -12743;
18271pub const kCMSampleBufferError_Invalidated: _bindgen_ty_1702 = -12744;
18273pub const kCMSampleBufferError_DataFailed: _bindgen_ty_1702 = -16750;
18275pub const kCMSampleBufferError_DataCanceled: _bindgen_ty_1702 = -16751;
18277pub type _bindgen_ty_1702 = ::core::ffi::c_int;
18279pub const kCMSampleBufferFlag_AudioBufferList_Assure16ByteAlignment: _bindgen_ty_1703 = 1;
18281pub type _bindgen_ty_1703 = ::core::ffi::c_uint;
18283#[repr(C)]
18284#[derive(Debug, Copy, Clone)]
18285pub struct opaqueCMSampleBuffer {
18287 _unused: [u8; 0],
18288}
18289pub type CMSampleBufferRef = *mut opaqueCMSampleBuffer;
18291#[repr(C)]
18292#[derive(Debug, Copy, Clone)]
18293pub struct CMSampleTimingInfo {
18295 pub duration: CMTime,
18296 pub presentationTimeStamp: CMTime,
18297 pub decodeTimeStamp: CMTime,
18298}
18299extern "C" {
18300pub static kCMTimingInfoInvalid: CMSampleTimingInfo;
18302}
18303pub type CMSampleBufferMakeDataReadyCallback = ::core::option::Option<
18305 unsafe extern "C" fn(
18306 sbuf: CMSampleBufferRef,
18307 makeDataReadyRefcon: *mut ::core::ffi::c_void,
18308 ) -> OSStatus,
18309>;
18310pub type CMSampleBufferMakeDataReadyHandler = *mut ::core::ffi::c_void;
18312extern "C" {
18313pub fn CMSampleBufferCreate(
18315 allocator: CFAllocatorRef,
18316 dataBuffer: CMBlockBufferRef,
18317 dataReady: Boolean,
18318 makeDataReadyCallback: CMSampleBufferMakeDataReadyCallback,
18319 makeDataReadyRefcon: *mut ::core::ffi::c_void,
18320 formatDescription: CMFormatDescriptionRef,
18321 numSamples: CMItemCount,
18322 numSampleTimingEntries: CMItemCount,
18323 sampleTimingArray: *const CMSampleTimingInfo,
18324 numSampleSizeEntries: CMItemCount,
18325 sampleSizeArray: *const usize,
18326 sampleBufferOut: *mut CMSampleBufferRef,
18327 ) -> OSStatus;
18328}
18329extern "C" {
18330pub fn CMSampleBufferCreateWithMakeDataReadyHandler(
18332 allocator: CFAllocatorRef,
18333 dataBuffer: CMBlockBufferRef,
18334 dataReady: Boolean,
18335 formatDescription: CMFormatDescriptionRef,
18336 numSamples: CMItemCount,
18337 numSampleTimingEntries: CMItemCount,
18338 sampleTimingArray: *const CMSampleTimingInfo,
18339 numSampleSizeEntries: CMItemCount,
18340 sampleSizeArray: *const usize,
18341 sampleBufferOut: *mut CMSampleBufferRef,
18342 makeDataReadyHandler: CMSampleBufferMakeDataReadyHandler,
18343 ) -> OSStatus;
18344}
18345extern "C" {
18346pub fn CMSampleBufferCreateReady(
18348 allocator: CFAllocatorRef,
18349 dataBuffer: CMBlockBufferRef,
18350 formatDescription: CMFormatDescriptionRef,
18351 numSamples: CMItemCount,
18352 numSampleTimingEntries: CMItemCount,
18353 sampleTimingArray: *const CMSampleTimingInfo,
18354 numSampleSizeEntries: CMItemCount,
18355 sampleSizeArray: *const usize,
18356 sampleBufferOut: *mut CMSampleBufferRef,
18357 ) -> OSStatus;
18358}
18359extern "C" {
18360pub fn CMAudioSampleBufferCreateWithPacketDescriptions(
18362 allocator: CFAllocatorRef,
18363 dataBuffer: CMBlockBufferRef,
18364 dataReady: Boolean,
18365 makeDataReadyCallback: CMSampleBufferMakeDataReadyCallback,
18366 makeDataReadyRefcon: *mut ::core::ffi::c_void,
18367 formatDescription: CMFormatDescriptionRef,
18368 numSamples: CMItemCount,
18369 presentationTimeStamp: CMTime,
18370 packetDescriptions: *const AudioStreamPacketDescription,
18371 sampleBufferOut: *mut CMSampleBufferRef,
18372 ) -> OSStatus;
18373}
18374extern "C" {
18375pub fn CMAudioSampleBufferCreateWithPacketDescriptionsAndMakeDataReadyHandler(
18377 allocator: CFAllocatorRef,
18378 dataBuffer: CMBlockBufferRef,
18379 dataReady: Boolean,
18380 formatDescription: CMFormatDescriptionRef,
18381 numSamples: CMItemCount,
18382 presentationTimeStamp: CMTime,
18383 packetDescriptions: *const AudioStreamPacketDescription,
18384 sampleBufferOut: *mut CMSampleBufferRef,
18385 makeDataReadyHandler: CMSampleBufferMakeDataReadyHandler,
18386 ) -> OSStatus;
18387}
18388extern "C" {
18389pub fn CMAudioSampleBufferCreateReadyWithPacketDescriptions(
18391 allocator: CFAllocatorRef,
18392 dataBuffer: CMBlockBufferRef,
18393 formatDescription: CMFormatDescriptionRef,
18394 numSamples: CMItemCount,
18395 presentationTimeStamp: CMTime,
18396 packetDescriptions: *const AudioStreamPacketDescription,
18397 sampleBufferOut: *mut CMSampleBufferRef,
18398 ) -> OSStatus;
18399}
18400extern "C" {
18401pub fn CMSampleBufferCreateForImageBuffer(
18403 allocator: CFAllocatorRef,
18404 imageBuffer: CVImageBufferRef,
18405 dataReady: Boolean,
18406 makeDataReadyCallback: CMSampleBufferMakeDataReadyCallback,
18407 makeDataReadyRefcon: *mut ::core::ffi::c_void,
18408 formatDescription: CMVideoFormatDescriptionRef,
18409 sampleTiming: *const CMSampleTimingInfo,
18410 sampleBufferOut: *mut CMSampleBufferRef,
18411 ) -> OSStatus;
18412}
18413extern "C" {
18414pub fn CMSampleBufferCreateForImageBufferWithMakeDataReadyHandler(
18416 allocator: CFAllocatorRef,
18417 imageBuffer: CVImageBufferRef,
18418 dataReady: Boolean,
18419 formatDescription: CMVideoFormatDescriptionRef,
18420 sampleTiming: *const CMSampleTimingInfo,
18421 sampleBufferOut: *mut CMSampleBufferRef,
18422 makeDataReadyHandler: CMSampleBufferMakeDataReadyHandler,
18423 ) -> OSStatus;
18424}
18425extern "C" {
18426pub fn CMSampleBufferCreateReadyWithImageBuffer(
18428 allocator: CFAllocatorRef,
18429 imageBuffer: CVImageBufferRef,
18430 formatDescription: CMVideoFormatDescriptionRef,
18431 sampleTiming: *const CMSampleTimingInfo,
18432 sampleBufferOut: *mut CMSampleBufferRef,
18433 ) -> OSStatus;
18434}
18435extern "C" {
18436pub fn CMSampleBufferCreateCopy(
18438 allocator: CFAllocatorRef,
18439 sbuf: CMSampleBufferRef,
18440 sampleBufferOut: *mut CMSampleBufferRef,
18441 ) -> OSStatus;
18442}
18443extern "C" {
18444pub fn CMSampleBufferCreateCopyWithNewTiming(
18446 allocator: CFAllocatorRef,
18447 originalSBuf: CMSampleBufferRef,
18448 numSampleTimingEntries: CMItemCount,
18449 sampleTimingArray: *const CMSampleTimingInfo,
18450 sampleBufferOut: *mut CMSampleBufferRef,
18451 ) -> OSStatus;
18452}
18453extern "C" {
18454pub fn CMSampleBufferCopySampleBufferForRange(
18456 allocator: CFAllocatorRef,
18457 sbuf: CMSampleBufferRef,
18458 sampleRange: CFRange,
18459 sampleBufferOut: *mut CMSampleBufferRef,
18460 ) -> OSStatus;
18461}
18462extern "C" {
18463pub fn CMSampleBufferGetTypeID() -> CFTypeID;
18465}
18466extern "C" {
18467pub fn CMSampleBufferSetDataBuffer(
18469 sbuf: CMSampleBufferRef,
18470 dataBuffer: CMBlockBufferRef,
18471 ) -> OSStatus;
18472}
18473extern "C" {
18474pub fn CMSampleBufferGetDataBuffer(sbuf: CMSampleBufferRef) -> CMBlockBufferRef;
18476}
18477extern "C" {
18478pub fn CMSampleBufferGetImageBuffer(sbuf: CMSampleBufferRef) -> CVImageBufferRef;
18480}
18481extern "C" {
18482pub fn CMSampleBufferSetDataBufferFromAudioBufferList(
18484 sbuf: CMSampleBufferRef,
18485 blockBufferStructureAllocator: CFAllocatorRef,
18486 blockBufferBlockAllocator: CFAllocatorRef,
18487 flags: u32,
18488 bufferList: *const AudioBufferList,
18489 ) -> OSStatus;
18490}
18491extern "C" {
18492pub fn CMSampleBufferGetAudioBufferListWithRetainedBlockBuffer(
18494 sbuf: CMSampleBufferRef,
18495 bufferListSizeNeededOut: *mut usize,
18496 bufferListOut: *mut AudioBufferList,
18497 bufferListSize: usize,
18498 blockBufferStructureAllocator: CFAllocatorRef,
18499 blockBufferBlockAllocator: CFAllocatorRef,
18500 flags: u32,
18501 blockBufferOut: *mut CMBlockBufferRef,
18502 ) -> OSStatus;
18503}
18504extern "C" {
18505pub fn CMSampleBufferGetAudioStreamPacketDescriptions(
18507 sbuf: CMSampleBufferRef,
18508 packetDescriptionsSize: usize,
18509 packetDescriptionsOut: *mut AudioStreamPacketDescription,
18510 packetDescriptionsSizeNeededOut: *mut usize,
18511 ) -> OSStatus;
18512}
18513extern "C" {
18514pub fn CMSampleBufferGetAudioStreamPacketDescriptionsPtr(
18516 sbuf: CMSampleBufferRef,
18517 packetDescriptionsPointerOut: *mut *const AudioStreamPacketDescription,
18518 packetDescriptionsSizeOut: *mut usize,
18519 ) -> OSStatus;
18520}
18521extern "C" {
18522pub fn CMSampleBufferCopyPCMDataIntoAudioBufferList(
18524 sbuf: CMSampleBufferRef,
18525 frameOffset: i32,
18526 numFrames: i32,
18527 bufferList: *mut AudioBufferList,
18528 ) -> OSStatus;
18529}
18530extern "C" {
18531pub fn CMSampleBufferSetDataReady(sbuf: CMSampleBufferRef) -> OSStatus;
18533}
18534extern "C" {
18535pub fn CMSampleBufferDataIsReady(sbuf: CMSampleBufferRef) -> Boolean;
18537}
18538extern "C" {
18539pub fn CMSampleBufferSetDataFailed(sbuf: CMSampleBufferRef, status: OSStatus) -> OSStatus;
18541}
18542extern "C" {
18543pub fn CMSampleBufferHasDataFailed(
18545 sbuf: CMSampleBufferRef,
18546 statusOut: *mut OSStatus,
18547 ) -> Boolean;
18548}
18549extern "C" {
18550pub fn CMSampleBufferMakeDataReady(sbuf: CMSampleBufferRef) -> OSStatus;
18552}
18553extern "C" {
18554pub fn CMSampleBufferTrackDataReadiness(
18556 sbuf: CMSampleBufferRef,
18557 sampleBufferToTrack: CMSampleBufferRef,
18558 ) -> OSStatus;
18559}
18560extern "C" {
18561pub fn CMSampleBufferInvalidate(sbuf: CMSampleBufferRef) -> OSStatus;
18563}
18564pub type CMSampleBufferInvalidateCallback =
18566 ::core::option::Option<unsafe extern "C" fn(sbuf: CMSampleBufferRef, invalidateRefCon: u64)>;
18567extern "C" {
18568pub fn CMSampleBufferSetInvalidateCallback(
18570 sbuf: CMSampleBufferRef,
18571 invalidateCallback: CMSampleBufferInvalidateCallback,
18572 invalidateRefCon: u64,
18573 ) -> OSStatus;
18574}
18575pub type CMSampleBufferInvalidateHandler = *mut ::core::ffi::c_void;
18577extern "C" {
18578pub fn CMSampleBufferSetInvalidateHandler(
18580 sbuf: CMSampleBufferRef,
18581 invalidateHandler: CMSampleBufferInvalidateHandler,
18582 ) -> OSStatus;
18583}
18584extern "C" {
18585pub fn CMSampleBufferIsValid(sbuf: CMSampleBufferRef) -> Boolean;
18587}
18588extern "C" {
18589pub static kCMSampleBufferNotification_DataBecameReady: CFStringRef;
18591}
18592extern "C" {
18593pub static kCMSampleBufferNotification_DataFailed: CFStringRef;
18595}
18596extern "C" {
18597pub static kCMSampleBufferNotificationParameter_OSStatus: CFStringRef;
18599}
18600extern "C" {
18601pub static kCMSampleBufferConduitNotification_InhibitOutputUntil: CFStringRef;
18603}
18604extern "C" {
18605pub static kCMSampleBufferConduitNotificationParameter_ResumeTag: CFStringRef;
18607}
18608extern "C" {
18609pub static kCMSampleBufferConduitNotification_ResetOutput: CFStringRef;
18611}
18612extern "C" {
18613pub static kCMSampleBufferConduitNotification_UpcomingOutputPTSRangeChanged: CFStringRef;
18615}
18616extern "C" {
18617pub static kCMSampleBufferConduitNotificationParameter_UpcomingOutputPTSRangeMayOverlapQueuedOutputPTSRange:
18619 CFStringRef;
18620}
18621extern "C" {
18622pub static kCMSampleBufferConduitNotificationParameter_MinUpcomingOutputPTS: CFStringRef;
18624}
18625extern "C" {
18626pub static kCMSampleBufferConduitNotificationParameter_MaxUpcomingOutputPTS: CFStringRef;
18628}
18629extern "C" {
18630pub static kCMSampleBufferConsumerNotification_BufferConsumed: CFStringRef;
18632}
18633extern "C" {
18634pub fn CMSampleBufferGetNumSamples(sbuf: CMSampleBufferRef) -> CMItemCount;
18636}
18637extern "C" {
18638pub fn CMSampleBufferGetDuration(sbuf: CMSampleBufferRef) -> CMTime;
18640}
18641extern "C" {
18642pub fn CMSampleBufferGetPresentationTimeStamp(sbuf: CMSampleBufferRef) -> CMTime;
18644}
18645extern "C" {
18646pub fn CMSampleBufferGetDecodeTimeStamp(sbuf: CMSampleBufferRef) -> CMTime;
18648}
18649extern "C" {
18650pub fn CMSampleBufferGetOutputDuration(sbuf: CMSampleBufferRef) -> CMTime;
18652}
18653extern "C" {
18654pub fn CMSampleBufferGetOutputPresentationTimeStamp(sbuf: CMSampleBufferRef) -> CMTime;
18656}
18657extern "C" {
18658pub fn CMSampleBufferSetOutputPresentationTimeStamp(
18660 sbuf: CMSampleBufferRef,
18661 outputPresentationTimeStamp: CMTime,
18662 ) -> OSStatus;
18663}
18664extern "C" {
18665pub fn CMSampleBufferGetOutputDecodeTimeStamp(sbuf: CMSampleBufferRef) -> CMTime;
18667}
18668extern "C" {
18669pub fn CMSampleBufferGetSampleTimingInfoArray(
18671 sbuf: CMSampleBufferRef,
18672 numSampleTimingEntries: CMItemCount,
18673 timingArrayOut: *mut CMSampleTimingInfo,
18674 timingArrayEntriesNeededOut: *mut CMItemCount,
18675 ) -> OSStatus;
18676}
18677extern "C" {
18678pub fn CMSampleBufferGetOutputSampleTimingInfoArray(
18680 sbuf: CMSampleBufferRef,
18681 timingArrayEntries: CMItemCount,
18682 timingArrayOut: *mut CMSampleTimingInfo,
18683 timingArrayEntriesNeededOut: *mut CMItemCount,
18684 ) -> OSStatus;
18685}
18686extern "C" {
18687pub fn CMSampleBufferGetSampleTimingInfo(
18689 sbuf: CMSampleBufferRef,
18690 sampleIndex: CMItemIndex,
18691 timingInfoOut: *mut CMSampleTimingInfo,
18692 ) -> OSStatus;
18693}
18694extern "C" {
18695pub fn CMSampleBufferGetSampleSizeArray(
18697 sbuf: CMSampleBufferRef,
18698 sizeArrayEntries: CMItemCount,
18699 sizeArrayOut: *mut usize,
18700 sizeArrayEntriesNeededOut: *mut CMItemCount,
18701 ) -> OSStatus;
18702}
18703extern "C" {
18704pub fn CMSampleBufferGetSampleSize(sbuf: CMSampleBufferRef, sampleIndex: CMItemIndex) -> usize;
18706}
18707extern "C" {
18708pub fn CMSampleBufferGetTotalSampleSize(sbuf: CMSampleBufferRef) -> usize;
18710}
18711extern "C" {
18712pub fn CMSampleBufferGetFormatDescription(sbuf: CMSampleBufferRef) -> CMFormatDescriptionRef;
18714}
18715extern "C" {
18716pub fn CMSampleBufferGetSampleAttachmentsArray(
18718 sbuf: CMSampleBufferRef,
18719 createIfNecessary: Boolean,
18720 ) -> CFArrayRef;
18721}
18722extern "C" {
18723pub static kCMSampleAttachmentKey_NotSync: CFStringRef;
18725}
18726extern "C" {
18727pub static kCMSampleAttachmentKey_PartialSync: CFStringRef;
18729}
18730extern "C" {
18731pub static kCMSampleAttachmentKey_HasRedundantCoding: CFStringRef;
18733}
18734extern "C" {
18735pub static kCMSampleAttachmentKey_IsDependedOnByOthers: CFStringRef;
18737}
18738extern "C" {
18739pub static kCMSampleAttachmentKey_DependsOnOthers: CFStringRef;
18741}
18742extern "C" {
18743pub static kCMSampleAttachmentKey_EarlierDisplayTimesAllowed: CFStringRef;
18745}
18746extern "C" {
18747pub static kCMSampleAttachmentKey_DisplayImmediately: CFStringRef;
18749}
18750extern "C" {
18751pub static kCMSampleAttachmentKey_DoNotDisplay: CFStringRef;
18753}
18754extern "C" {
18755pub static kCMSampleBufferAttachmentKey_ResetDecoderBeforeDecoding: CFStringRef;
18757}
18758extern "C" {
18759pub static kCMSampleBufferAttachmentKey_DrainAfterDecoding: CFStringRef;
18761}
18762extern "C" {
18763pub static kCMSampleBufferAttachmentKey_PostNotificationWhenConsumed: CFStringRef;
18765}
18766extern "C" {
18767pub static kCMSampleBufferAttachmentKey_ResumeOutput: CFStringRef;
18769}
18770extern "C" {
18771pub static kCMSampleAttachmentKey_HEVCTemporalLevelInfo: CFStringRef;
18773}
18774extern "C" {
18775pub static kCMHEVCTemporalLevelInfoKey_TemporalLevel: CFStringRef;
18777}
18778extern "C" {
18779pub static kCMHEVCTemporalLevelInfoKey_ProfileSpace: CFStringRef;
18781}
18782extern "C" {
18783pub static kCMHEVCTemporalLevelInfoKey_TierFlag: CFStringRef;
18785}
18786extern "C" {
18787pub static kCMHEVCTemporalLevelInfoKey_ProfileIndex: CFStringRef;
18789}
18790extern "C" {
18791pub static kCMHEVCTemporalLevelInfoKey_ProfileCompatibilityFlags: CFStringRef;
18793}
18794extern "C" {
18795pub static kCMHEVCTemporalLevelInfoKey_ConstraintIndicatorFlags: CFStringRef;
18797}
18798extern "C" {
18799pub static kCMHEVCTemporalLevelInfoKey_LevelIndex: CFStringRef;
18801}
18802extern "C" {
18803pub static kCMSampleAttachmentKey_HEVCTemporalSubLayerAccess: CFStringRef;
18805}
18806extern "C" {
18807pub static kCMSampleAttachmentKey_HEVCStepwiseTemporalSubLayerAccess: CFStringRef;
18809}
18810extern "C" {
18811pub static kCMSampleAttachmentKey_HEVCSyncSampleNALUnitType: CFStringRef;
18813}
18814extern "C" {
18815pub static kCMSampleAttachmentKey_AudioIndependentSampleDecoderRefreshCount: CFStringRef;
18817}
18818extern "C" {
18819pub static kCMSampleBufferAttachmentKey_TransitionID: CFStringRef;
18821}
18822extern "C" {
18823pub static kCMSampleBufferAttachmentKey_TrimDurationAtStart: CFStringRef;
18825}
18826extern "C" {
18827pub static kCMSampleBufferAttachmentKey_TrimDurationAtEnd: CFStringRef;
18829}
18830extern "C" {
18831pub static kCMSampleBufferAttachmentKey_SpeedMultiplier: CFStringRef;
18833}
18834extern "C" {
18835pub static kCMSampleBufferAttachmentKey_Reverse: CFStringRef;
18837}
18838extern "C" {
18839pub static kCMSampleBufferAttachmentKey_FillDiscontinuitiesWithSilence: CFStringRef;
18841}
18842extern "C" {
18843pub static kCMSampleBufferAttachmentKey_EmptyMedia: CFStringRef;
18845}
18846extern "C" {
18847pub static kCMSampleBufferAttachmentKey_PermanentEmptyMedia: CFStringRef;
18849}
18850extern "C" {
18851pub static kCMSampleBufferAttachmentKey_DisplayEmptyMediaImmediately: CFStringRef;
18853}
18854extern "C" {
18855pub static kCMSampleBufferAttachmentKey_EndsPreviousSampleDuration: CFStringRef;
18857}
18858extern "C" {
18859pub static kCMSampleBufferAttachmentKey_SampleReferenceURL: CFStringRef;
18861}
18862extern "C" {
18863pub static kCMSampleBufferAttachmentKey_SampleReferenceByteOffset: CFStringRef;
18865}
18866extern "C" {
18867pub static kCMSampleBufferAttachmentKey_GradualDecoderRefresh: CFStringRef;
18869}
18870extern "C" {
18871pub static kCMSampleBufferAttachmentKey_DroppedFrameReason: CFStringRef;
18873}
18874extern "C" {
18875pub static kCMSampleBufferDroppedFrameReason_FrameWasLate: CFStringRef;
18877}
18878extern "C" {
18879pub static kCMSampleBufferDroppedFrameReason_OutOfBuffers: CFStringRef;
18881}
18882extern "C" {
18883pub static kCMSampleBufferDroppedFrameReason_Discontinuity: CFStringRef;
18885}
18886extern "C" {
18887pub static kCMSampleBufferAttachmentKey_DroppedFrameReasonInfo: CFStringRef;
18889}
18890extern "C" {
18891pub static kCMSampleBufferDroppedFrameReasonInfo_CameraModeSwitch: CFStringRef;
18893}
18894extern "C" {
18895pub static kCMSampleBufferAttachmentKey_StillImageLensStabilizationInfo: CFStringRef;
18897}
18898extern "C" {
18899pub static kCMSampleBufferLensStabilizationInfo_Active: CFStringRef;
18901}
18902extern "C" {
18903pub static kCMSampleBufferLensStabilizationInfo_OutOfRange: CFStringRef;
18905}
18906extern "C" {
18907pub static kCMSampleBufferLensStabilizationInfo_Unavailable: CFStringRef;
18909}
18910extern "C" {
18911pub static kCMSampleBufferLensStabilizationInfo_Off: CFStringRef;
18913}
18914extern "C" {
18915pub static kCMSampleBufferAttachmentKey_CameraIntrinsicMatrix: CFStringRef;
18917}
18918extern "C" {
18919pub static kCMSampleBufferAttachmentKey_ForceKeyFrame: CFStringRef;
18921}
18922extern "C" {
18923pub static kCMSampleAttachmentKey_CryptorSubsampleAuxiliaryData: CFStringRef;
18925}
18926extern "C" {
18927pub static kCMSampleAttachmentKey_HDR10PlusPerFrameData: CFStringRef;
18929}
18930extern "C" {
18931pub static kCMSampleAttachmentKey_PostDecodeProcessingMetadata: CFStringRef;
18933}
18934extern "C" {
18935pub fn CMSampleBufferCallForEachSample(
18937 sbuf: CMSampleBufferRef,
18938 callback: ::core::option::Option<
18939 unsafe extern "C" fn(
18940 sampleBuffer: CMSampleBufferRef,
18941 index: CMItemCount,
18942 refcon: *mut ::core::ffi::c_void,
18943 ) -> OSStatus,
18944 >,
18945 refcon: *mut ::core::ffi::c_void,
18946 ) -> OSStatus;
18947}
18948extern "C" {
18949pub fn CMSampleBufferCallBlockForEachSample(
18951 sbuf: CMSampleBufferRef,
18952 handler: *mut ::core::ffi::c_void,
18953 ) -> OSStatus;
18954}
18955pub type CMTagError = OSStatus;
18957pub const kCMTagError_ParamErr: _bindgen_ty_1704 = -15730;
18959pub const kCMTagError_AllocationFailed: _bindgen_ty_1704 = -15731;
18961pub type _bindgen_ty_1704 = ::core::ffi::c_int;
18963pub type CMTagCategory = FourCharCode;
18965pub const kCMTagCategory_Undefined: _bindgen_ty_1705 = 0;
18967pub const kCMTagCategory_MediaType: _bindgen_ty_1705 = 1835297121;
18969pub const kCMTagCategory_MediaSubType: _bindgen_ty_1705 = 1836283234;
18971pub const kCMTagCategory_TrackID: _bindgen_ty_1705 = 1953653099;
18973pub const kCMTagCategory_ChannelID: _bindgen_ty_1705 = 1986226286;
18975pub const kCMTagCategory_VideoLayerID: _bindgen_ty_1705 = 1986814329;
18977pub const kCMTagCategory_PixelFormat: _bindgen_ty_1705 = 1885960294;
18979pub const kCMTagCategory_PackingType: _bindgen_ty_1705 = 1885430635;
18981pub const kCMTagCategory_ProjectionType: _bindgen_ty_1705 = 1886547818;
18983pub const kCMTagCategory_StereoView: _bindgen_ty_1705 = 1702454643;
18985pub const kCMTagCategory_StereoViewInterpretation: _bindgen_ty_1705 = 1702455664;
18987pub type _bindgen_ty_1705 = ::core::ffi::c_uint;
18989pub type CMTagDataType = u32;
18991pub const kCMTagDataType_Invalid: _bindgen_ty_1706 = 0;
18993pub const kCMTagDataType_SInt64: _bindgen_ty_1706 = 2;
18995pub const kCMTagDataType_Float64: _bindgen_ty_1706 = 3;
18997pub const kCMTagDataType_OSType: _bindgen_ty_1706 = 5;
18999pub const kCMTagDataType_Flags: _bindgen_ty_1706 = 7;
19001pub type _bindgen_ty_1706 = ::core::ffi::c_uint;
19003pub type CMTagValue = u64;
19005#[repr(C)]
19006#[derive(Debug, Copy, Clone)]
19007pub struct CMTag {
19009 pub category: CMTagCategory,
19010 pub dataType: CMTagDataType,
19011 pub value: CMTagValue,
19012}
19013extern "C" {
19014pub fn CMTagGetValueDataType(tag: CMTag) -> CMTagDataType;
19016}
19017extern "C" {
19018pub static kCMTagInvalid: CMTag;
19020}
19021extern "C" {
19022pub static kCMTagMediaTypeVideo: CMTag;
19024}
19025extern "C" {
19026pub static kCMTagMediaSubTypeMebx: CMTag;
19028}
19029extern "C" {
19030pub static kCMTagMediaTypeAudio: CMTag;
19032}
19033extern "C" {
19034pub static kCMTagMediaTypeMetadata: CMTag;
19036}
19037pub type CMStereoViewComponents = u64;
19039pub const kCMStereoView_None: _bindgen_ty_1707 = 0;
19041pub const kCMStereoView_LeftEye: _bindgen_ty_1707 = 1;
19043pub const kCMStereoView_RightEye: _bindgen_ty_1707 = 2;
19045pub type _bindgen_ty_1707 = ::core::ffi::c_uint;
19047extern "C" {
19048pub static kCMTagStereoLeftEye: CMTag;
19050}
19051extern "C" {
19052pub static kCMTagStereoRightEye: CMTag;
19054}
19055extern "C" {
19056pub static kCMTagStereoLeftAndRightEye: CMTag;
19058}
19059extern "C" {
19060pub static kCMTagStereoNone: CMTag;
19062}
19063pub type CMStereoViewInterpretationOptions = u64;
19065pub const kCMStereoViewInterpretation_Default: _bindgen_ty_1708 = 0;
19067pub const kCMStereoViewInterpretation_StereoOrderReversed: _bindgen_ty_1708 = 1;
19069pub const kCMStereoViewInterpretation_AdditionalViews: _bindgen_ty_1708 = 2;
19071pub type _bindgen_ty_1708 = ::core::ffi::c_uint;
19073extern "C" {
19074pub static kCMTagStereoInterpretationOrderReversed: CMTag;
19076}
19077pub type CMProjectionType = u64;
19079pub const kCMProjectionType_Rectangular: _bindgen_ty_1709 = 1919247220;
19081pub const kCMProjectionType_Equirectangular: _bindgen_ty_1709 = 1701934441;
19083pub const kCMProjectionType_HalfEquirectangular: _bindgen_ty_1709 = 1751478645;
19085pub const kCMProjectionType_Fisheye: _bindgen_ty_1709 = 1718186856;
19087pub const kCMProjectionType_ParametricImmersive: _bindgen_ty_1709 = 1886546285;
19089pub type _bindgen_ty_1709 = ::core::ffi::c_uint;
19091extern "C" {
19092pub static kCMTagProjectionTypeRectangular: CMTag;
19094}
19095extern "C" {
19096pub static kCMTagProjectionTypeEquirectangular: CMTag;
19098}
19099extern "C" {
19100pub static kCMTagProjectionTypeHalfEquirectangular: CMTag;
19102}
19103extern "C" {
19104pub static kCMTagProjectionTypeFisheye: CMTag;
19106}
19107extern "C" {
19108pub static kCMTagProjectionTypeParametricImmersive: CMTag;
19110}
19111pub type CMPackingType = u64;
19113pub const kCMPackingType_None: _bindgen_ty_1710 = 1852796517;
19115pub const kCMPackingType_SideBySide: _bindgen_ty_1710 = 1936286821;
19117pub const kCMPackingType_OverUnder: _bindgen_ty_1710 = 1870030194;
19119pub type _bindgen_ty_1710 = ::core::ffi::c_uint;
19121extern "C" {
19122pub static kCMTagPackingTypeNone: CMTag;
19124}
19125extern "C" {
19126pub static kCMTagPackingTypeSideBySide: CMTag;
19128}
19129extern "C" {
19130pub static kCMTagPackingTypeOverUnder: CMTag;
19132}
19133extern "C" {
19134pub fn CMTagHasSInt64Value(tag: CMTag) -> Boolean;
19136}
19137extern "C" {
19138pub fn CMTagGetSInt64Value(tag: CMTag) -> i64;
19140}
19141extern "C" {
19142pub fn CMTagHasFloat64Value(tag: CMTag) -> Boolean;
19144}
19145extern "C" {
19146pub fn CMTagGetFloat64Value(tag: CMTag) -> Float64;
19148}
19149extern "C" {
19150pub fn CMTagHasOSTypeValue(tag: CMTag) -> Boolean;
19152}
19153extern "C" {
19154pub fn CMTagGetOSTypeValue(tag: CMTag) -> OSType;
19156}
19157extern "C" {
19158pub fn CMTagHasFlagsValue(tag: CMTag) -> Boolean;
19160}
19161extern "C" {
19162pub fn CMTagGetFlagsValue(tag: CMTag) -> u64;
19164}
19165extern "C" {
19166pub fn CMTagMakeWithSInt64Value(category: CMTagCategory, value: i64) -> CMTag;
19168}
19169extern "C" {
19170pub fn CMTagMakeWithFloat64Value(category: CMTagCategory, value: Float64) -> CMTag;
19172}
19173extern "C" {
19174pub fn CMTagMakeWithOSTypeValue(category: CMTagCategory, value: OSType) -> CMTag;
19176}
19177extern "C" {
19178pub fn CMTagMakeWithFlagsValue(category: CMTagCategory, flagsForTag: u64) -> CMTag;
19180}
19181extern "C" {
19182pub fn CMTagEqualToTag(tag1: CMTag, tag2: CMTag) -> Boolean;
19184}
19185extern "C" {
19186pub fn CMTagCompare(tag1: CMTag, tag2: CMTag) -> CFComparisonResult;
19188}
19189extern "C" {
19190pub fn CMTagHash(tag: CMTag) -> CFHashCode;
19192}
19193extern "C" {
19194pub fn CMTagCopyDescription(allocator: CFAllocatorRef, tag: CMTag) -> CFStringRef;
19196}
19197extern "C" {
19198pub fn CMTagCopyAsDictionary(tag: CMTag, allocator: CFAllocatorRef) -> CFDictionaryRef;
19200}
19201extern "C" {
19202pub fn CMTagMakeFromDictionary(dict: CFDictionaryRef) -> CMTag;
19204}
19205extern "C" {
19206pub static kCMTagValueKey: CFStringRef;
19208}
19209extern "C" {
19210pub static kCMTagCategoryKey: CFStringRef;
19212}
19213extern "C" {
19214pub static kCMTagDataTypeKey: CFStringRef;
19216}
19217pub type CMTagCollectionError = OSStatus;
19219pub const kCMTagCollectionError_ParamErr: _bindgen_ty_1711 = -15740;
19221pub const kCMTagCollectionError_AllocationFailed: _bindgen_ty_1711 = -15741;
19223pub const kCMTagCollectionError_InternalError: _bindgen_ty_1711 = -15742;
19225pub const kCMTagCollectionError_InvalidTag: _bindgen_ty_1711 = -15743;
19227pub const kCMTagCollectionError_InvalidTagCollectionDictionary: _bindgen_ty_1711 = -15744;
19229pub const kCMTagCollectionError_InvalidTagCollectionData: _bindgen_ty_1711 = -15745;
19231pub const kCMTagCollectionError_TagNotFound: _bindgen_ty_1711 = -15746;
19233pub const kCMTagCollectionError_InvalidTagCollectionDataVersion: _bindgen_ty_1711 = -15747;
19235pub const kCMTagCollectionError_ExhaustedBufferSize: _bindgen_ty_1711 = -15748;
19237pub const kCMTagCollectionError_NotYetImplemented: _bindgen_ty_1711 = -15749;
19239pub type _bindgen_ty_1711 = ::core::ffi::c_int;
19241#[repr(C)]
19242#[derive(Debug, Copy, Clone)]
19243pub struct OpaqueCMTagCollection {
19245 _unused: [u8; 0],
19246}
19247pub type CMTagCollectionRef = *const OpaqueCMTagCollection;
19249pub type CMMutableTagCollectionRef = *mut OpaqueCMTagCollection;
19251extern "C" {
19252pub fn CMTagCollectionGetTypeID() -> CFTypeID;
19254}
19255pub type CMTagCollectionApplierFunction =
19257 ::core::option::Option<unsafe extern "C" fn(tag: CMTag, context: *mut ::core::ffi::c_void)>;
19258pub type CMTagCollectionTagFilterFunction = ::core::option::Option<
19260 unsafe extern "C" fn(tag: CMTag, context: *mut ::core::ffi::c_void) -> Boolean,
19261>;
19262extern "C" {
19263pub fn CMTagCollectionCreate(
19265 allocator: CFAllocatorRef,
19266 tags: *const CMTag,
19267 tagCount: CMItemCount,
19268 newCollectionOut: *mut CMTagCollectionRef,
19269 ) -> OSStatus;
19270}
19271extern "C" {
19272pub fn CMTagCollectionCreateMutable(
19274 allocator: CFAllocatorRef,
19275 capacity: CFIndex,
19276 newMutableCollectionOut: *mut CMMutableTagCollectionRef,
19277 ) -> OSStatus;
19278}
19279extern "C" {
19280pub fn CMTagCollectionCreateCopy(
19282 tagCollection: CMTagCollectionRef,
19283 allocator: CFAllocatorRef,
19284 newCollectionCopyOut: *mut CMTagCollectionRef,
19285 ) -> OSStatus;
19286}
19287extern "C" {
19288pub fn CMTagCollectionCreateMutableCopy(
19290 tagCollection: CMTagCollectionRef,
19291 allocator: CFAllocatorRef,
19292 newMutableCollectionCopyOut: *mut CMMutableTagCollectionRef,
19293 ) -> OSStatus;
19294}
19295extern "C" {
19296pub fn CMTagCollectionCopyDescription(
19298 allocator: CFAllocatorRef,
19299 tagCollection: CMTagCollectionRef,
19300 ) -> CFStringRef;
19301}
19302extern "C" {
19303pub fn CMTagCollectionGetCount(tagCollection: CMTagCollectionRef) -> CMItemCount;
19305}
19306extern "C" {
19307pub fn CMTagCollectionContainsTag(tagCollection: CMTagCollectionRef, tag: CMTag) -> Boolean;
19309}
19310extern "C" {
19311pub fn CMTagCollectionContainsTagsOfCollection(
19313 tagCollection: CMTagCollectionRef,
19314 containedTagCollection: CMTagCollectionRef,
19315 ) -> Boolean;
19316}
19317extern "C" {
19318pub fn CMTagCollectionContainsSpecifiedTags(
19320 tagCollection: CMTagCollectionRef,
19321 containedTags: *const CMTag,
19322 containedTagCount: CMItemCount,
19323 ) -> Boolean;
19324}
19325extern "C" {
19326pub fn CMTagCollectionContainsCategory(
19328 tagCollection: CMTagCollectionRef,
19329 category: CMTagCategory,
19330 ) -> Boolean;
19331}
19332extern "C" {
19333pub fn CMTagCollectionGetCountOfCategory(
19335 tagCollection: CMTagCollectionRef,
19336 category: CMTagCategory,
19337 ) -> CMItemCount;
19338}
19339extern "C" {
19340pub fn CMTagCollectionGetTags(
19342 tagCollection: CMTagCollectionRef,
19343 tagBuffer: *mut CMTag,
19344 tagBufferCount: CMItemCount,
19345 numberOfTagsCopied: *mut CMItemCount,
19346 ) -> OSStatus;
19347}
19348extern "C" {
19349pub fn CMTagCollectionGetTagsWithCategory(
19351 tagCollection: CMTagCollectionRef,
19352 category: CMTagCategory,
19353 tagBuffer: *mut CMTag,
19354 tagBufferCount: CMItemCount,
19355 numberOfTagsCopied: *mut CMItemCount,
19356 ) -> OSStatus;
19357}
19358extern "C" {
19359pub fn CMTagCollectionCountTagsWithFilterFunction(
19361 tagCollection: CMTagCollectionRef,
19362 filterApplier: CMTagCollectionTagFilterFunction,
19363 context: *mut ::core::ffi::c_void,
19364 ) -> CMItemCount;
19365}
19366extern "C" {
19367pub fn CMTagCollectionGetTagsWithFilterFunction(
19369 tagCollection: CMTagCollectionRef,
19370 tagBuffer: *mut CMTag,
19371 tagBufferCount: CMItemCount,
19372 numberOfTagsCopied: *mut CMItemCount,
19373 filter: CMTagCollectionTagFilterFunction,
19374 context: *mut ::core::ffi::c_void,
19375 ) -> OSStatus;
19376}
19377extern "C" {
19378pub fn CMTagCollectionCopyTagsOfCategories(
19380 allocator: CFAllocatorRef,
19381 tagCollection: CMTagCollectionRef,
19382 categories: *const CMTagCategory,
19383 categoriesCount: CMItemCount,
19384 collectionWithTagsOfCategories: *mut CMTagCollectionRef,
19385 ) -> OSStatus;
19386}
19387extern "C" {
19388pub fn CMTagCollectionApply(
19390 tagCollection: CMTagCollectionRef,
19391 applier: CMTagCollectionApplierFunction,
19392 context: *mut ::core::ffi::c_void,
19393 );
19394}
19395extern "C" {
19396pub fn CMTagCollectionApplyUntil(
19398 tagCollection: CMTagCollectionRef,
19399 applier: CMTagCollectionTagFilterFunction,
19400 context: *mut ::core::ffi::c_void,
19401 ) -> CMTag;
19402}
19403extern "C" {
19404pub fn CMTagCollectionIsEmpty(tagCollection: CMTagCollectionRef) -> Boolean;
19406}
19407extern "C" {
19408pub fn CMTagCollectionCreateIntersection(
19410 tagCollection1: CMTagCollectionRef,
19411 tagCollection2: CMTagCollectionRef,
19412 tagCollectionOut: *mut CMTagCollectionRef,
19413 ) -> OSStatus;
19414}
19415extern "C" {
19416pub fn CMTagCollectionCreateUnion(
19418 tagCollection1: CMTagCollectionRef,
19419 tagCollection2: CMTagCollectionRef,
19420 tagCollectionOut: *mut CMTagCollectionRef,
19421 ) -> OSStatus;
19422}
19423extern "C" {
19424pub fn CMTagCollectionCreateDifference(
19426 tagCollectionMinuend: CMTagCollectionRef,
19427 tagCollectionSubtrahend: CMTagCollectionRef,
19428 tagCollectionOut: *mut CMTagCollectionRef,
19429 ) -> OSStatus;
19430}
19431extern "C" {
19432pub fn CMTagCollectionCreateExclusiveOr(
19434 tagCollection1: CMTagCollectionRef,
19435 tagCollection2: CMTagCollectionRef,
19436 tagCollectionOut: *mut CMTagCollectionRef,
19437 ) -> OSStatus;
19438}
19439extern "C" {
19440pub fn CMTagCollectionAddTag(
19442 tagCollection: CMMutableTagCollectionRef,
19443 tagToAdd: CMTag,
19444 ) -> OSStatus;
19445}
19446extern "C" {
19447pub fn CMTagCollectionRemoveTag(
19449 tagCollection: CMMutableTagCollectionRef,
19450 tagToRemove: CMTag,
19451 ) -> OSStatus;
19452}
19453extern "C" {
19454pub fn CMTagCollectionRemoveAllTags(tagCollection: CMMutableTagCollectionRef) -> OSStatus;
19456}
19457extern "C" {
19458pub fn CMTagCollectionRemoveAllTagsOfCategory(
19460 tagCollection: CMMutableTagCollectionRef,
19461 category: CMTagCategory,
19462 ) -> OSStatus;
19463}
19464extern "C" {
19465pub fn CMTagCollectionAddTagsFromCollection(
19467 tagCollection: CMMutableTagCollectionRef,
19468 collectionWithTagsToAdd: CMTagCollectionRef,
19469 ) -> OSStatus;
19470}
19471extern "C" {
19472pub fn CMTagCollectionAddTagsFromArray(
19474 tagCollection: CMMutableTagCollectionRef,
19475 tags: *mut CMTag,
19476 tagCount: CMItemCount,
19477 ) -> OSStatus;
19478}
19479extern "C" {
19480pub fn CMTagCollectionCopyAsDictionary(
19482 tagCollection: CMTagCollectionRef,
19483 allocator: CFAllocatorRef,
19484 ) -> CFDictionaryRef;
19485}
19486extern "C" {
19487pub fn CMTagCollectionCreateFromDictionary(
19489 dict: CFDictionaryRef,
19490 allocator: CFAllocatorRef,
19491 newCollectionOut: *mut CMTagCollectionRef,
19492 ) -> OSStatus;
19493}
19494extern "C" {
19495pub fn CMTagCollectionCopyAsData(
19497 tagCollection: CMTagCollectionRef,
19498 allocator: CFAllocatorRef,
19499 ) -> CFDataRef;
19500}
19501extern "C" {
19502pub fn CMTagCollectionCreateFromData(
19504 data: CFDataRef,
19505 allocator: CFAllocatorRef,
19506 newCollectionOut: *mut CMTagCollectionRef,
19507 ) -> OSStatus;
19508}
19509extern "C" {
19510pub static kCMTagCollectionTagsArrayKey: CFStringRef;
19512}
19513pub type CMTaggedBufferGroupError = OSStatus;
19515pub const kCMTaggedBufferGroupError_ParamErr: _bindgen_ty_1712 = -15780;
19517pub const kCMTaggedBufferGroupError_AllocationFailed: _bindgen_ty_1712 = -15781;
19519pub const kCMTaggedBufferGroupError_InternalError: _bindgen_ty_1712 = -15782;
19521pub type _bindgen_ty_1712 = ::core::ffi::c_int;
19523#[repr(C)]
19524#[derive(Debug, Copy, Clone)]
19525pub struct OpaqueCMTaggedBufferGroup {
19527 _unused: [u8; 0],
19528}
19529pub type CMTaggedBufferGroupRef = *mut OpaqueCMTaggedBufferGroup;
19531extern "C" {
19532pub fn CMTaggedBufferGroupGetTypeID() -> CFTypeID;
19534}
19535extern "C" {
19536pub fn CMTaggedBufferGroupCreate(
19538 allocator: CFAllocatorRef,
19539 tagCollections: CFArrayRef,
19540 buffers: CFArrayRef,
19541 groupOut: *mut CMTaggedBufferGroupRef,
19542 ) -> OSStatus;
19543}
19544extern "C" {
19545pub fn CMTaggedBufferGroupCreateCombined(
19547 allocator: CFAllocatorRef,
19548 taggedBufferGroups: CFArrayRef,
19549 groupOut: *mut CMTaggedBufferGroupRef,
19550 ) -> OSStatus;
19551}
19552extern "C" {
19553pub fn CMTaggedBufferGroupGetCount(group: CMTaggedBufferGroupRef) -> CMItemCount;
19555}
19556extern "C" {
19557pub fn CMTaggedBufferGroupGetTagCollectionAtIndex(
19559 group: CMTaggedBufferGroupRef,
19560 index: CFIndex,
19561 ) -> CMTagCollectionRef;
19562}
19563extern "C" {
19564pub fn CMTaggedBufferGroupGetCVPixelBufferAtIndex(
19566 group: CMTaggedBufferGroupRef,
19567 index: CFIndex,
19568 ) -> CVPixelBufferRef;
19569}
19570extern "C" {
19571pub fn CMTaggedBufferGroupGetCVPixelBufferForTag(
19573 group: CMTaggedBufferGroupRef,
19574 tag: CMTag,
19575 indexOut: *mut CFIndex,
19576 ) -> CVPixelBufferRef;
19577}
19578extern "C" {
19579pub fn CMTaggedBufferGroupGetCVPixelBufferForTagCollection(
19581 group: CMTaggedBufferGroupRef,
19582 tagCollection: CMTagCollectionRef,
19583 indexOut: *mut CFIndex,
19584 ) -> CVPixelBufferRef;
19585}
19586extern "C" {
19587pub fn CMTaggedBufferGroupGetCMSampleBufferAtIndex(
19589 group: CMTaggedBufferGroupRef,
19590 index: CFIndex,
19591 ) -> CMSampleBufferRef;
19592}
19593extern "C" {
19594pub fn CMTaggedBufferGroupGetCMSampleBufferForTag(
19596 group: CMTaggedBufferGroupRef,
19597 tag: CMTag,
19598 indexOut: *mut CFIndex,
19599 ) -> CMSampleBufferRef;
19600}
19601extern "C" {
19602pub fn CMTaggedBufferGroupGetCMSampleBufferForTagCollection(
19604 group: CMTaggedBufferGroupRef,
19605 tagCollection: CMTagCollectionRef,
19606 indexOut: *mut CFIndex,
19607 ) -> CMSampleBufferRef;
19608}
19609extern "C" {
19610pub fn CMTaggedBufferGroupGetNumberOfMatchesForTagCollection(
19612 group: CMTaggedBufferGroupRef,
19613 tagCollection: CMTagCollectionRef,
19614 ) -> CMItemCount;
19615}
19616extern "C" {
19617pub fn CMTaggedBufferGroupFormatDescriptionCreateForTaggedBufferGroup(
19619 allocator: CFAllocatorRef,
19620 taggedBufferGroup: CMTaggedBufferGroupRef,
19621 formatDescriptionOut: *mut CMTaggedBufferGroupFormatDescriptionRef,
19622 ) -> OSStatus;
19623}
19624extern "C" {
19625pub fn CMTaggedBufferGroupFormatDescriptionCreateForTaggedBufferGroupWithExtensions(
19627 allocator: CFAllocatorRef,
19628 taggedBufferGroup: CMTaggedBufferGroupRef,
19629 extensions: CFDictionaryRef,
19630 formatDescriptionOut: *mut CMTaggedBufferGroupFormatDescriptionRef,
19631 ) -> OSStatus;
19632}
19633extern "C" {
19634pub fn CMTaggedBufferGroupFormatDescriptionMatchesTaggedBufferGroup(
19636 desc: CMTaggedBufferGroupFormatDescriptionRef,
19637 taggedBufferGroup: CMTaggedBufferGroupRef,
19638 ) -> Boolean;
19639}
19640extern "C" {
19641pub fn CMSampleBufferCreateForTaggedBufferGroup(
19643 allocator: CFAllocatorRef,
19644 taggedBufferGroup: CMTaggedBufferGroupRef,
19645 sbufPTS: CMTime,
19646 sbufDuration: CMTime,
19647 formatDescription: CMTaggedBufferGroupFormatDescriptionRef,
19648 sBufOut: *mut CMSampleBufferRef,
19649 ) -> OSStatus;
19650}
19651extern "C" {
19652pub fn CMSampleBufferGetTaggedBufferGroup(sbuf: CMSampleBufferRef) -> CMTaggedBufferGroupRef;
19654}
19655pub const kCMSimpleQueueError_AllocationFailed: _bindgen_ty_1713 = -12770;
19657pub const kCMSimpleQueueError_RequiredParameterMissing: _bindgen_ty_1713 = -12771;
19659pub const kCMSimpleQueueError_ParameterOutOfRange: _bindgen_ty_1713 = -12772;
19661pub const kCMSimpleQueueError_QueueIsFull: _bindgen_ty_1713 = -12773;
19663pub type _bindgen_ty_1713 = ::core::ffi::c_int;
19665#[repr(C)]
19666#[derive(Debug, Copy, Clone)]
19667pub struct opaqueCMSimpleQueue {
19669 _unused: [u8; 0],
19670}
19671pub type CMSimpleQueueRef = *mut opaqueCMSimpleQueue;
19673extern "C" {
19674pub fn CMSimpleQueueGetTypeID() -> CFTypeID;
19676}
19677extern "C" {
19678pub fn CMSimpleQueueCreate(
19680 allocator: CFAllocatorRef,
19681 capacity: i32,
19682 queueOut: *mut CMSimpleQueueRef,
19683 ) -> OSStatus;
19684}
19685extern "C" {
19686pub fn CMSimpleQueueEnqueue(
19688 queue: CMSimpleQueueRef,
19689 element: *const ::core::ffi::c_void,
19690 ) -> OSStatus;
19691}
19692extern "C" {
19693pub fn CMSimpleQueueDequeue(queue: CMSimpleQueueRef) -> *const ::core::ffi::c_void;
19695}
19696extern "C" {
19697pub fn CMSimpleQueueGetHead(queue: CMSimpleQueueRef) -> *const ::core::ffi::c_void;
19699}
19700extern "C" {
19701pub fn CMSimpleQueueReset(queue: CMSimpleQueueRef) -> OSStatus;
19703}
19704extern "C" {
19705pub fn CMSimpleQueueGetCapacity(queue: CMSimpleQueueRef) -> i32;
19707}
19708extern "C" {
19709pub fn CMSimpleQueueGetCount(queue: CMSimpleQueueRef) -> i32;
19711}
19712#[repr(C)]
19713#[derive(Debug, Copy, Clone)]
19714pub struct OpaqueCMMemoryPool {
19716 _unused: [u8; 0],
19717}
19718pub type CMMemoryPoolRef = *mut OpaqueCMMemoryPool;
19720pub const kCMMemoryPoolError_AllocationFailed: _bindgen_ty_1714 = -15490;
19722pub const kCMMemoryPoolError_InvalidParameter: _bindgen_ty_1714 = -15491;
19724pub type _bindgen_ty_1714 = ::core::ffi::c_int;
19726extern "C" {
19727pub fn CMMemoryPoolGetTypeID() -> CFTypeID;
19729}
19730extern "C" {
19731pub static mut kCMMemoryPoolOption_AgeOutPeriod: CFStringRef;
19733}
19734extern "C" {
19735pub fn CMMemoryPoolCreate(options: CFDictionaryRef) -> CMMemoryPoolRef;
19737}
19738extern "C" {
19739pub fn CMMemoryPoolGetAllocator(pool: CMMemoryPoolRef) -> CFAllocatorRef;
19741}
19742extern "C" {
19743pub fn CMMemoryPoolFlush(pool: CMMemoryPoolRef);
19745}
19746extern "C" {
19747pub fn CMMemoryPoolInvalidate(pool: CMMemoryPoolRef);
19749}
19750#[repr(C)]
19751#[derive(Debug, Copy, Clone)]
19752pub struct OpaqueCMClock {
19754 _unused: [u8; 0],
19755}
19756pub type CMClockRef = *mut OpaqueCMClock;
19758#[repr(C)]
19759#[derive(Debug, Copy, Clone)]
19760pub struct OpaqueCMTimebase {
19762 _unused: [u8; 0],
19763}
19764pub type CMTimebaseRef = *mut OpaqueCMTimebase;
19766pub type CMClockOrTimebaseRef = CFTypeRef;
19768pub const kCMClockError_MissingRequiredParameter: _bindgen_ty_1715 = -12745;
19770pub const kCMClockError_InvalidParameter: _bindgen_ty_1715 = -12746;
19772pub const kCMClockError_AllocationFailed: _bindgen_ty_1715 = -12747;
19774pub const kCMClockError_UnsupportedOperation: _bindgen_ty_1715 = -12756;
19776pub type _bindgen_ty_1715 = ::core::ffi::c_int;
19778pub const kCMTimebaseError_MissingRequiredParameter: _bindgen_ty_1716 = -12748;
19780pub const kCMTimebaseError_InvalidParameter: _bindgen_ty_1716 = -12749;
19782pub const kCMTimebaseError_AllocationFailed: _bindgen_ty_1716 = -12750;
19784pub const kCMTimebaseError_TimerIntervalTooShort: _bindgen_ty_1716 = -12751;
19786pub const kCMTimebaseError_ReadOnly: _bindgen_ty_1716 = -12757;
19788pub type _bindgen_ty_1716 = ::core::ffi::c_int;
19790pub const kCMSyncError_MissingRequiredParameter: _bindgen_ty_1717 = -12752;
19792pub const kCMSyncError_InvalidParameter: _bindgen_ty_1717 = -12753;
19794pub const kCMSyncError_AllocationFailed: _bindgen_ty_1717 = -12754;
19796pub const kCMSyncError_RateMustBeNonZero: _bindgen_ty_1717 = -12755;
19798pub type _bindgen_ty_1717 = ::core::ffi::c_int;
19800extern "C" {
19801pub fn CMClockGetTypeID() -> CFTypeID;
19803}
19804extern "C" {
19805pub fn CMClockGetHostTimeClock() -> CMClockRef;
19807}
19808extern "C" {
19809pub fn CMClockConvertHostTimeToSystemUnits(hostTime: CMTime) -> u64;
19811}
19812extern "C" {
19813pub fn CMClockMakeHostTimeFromSystemUnits(hostTime: u64) -> CMTime;
19815}
19816extern "C" {
19817pub fn CMClockGetTime(clock: CMClockRef) -> CMTime;
19819}
19820extern "C" {
19821pub fn CMClockGetAnchorTime(
19823 clock: CMClockRef,
19824 clockTimeOut: *mut CMTime,
19825 referenceClockTimeOut: *mut CMTime,
19826 ) -> OSStatus;
19827}
19828extern "C" {
19829pub fn CMClockMightDrift(clock: CMClockRef, otherClock: CMClockRef) -> Boolean;
19831}
19832extern "C" {
19833pub fn CMClockInvalidate(clock: CMClockRef);
19835}
19836extern "C" {
19837pub fn CMTimebaseGetTypeID() -> CFTypeID;
19839}
19840extern "C" {
19841pub fn CMTimebaseCreateWithSourceClock(
19843 allocator: CFAllocatorRef,
19844 sourceClock: CMClockRef,
19845 timebaseOut: *mut CMTimebaseRef,
19846 ) -> OSStatus;
19847}
19848extern "C" {
19849pub fn CMTimebaseCreateWithSourceTimebase(
19851 allocator: CFAllocatorRef,
19852 sourceTimebase: CMTimebaseRef,
19853 timebaseOut: *mut CMTimebaseRef,
19854 ) -> OSStatus;
19855}
19856extern "C" {
19857pub fn CMTimebaseCopySourceTimebase(timebase: CMTimebaseRef) -> CMTimebaseRef;
19859}
19860extern "C" {
19861pub fn CMTimebaseCopySourceClock(timebase: CMTimebaseRef) -> CMClockRef;
19863}
19864extern "C" {
19865pub fn CMTimebaseCopySource(timebase: CMTimebaseRef) -> CMClockOrTimebaseRef;
19867}
19868extern "C" {
19869pub fn CMTimebaseCopyUltimateSourceClock(timebase: CMTimebaseRef) -> CMClockRef;
19871}
19872extern "C" {
19873pub fn CMTimebaseGetMasterTimebase(timebase: CMTimebaseRef) -> CMTimebaseRef;
19875}
19876extern "C" {
19877pub fn CMTimebaseGetMasterClock(timebase: CMTimebaseRef) -> CMClockRef;
19879}
19880extern "C" {
19881pub fn CMTimebaseGetMaster(timebase: CMTimebaseRef) -> CMClockOrTimebaseRef;
19883}
19884extern "C" {
19885pub fn CMTimebaseGetUltimateMasterClock(timebase: CMTimebaseRef) -> CMClockRef;
19887}
19888extern "C" {
19889pub fn CMTimebaseSetSourceClock(
19891 timebase: CMTimebaseRef,
19892 newSourceClock: CMClockRef,
19893 ) -> OSStatus;
19894}
19895extern "C" {
19896pub fn CMTimebaseSetSourceTimebase(
19898 timebase: CMTimebaseRef,
19899 newSourceTimebase: CMTimebaseRef,
19900 ) -> OSStatus;
19901}
19902extern "C" {
19903pub fn CMTimebaseGetTime(timebase: CMTimebaseRef) -> CMTime;
19905}
19906extern "C" {
19907pub fn CMTimebaseGetTimeWithTimeScale(
19909 timebase: CMTimebaseRef,
19910 timescale: CMTimeScale,
19911 method: CMTimeRoundingMethod,
19912 ) -> CMTime;
19913}
19914extern "C" {
19915pub fn CMTimebaseSetTime(timebase: CMTimebaseRef, time: CMTime) -> OSStatus;
19917}
19918extern "C" {
19919pub fn CMTimebaseSetAnchorTime(
19921 timebase: CMTimebaseRef,
19922 timebaseTime: CMTime,
19923 immediateSourceTime: CMTime,
19924 ) -> OSStatus;
19925}
19926extern "C" {
19927pub fn CMTimebaseGetRate(timebase: CMTimebaseRef) -> Float64;
19929}
19930extern "C" {
19931pub fn CMTimebaseGetTimeAndRate(
19933 timebase: CMTimebaseRef,
19934 timeOut: *mut CMTime,
19935 rateOut: *mut Float64,
19936 ) -> OSStatus;
19937}
19938extern "C" {
19939pub fn CMTimebaseSetRate(timebase: CMTimebaseRef, rate: Float64) -> OSStatus;
19941}
19942extern "C" {
19943pub fn CMTimebaseSetRateAndAnchorTime(
19945 timebase: CMTimebaseRef,
19946 rate: Float64,
19947 timebaseTime: CMTime,
19948 immediateSourceTime: CMTime,
19949 ) -> OSStatus;
19950}
19951extern "C" {
19952pub fn CMTimebaseGetEffectiveRate(timebase: CMTimebaseRef) -> Float64;
19954}
19955extern "C" {
19956pub fn CMTimebaseAddTimer(
19958 timebase: CMTimebaseRef,
19959 timer: CFRunLoopTimerRef,
19960 runloop: CFRunLoopRef,
19961 ) -> OSStatus;
19962}
19963extern "C" {
19964pub fn CMTimebaseRemoveTimer(timebase: CMTimebaseRef, timer: CFRunLoopTimerRef) -> OSStatus;
19966}
19967extern "C" {
19968pub fn CMTimebaseSetTimerNextFireTime(
19970 timebase: CMTimebaseRef,
19971 timer: CFRunLoopTimerRef,
19972 fireTime: CMTime,
19973 flags: u32,
19974 ) -> OSStatus;
19975}
19976extern "C" {
19977pub fn CMTimebaseSetTimerToFireImmediately(
19979 timebase: CMTimebaseRef,
19980 timer: CFRunLoopTimerRef,
19981 ) -> OSStatus;
19982}
19983extern "C" {
19984pub fn CMTimebaseAddTimerDispatchSource(
19986 timebase: CMTimebaseRef,
19987 timerSource: dispatch_source_t,
19988 ) -> OSStatus;
19989}
19990extern "C" {
19991pub fn CMTimebaseRemoveTimerDispatchSource(
19993 timebase: CMTimebaseRef,
19994 timerSource: dispatch_source_t,
19995 ) -> OSStatus;
19996}
19997extern "C" {
19998pub fn CMTimebaseSetTimerDispatchSourceNextFireTime(
20000 timebase: CMTimebaseRef,
20001 timerSource: dispatch_source_t,
20002 fireTime: CMTime,
20003 flags: u32,
20004 ) -> OSStatus;
20005}
20006extern "C" {
20007pub fn CMTimebaseSetTimerDispatchSourceToFireImmediately(
20009 timebase: CMTimebaseRef,
20010 timerSource: dispatch_source_t,
20011 ) -> OSStatus;
20012}
20013extern "C" {
20014pub fn CMSyncGetRelativeRate(
20016 ofClockOrTimebase: CMClockOrTimebaseRef,
20017 relativeToClockOrTimebase: CMClockOrTimebaseRef,
20018 ) -> Float64;
20019}
20020extern "C" {
20021pub fn CMSyncGetRelativeRateAndAnchorTime(
20023 ofClockOrTimebase: CMClockOrTimebaseRef,
20024 relativeToClockOrTimebase: CMClockOrTimebaseRef,
20025 outRelativeRate: *mut Float64,
20026 outOfClockOrTimebaseAnchorTime: *mut CMTime,
20027 outRelativeToClockOrTimebaseAnchorTime: *mut CMTime,
20028 ) -> OSStatus;
20029}
20030extern "C" {
20031pub fn CMSyncConvertTime(
20033 time: CMTime,
20034 fromClockOrTimebase: CMClockOrTimebaseRef,
20035 toClockOrTimebase: CMClockOrTimebaseRef,
20036 ) -> CMTime;
20037}
20038extern "C" {
20039pub fn CMSyncMightDrift(
20041 clockOrTimebase1: CMClockOrTimebaseRef,
20042 clockOrTimebase2: CMClockOrTimebaseRef,
20043 ) -> Boolean;
20044}
20045extern "C" {
20046pub fn CMSyncGetTime(clockOrTimebase: CMClockOrTimebaseRef) -> CMTime;
20048}
20049extern "C" {
20050pub fn CMTimebaseNotificationBarrier(timebase: CMTimebaseRef) -> OSStatus;
20052}
20053extern "C" {
20054pub static kCMTimebaseNotification_EffectiveRateChanged: CFStringRef;
20056}
20057extern "C" {
20058pub static kCMTimebaseNotification_TimeJumped: CFStringRef;
20060}
20061extern "C" {
20062pub static kCMTimebaseNotificationKey_EventTime: CFStringRef;
20064}
20065extern "C" {
20066pub static kCMTextMarkupAttribute_ForegroundColorARGB: CFStringRef;
20068}
20069extern "C" {
20070pub static kCMTextMarkupAttribute_BackgroundColorARGB: CFStringRef;
20072}
20073extern "C" {
20074pub static kCMTextMarkupAttribute_CharacterBackgroundColorARGB: CFStringRef;
20076}
20077extern "C" {
20078pub static kCMTextMarkupAttribute_BoldStyle: CFStringRef;
20080}
20081extern "C" {
20082pub static kCMTextMarkupAttribute_ItalicStyle: CFStringRef;
20084}
20085extern "C" {
20086pub static kCMTextMarkupAttribute_UnderlineStyle: CFStringRef;
20088}
20089extern "C" {
20090pub static kCMTextMarkupAttribute_FontFamilyName: CFStringRef;
20092}
20093extern "C" {
20094pub static kCMTextMarkupAttribute_FontFamilyNameList: CFStringRef;
20096}
20097extern "C" {
20098pub static kCMTextMarkupAttribute_GenericFontFamilyName: CFStringRef;
20100}
20101extern "C" {
20102pub static kCMTextMarkupGenericFontName_Default: CFStringRef;
20104}
20105extern "C" {
20106pub static kCMTextMarkupGenericFontName_Serif: CFStringRef;
20108}
20109extern "C" {
20110pub static kCMTextMarkupGenericFontName_SansSerif: CFStringRef;
20112}
20113extern "C" {
20114pub static kCMTextMarkupGenericFontName_Monospace: CFStringRef;
20116}
20117extern "C" {
20118pub static kCMTextMarkupGenericFontName_ProportionalSerif: CFStringRef;
20120}
20121extern "C" {
20122pub static kCMTextMarkupGenericFontName_ProportionalSansSerif: CFStringRef;
20124}
20125extern "C" {
20126pub static kCMTextMarkupGenericFontName_MonospaceSerif: CFStringRef;
20128}
20129extern "C" {
20130pub static kCMTextMarkupGenericFontName_MonospaceSansSerif: CFStringRef;
20132}
20133extern "C" {
20134pub static kCMTextMarkupGenericFontName_Casual: CFStringRef;
20136}
20137extern "C" {
20138pub static kCMTextMarkupGenericFontName_Cursive: CFStringRef;
20140}
20141extern "C" {
20142pub static kCMTextMarkupGenericFontName_Fantasy: CFStringRef;
20144}
20145extern "C" {
20146pub static kCMTextMarkupGenericFontName_SmallCapital: CFStringRef;
20148}
20149extern "C" {
20150pub static kCMTextMarkupAttribute_BaseFontSizePercentageRelativeToVideoHeight: CFStringRef;
20152}
20153extern "C" {
20154pub static kCMTextMarkupAttribute_RelativeFontSize: CFStringRef;
20156}
20157extern "C" {
20158pub static kCMTextMarkupAttribute_VerticalLayout: CFStringRef;
20160}
20161extern "C" {
20162pub static kCMTextVerticalLayout_LeftToRight: CFStringRef;
20164}
20165extern "C" {
20166pub static kCMTextVerticalLayout_RightToLeft: CFStringRef;
20168}
20169extern "C" {
20170pub static kCMTextMarkupAttribute_Alignment: CFStringRef;
20172}
20173extern "C" {
20174pub static kCMTextMarkupAlignmentType_Start: CFStringRef;
20176}
20177extern "C" {
20178pub static kCMTextMarkupAlignmentType_Middle: CFStringRef;
20180}
20181extern "C" {
20182pub static kCMTextMarkupAlignmentType_End: CFStringRef;
20184}
20185extern "C" {
20186pub static kCMTextMarkupAlignmentType_Left: CFStringRef;
20188}
20189extern "C" {
20190pub static kCMTextMarkupAlignmentType_Right: CFStringRef;
20192}
20193extern "C" {
20194pub static kCMTextMarkupAttribute_TextPositionPercentageRelativeToWritingDirection: CFStringRef;
20196}
20197extern "C" {
20198pub static kCMTextMarkupAttribute_OrthogonalLinePositionPercentageRelativeToWritingDirection:
20200 CFStringRef;
20201}
20202extern "C" {
20203pub static kCMTextMarkupAttribute_WritingDirectionSizePercentage: CFStringRef;
20205}
20206extern "C" {
20207pub static kCMTextMarkupAttribute_CharacterEdgeStyle: CFStringRef;
20209}
20210extern "C" {
20211pub static kCMTextMarkupCharacterEdgeStyle_None: CFStringRef;
20213}
20214extern "C" {
20215pub static kCMTextMarkupCharacterEdgeStyle_Raised: CFStringRef;
20217}
20218extern "C" {
20219pub static kCMTextMarkupCharacterEdgeStyle_Depressed: CFStringRef;
20221}
20222extern "C" {
20223pub static kCMTextMarkupCharacterEdgeStyle_Uniform: CFStringRef;
20225}
20226extern "C" {
20227pub static kCMTextMarkupCharacterEdgeStyle_DropShadow: CFStringRef;
20229}
20230pub const kCMMetadataIdentifierError_AllocationFailed: _bindgen_ty_1718 = -16300;
20232pub const kCMMetadataIdentifierError_RequiredParameterMissing: _bindgen_ty_1718 = -16301;
20234pub const kCMMetadataIdentifierError_BadKey: _bindgen_ty_1718 = -16302;
20236pub const kCMMetadataIdentifierError_BadKeyLength: _bindgen_ty_1718 = -16303;
20238pub const kCMMetadataIdentifierError_BadKeyType: _bindgen_ty_1718 = -16304;
20240pub const kCMMetadataIdentifierError_BadNumberKey: _bindgen_ty_1718 = -16305;
20242pub const kCMMetadataIdentifierError_BadKeySpace: _bindgen_ty_1718 = -16306;
20244pub const kCMMetadataIdentifierError_BadIdentifier: _bindgen_ty_1718 = -16307;
20246pub const kCMMetadataIdentifierError_NoKeyValueAvailable: _bindgen_ty_1718 = -16308;
20248pub type _bindgen_ty_1718 = ::core::ffi::c_int;
20250pub const kCMMetadataDataTypeRegistryError_AllocationFailed: _bindgen_ty_1719 = -16310;
20252pub const kCMMetadataDataTypeRegistryError_RequiredParameterMissing: _bindgen_ty_1719 = -16311;
20254pub const kCMMetadataDataTypeRegistryError_BadDataTypeIdentifier: _bindgen_ty_1719 = -16312;
20256pub const kCMMetadataDataTypeRegistryError_DataTypeAlreadyRegistered: _bindgen_ty_1719 = -16313;
20258pub const kCMMetadataDataTypeRegistryError_RequiresConformingBaseType: _bindgen_ty_1719 = -16314;
20260pub const kCMMetadataDataTypeRegistryError_MultipleConformingBaseTypes: _bindgen_ty_1719 = -16315;
20262pub type _bindgen_ty_1719 = ::core::ffi::c_int;
20264extern "C" {
20265pub static kCMMetadataKeySpace_QuickTimeUserData: CFStringRef;
20267}
20268extern "C" {
20269pub static kCMMetadataKeySpace_ISOUserData: CFStringRef;
20271}
20272extern "C" {
20273pub static kCMMetadataKeySpace_QuickTimeMetadata: CFStringRef;
20275}
20276extern "C" {
20277pub static kCMMetadataKeySpace_iTunes: CFStringRef;
20279}
20280extern "C" {
20281pub static kCMMetadataKeySpace_ID3: CFStringRef;
20283}
20284extern "C" {
20285pub static kCMMetadataKeySpace_Icy: CFStringRef;
20287}
20288extern "C" {
20289pub static kCMMetadataKeySpace_HLSDateRange: CFStringRef;
20291}
20292extern "C" {
20293pub static kCMMetadataIdentifier_QuickTimeMetadataLocation_ISO6709: CFStringRef;
20295}
20296extern "C" {
20297pub static kCMMetadataIdentifier_QuickTimeMetadataDirection_Facing: CFStringRef;
20299}
20300extern "C" {
20301pub static kCMMetadataIdentifier_QuickTimeMetadataPreferredAffineTransform: CFStringRef;
20303}
20304extern "C" {
20305pub static kCMMetadataIdentifier_QuickTimeMetadataVideoOrientation: CFStringRef;
20307}
20308extern "C" {
20309pub static kCMMetadataIdentifier_QuickTimeMetadataLivePhotoStillImageTransform: CFStringRef;
20311}
20312extern "C" {
20313pub static kCMMetadataIdentifier_QuickTimeMetadataLivePhotoStillImageTransformReferenceDimensions:
20315 CFStringRef;
20316}
20317extern "C" {
20318pub static kCMMetadataIdentifier_QuickTimeMetadataSegmentIdentifier: CFStringRef;
20320}
20321extern "C" {
20322pub static kCMMetadataIdentifier_QuickTimeMetadataSceneIlluminance: CFStringRef;
20324}
20325extern "C" {
20326pub static kCMMetadataIdentifier_QuickTimeMetadataSpatialAudioMix: CFStringRef;
20328}
20329extern "C" {
20330pub static kCMMetadataIdentifier_QuickTimeMetadataDisplayMaskRectangleMono: CFStringRef;
20332}
20333extern "C" {
20334pub static kCMMetadataIdentifier_QuickTimeMetadataDisplayMaskRectangleStereoLeft: CFStringRef;
20336}
20337extern "C" {
20338pub static kCMMetadataIdentifier_QuickTimeMetadataDisplayMaskRectangleStereoRight: CFStringRef;
20340}
20341extern "C" {
20342pub static kCMMetadataIdentifier_QuickTimeMetadataPresentationImmersiveMedia: CFStringRef;
20344}
20345extern "C" {
20346pub fn CMMetadataCreateIdentifierForKeyAndKeySpace(
20348 allocator: CFAllocatorRef,
20349 key: CFTypeRef,
20350 keySpace: CFStringRef,
20351 identifierOut: *mut CFStringRef,
20352 ) -> OSStatus;
20353}
20354extern "C" {
20355pub fn CMMetadataCreateKeyFromIdentifier(
20357 allocator: CFAllocatorRef,
20358 identifier: CFStringRef,
20359 keyOut: *mut CFTypeRef,
20360 ) -> OSStatus;
20361}
20362extern "C" {
20363pub fn CMMetadataCreateKeyFromIdentifierAsCFData(
20365 allocator: CFAllocatorRef,
20366 identifier: CFStringRef,
20367 keyOut: *mut CFDataRef,
20368 ) -> OSStatus;
20369}
20370extern "C" {
20371pub fn CMMetadataCreateKeySpaceFromIdentifier(
20373 allocator: CFAllocatorRef,
20374 identifier: CFStringRef,
20375 keySpaceOut: *mut CFStringRef,
20376 ) -> OSStatus;
20377}
20378extern "C" {
20379pub static kCMMetadataBaseDataType_RawData: CFStringRef;
20381}
20382extern "C" {
20383pub static kCMMetadataBaseDataType_UTF8: CFStringRef;
20385}
20386extern "C" {
20387pub static kCMMetadataBaseDataType_UTF16: CFStringRef;
20389}
20390extern "C" {
20391pub static kCMMetadataBaseDataType_GIF: CFStringRef;
20393}
20394extern "C" {
20395pub static kCMMetadataBaseDataType_JPEG: CFStringRef;
20397}
20398extern "C" {
20399pub static kCMMetadataBaseDataType_PNG: CFStringRef;
20401}
20402extern "C" {
20403pub static kCMMetadataBaseDataType_BMP: CFStringRef;
20405}
20406extern "C" {
20407pub static kCMMetadataBaseDataType_Float32: CFStringRef;
20409}
20410extern "C" {
20411pub static kCMMetadataBaseDataType_Float64: CFStringRef;
20413}
20414extern "C" {
20415pub static kCMMetadataBaseDataType_SInt8: CFStringRef;
20417}
20418extern "C" {
20419pub static kCMMetadataBaseDataType_SInt16: CFStringRef;
20421}
20422extern "C" {
20423pub static kCMMetadataBaseDataType_SInt32: CFStringRef;
20425}
20426extern "C" {
20427pub static kCMMetadataBaseDataType_SInt64: CFStringRef;
20429}
20430extern "C" {
20431pub static kCMMetadataBaseDataType_UInt8: CFStringRef;
20433}
20434extern "C" {
20435pub static kCMMetadataBaseDataType_UInt16: CFStringRef;
20437}
20438extern "C" {
20439pub static kCMMetadataBaseDataType_UInt32: CFStringRef;
20441}
20442extern "C" {
20443pub static kCMMetadataBaseDataType_UInt64: CFStringRef;
20445}
20446extern "C" {
20447pub static kCMMetadataBaseDataType_PointF32: CFStringRef;
20449}
20450extern "C" {
20451pub static kCMMetadataBaseDataType_DimensionsF32: CFStringRef;
20453}
20454extern "C" {
20455pub static kCMMetadataBaseDataType_RectF32: CFStringRef;
20457}
20458extern "C" {
20459pub static kCMMetadataBaseDataType_AffineTransformF64: CFStringRef;
20461}
20462extern "C" {
20463pub static kCMMetadataBaseDataType_PolygonF32: CFStringRef;
20465}
20466extern "C" {
20467pub static kCMMetadataBaseDataType_PolylineF32: CFStringRef;
20469}
20470extern "C" {
20471pub static kCMMetadataBaseDataType_JSON: CFStringRef;
20473}
20474extern "C" {
20475pub static kCMMetadataBaseDataType_PerspectiveTransformF64: CFStringRef;
20477}
20478extern "C" {
20479pub static kCMMetadataBaseDataType_RasterRectangleValue: CFStringRef;
20481}
20482extern "C" {
20483pub static kCMMetadataBaseDataType_ExtendedRasterRectangleValue: CFStringRef;
20485}
20486extern "C" {
20487pub static kCMMetadataDataType_QuickTimeMetadataLocation_ISO6709: CFStringRef;
20489}
20490extern "C" {
20491pub static kCMMetadataDataType_QuickTimeMetadataDirection: CFStringRef;
20493}
20494extern "C" {
20495pub static kCMMetadataDataType_QuickTimeMetadataUUID: CFStringRef;
20497}
20498extern "C" {
20499pub static kCMMetadataDataType_QuickTimeMetadataMilliLux: CFStringRef;
20501}
20502extern "C" {
20503pub fn CMMetadataDataTypeRegistryRegisterDataType(
20505 dataType: CFStringRef,
20506 description: CFStringRef,
20507 conformingDataTypes: CFArrayRef,
20508 ) -> OSStatus;
20509}
20510extern "C" {
20511pub fn CMMetadataDataTypeRegistryDataTypeIsRegistered(dataType: CFStringRef) -> Boolean;
20513}
20514extern "C" {
20515pub fn CMMetadataDataTypeRegistryGetDataTypeDescription(dataType: CFStringRef) -> CFStringRef;
20517}
20518extern "C" {
20519pub fn CMMetadataDataTypeRegistryGetConformingDataTypes(dataType: CFStringRef) -> CFArrayRef;
20521}
20522extern "C" {
20523pub fn CMMetadataDataTypeRegistryDataTypeConformsToDataType(
20525 dataType: CFStringRef,
20526 conformsToDataType: CFStringRef,
20527 ) -> Boolean;
20528}
20529extern "C" {
20530pub fn CMMetadataDataTypeRegistryGetBaseDataTypes() -> CFArrayRef;
20532}
20533extern "C" {
20534pub fn CMMetadataDataTypeRegistryDataTypeIsBaseDataType(dataType: CFStringRef) -> Boolean;
20536}
20537extern "C" {
20538pub fn CMMetadataDataTypeRegistryGetBaseDataTypeForConformingDataType(
20540 dataType: CFStringRef,
20541 ) -> CFStringRef;
20542}
20543extern "C" {
20544pub fn CMAudioClockCreate(allocator: CFAllocatorRef, clockOut: *mut CMClockRef) -> OSStatus;
20546}
20547pub type AudioObjectID = UInt32;
20549pub type AudioDeviceID = AudioObjectID;
20551extern "C" {
20552pub fn CMAudioDeviceClockCreate(
20554 allocator: CFAllocatorRef,
20555 deviceUID: CFStringRef,
20556 clockOut: *mut CMClockRef,
20557 ) -> OSStatus;
20558}
20559extern "C" {
20560pub fn CMAudioDeviceClockCreateFromAudioDeviceID(
20562 allocator: CFAllocatorRef,
20563 deviceID: AudioDeviceID,
20564 clockOut: *mut CMClockRef,
20565 ) -> OSStatus;
20566}
20567extern "C" {
20568pub fn CMAudioDeviceClockSetAudioDeviceUID(
20570 clock: CMClockRef,
20571 deviceUID: CFStringRef,
20572 ) -> OSStatus;
20573}
20574extern "C" {
20575pub fn CMAudioDeviceClockSetAudioDeviceID(
20577 clock: CMClockRef,
20578 deviceID: AudioDeviceID,
20579 ) -> OSStatus;
20580}
20581extern "C" {
20582pub fn CMAudioDeviceClockGetAudioDevice(
20584 clock: CMClockRef,
20585 deviceUIDOut: *mut CFStringRef,
20586 deviceIDOut: *mut AudioDeviceID,
20587 trackingDefaultDeviceOut: *mut Boolean,
20588 ) -> OSStatus;
20589}
20590pub type __builtin_va_list = *mut ::core::ffi::c_char;
20592#[repr(C)]
20593#[derive(Debug, Copy, Clone)]
20594pub struct _os_object_s {
20596 pub _address: u8,
20597}
20598#[repr(C)]
20599#[derive(Debug, Copy, Clone)]
20600pub struct dispatch_object_s {
20602 pub _address: u8,
20603}
20604#[repr(C)]
20605#[derive(Debug, Copy, Clone)]
20606pub struct dispatch_group_s {
20608 pub _address: u8,
20609}
20610#[repr(C)]
20611#[derive(Debug, Copy, Clone)]
20612pub struct dispatch_source_s {
20614 pub _address: u8,
20615}
20616#[repr(C)]
20617#[derive(Debug, Copy, Clone)]
20618pub struct dispatch_channel_s {
20620 pub _address: u8,
20621}
20622#[repr(C)]
20623#[derive(Debug, Copy, Clone)]
20624pub struct dispatch_mach_s {
20626 pub _address: u8,
20627}
20628#[repr(C)]
20629#[derive(Debug, Copy, Clone)]
20630pub struct dispatch_mach_msg_s {
20632 pub _address: u8,
20633}
20634#[repr(C)]
20635#[derive(Debug, Copy, Clone)]
20636pub struct dispatch_semaphore_s {
20638 pub _address: u8,
20639}
20640#[repr(C)]
20641#[derive(Debug, Copy, Clone)]
20642pub struct dispatch_io_s {
20644 pub _address: u8,
20645}