diff --git a/MODULE.bazel b/MODULE.bazel index 74c8ed707..34d9a0f60 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -195,7 +195,8 @@ crate.annotation( # `generate-bindings` is enabled for darwin so miniaudio's Rust bindings match # its CoreAudio C layout. Build scripts execute for the host, however, so a # macOS-hosted Linux cross-build also sees that feature. Use Cargo's TARGET to -# keep bindgen darwin-only and select pregenerated bindings for other targets. +# keep bindgen darwin-only and select checked GNU/musl bindings by compilation +# target, including ARM64's larger glibc pthread layouts. crate.annotation( crate = "maudio-sys", patches = ["//bazel/patches:maudio-sys-target-bindings.patch"], diff --git a/bazel/patches/maudio-sys-target-bindings.patch b/bazel/patches/maudio-sys-target-bindings.patch index 779ebda03..398ccbb27 100644 --- a/bazel/patches/maudio-sys-target-bindings.patch +++ b/bazel/patches/maudio-sys-target-bindings.patch @@ -1,3 +1,5 @@ +diff --git a/build.rs b/build.rs +index 419076b76e63bf1acbf92d0c7ffebfbe00fcebed..6abe69957113d92429b395e9d4b5cbc6a140a7c4 100644 --- a/build.rs +++ b/build.rs @@ -5,6 +5,12 @@ use cc::Build; @@ -13,7 +15,7 @@ let mut builder = bindgen::Builder::default() .header("native/miniaudio/miniaudio.h") .clang_arg("-Inative") -@@ -25,11 +31,17 @@ fn write_bindings(out_bindings: &std::path::Path) { +@@ -25,12 +31,20 @@ fn write_bindings(out_bindings: &std::path::Path) { #[cfg(not(feature = "generate-bindings"))] fn write_bindings(out_bindings: &std::path::Path) { @@ -28,11 +30,42824 @@ - .expect("Failed to copy pre-generated bindings to OUT_DIR"); - #[cfg(windows)] - std::fs::copy("src/pregen_bindings/windows.rs", out_bindings) -+ let source = if target.contains("windows") { -+ "src/pregen_bindings/windows.rs" -+ } else { -+ "src/pregen_bindings/unix.rs" ++ let source = match target { ++ "aarch64-unknown-linux-gnu" => "src/pregen_bindings/linux-aarch64-gnu.rs", ++ "aarch64-unknown-linux-musl" => "src/pregen_bindings/linux-aarch64-musl.rs", ++ "x86_64-unknown-linux-musl" => "src/pregen_bindings/linux-x86_64-musl.rs", ++ target if target.contains("windows") => "src/pregen_bindings/windows.rs", ++ _ => "src/pregen_bindings/unix.rs", + }; + std::fs::copy(source, out_bindings) .expect("Failed to copy pre-generated bindings to OUT_DIR"); } + +diff --git a/native/miniaudio_version_check.c b/native/miniaudio_version_check.c +index 58b5fee15748c92f21825948907b3535cb68bac9..b943c65b3e0c03f4442ba9569deaf27972853a73 100644 +--- a/native/miniaudio_version_check.c ++++ b/native/miniaudio_version_check.c +@@ -4,4 +4,11 @@ + #error "Unsupported miniaudio version. Expected 0.11.23." + #endif + +-int miniaudio_version_check(void) { return 0; } ++int miniaudio_version_check(void) { return 0; } ++/* Hardware-independent ABI probe used by OMP's Rust layout regression test. */ ++size_t omp_maudio_sizeof_mutex(void) { return sizeof(ma_mutex); } ++size_t omp_maudio_alignof_mutex(void) { return _Alignof(ma_mutex); } ++size_t omp_maudio_sizeof_context(void) { return sizeof(ma_context); } ++size_t omp_maudio_alignof_context(void) { return _Alignof(ma_context); } ++size_t omp_maudio_sizeof_device(void) { return sizeof(ma_device); } ++size_t omp_maudio_alignof_device(void) { return _Alignof(ma_device); } +diff --git a/src/lib.rs b/src/lib.rs +index af13b9ceb9f0816bc71ba9aebdc601047a77feae..479fc9172f91f475d5c89ce31bad5c4bd5ec9bf6 100644 +--- a/src/lib.rs ++++ b/src/lib.rs +@@ -4,19 +4,7 @@ + #![allow(dead_code)] + #![no_std] + +-#[cfg(feature = "generate-bindings")] + #[doc(hidden)] + pub mod ffi { +- // Check if the version is at least 1.70 + include!(concat!(env!("OUT_DIR"), "/bindings.rs")); + } +- +-#[cfg(not(feature = "generate-bindings"))] +-#[doc(hidden)] +-pub mod ffi { +- #[cfg(unix)] +- include!("pregen_bindings/unix.rs"); +- +- #[cfg(windows)] +- include!("pregen_bindings/windows.rs"); +-} +diff --git a/src/pregen_bindings/linux-aarch64-gnu.rs b/src/pregen_bindings/linux-aarch64-gnu.rs +new file mode 100644 +index 0000000000000000000000000000000000000000..1a810aa6dfb98dda7de868d0ab13d2660911bcde +--- /dev/null ++++ b/src/pregen_bindings/linux-aarch64-gnu.rs +@@ -0,0 +1,14533 @@ ++/* automatically generated by rust-bindgen 0.72.1 */ ++ ++#[doc = r" If Bindgen could only determine the size and alignment of a"] ++#[doc = r" type, it is represented like this."] ++#[derive(PartialEq, Copy, Clone, Debug, Hash)] ++#[repr(C)] ++pub struct __BindgenOpaqueArray(pub [T; N]); ++impl Default for __BindgenOpaqueArray { ++ fn default() -> Self { ++ Self([::default(); N]) ++ } ++} ++pub const MA_VERSION_MAJOR: u32 = 0; ++pub const MA_VERSION_MINOR: u32 = 11; ++pub const MA_VERSION_REVISION: u32 = 23; ++pub const MA_SIZEOF_PTR: u32 = 8; ++pub const MA_TRUE: u32 = 1; ++pub const MA_FALSE: u32 = 0; ++pub const MA_SIZE_MAX: u32 = 4294967295; ++pub const _PTHREAD_H: u32 = 1; ++pub const _FEATURES_H: u32 = 1; ++pub const _DEFAULT_SOURCE: u32 = 1; ++pub const __GLIBC_USE_ISOC2Y: u32 = 0; ++pub const __GLIBC_USE_ISOC23: u32 = 0; ++pub const __USE_ISOC11: u32 = 1; ++pub const __USE_ISOC99: u32 = 1; ++pub const __USE_ISOC95: u32 = 1; ++pub const __USE_POSIX_IMPLICITLY: u32 = 1; ++pub const _POSIX_SOURCE: u32 = 1; ++pub const _POSIX_C_SOURCE: u32 = 200809; ++pub const __USE_POSIX: u32 = 1; ++pub const __USE_POSIX2: u32 = 1; ++pub const __USE_POSIX199309: u32 = 1; ++pub const __USE_POSIX199506: u32 = 1; ++pub const __USE_XOPEN2K: u32 = 1; ++pub const __USE_XOPEN2K8: u32 = 1; ++pub const _ATFILE_SOURCE: u32 = 1; ++pub const __WORDSIZE: u32 = 64; ++pub const __WORDSIZE_TIME64_COMPAT32: u32 = 0; ++pub const __TIMESIZE: u32 = 64; ++pub const __USE_TIME_BITS64: u32 = 1; ++pub const __USE_MISC: u32 = 1; ++pub const __USE_ATFILE: u32 = 1; ++pub const __USE_FORTIFY_LEVEL: u32 = 0; ++pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0; ++pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0; ++pub const __GLIBC_USE_C23_STRTOL: u32 = 0; ++pub const _STDC_PREDEF_H: u32 = 1; ++pub const __STDC_IEC_559__: u32 = 1; ++pub const __STDC_IEC_60559_BFP__: u32 = 201404; ++pub const __STDC_IEC_559_COMPLEX__: u32 = 1; ++pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404; ++pub const __STDC_ISO_10646__: u32 = 201706; ++pub const __GNU_LIBRARY__: u32 = 6; ++pub const __GLIBC__: u32 = 2; ++pub const __GLIBC_MINOR__: u32 = 42; ++pub const _SYS_CDEFS_H: u32 = 1; ++pub const __glibc_c99_flexarr_available: u32 = 1; ++pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0; ++pub const __HAVE_GENERIC_SELECTION: u32 = 1; ++pub const _SCHED_H: u32 = 1; ++pub const _BITS_TYPES_H: u32 = 1; ++pub const _BITS_TYPESIZES_H: u32 = 1; ++pub const __OFF_T_MATCHES_OFF64_T: u32 = 1; ++pub const __INO_T_MATCHES_INO64_T: u32 = 1; ++pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1; ++pub const __STATFS_MATCHES_STATFS64: u32 = 1; ++pub const __FD_SETSIZE: u32 = 1024; ++pub const _BITS_TIME64_H: u32 = 1; ++pub const __time_t_defined: u32 = 1; ++pub const _STRUCT_TIMESPEC: u32 = 1; ++pub const _BITS_ENDIAN_H: u32 = 1; ++pub const __LITTLE_ENDIAN: u32 = 1234; ++pub const __BIG_ENDIAN: u32 = 4321; ++pub const __PDP_ENDIAN: u32 = 3412; ++pub const _BITS_ENDIANNESS_H: u32 = 1; ++pub const __BYTE_ORDER: u32 = 1234; ++pub const __FLOAT_WORD_ORDER: u32 = 1234; ++pub const _BITS_SCHED_H: u32 = 1; ++pub const SCHED_OTHER: u32 = 0; ++pub const SCHED_FIFO: u32 = 1; ++pub const SCHED_RR: u32 = 2; ++pub const _BITS_TYPES_STRUCT_SCHED_PARAM: u32 = 1; ++pub const _BITS_CPU_SET_H: u32 = 1; ++pub const __CPU_SETSIZE: u32 = 1024; ++pub const _TIME_H: u32 = 1; ++pub const _BITS_TIME_H: u32 = 1; ++pub const CLOCK_REALTIME: u32 = 0; ++pub const CLOCK_MONOTONIC: u32 = 1; ++pub const CLOCK_PROCESS_CPUTIME_ID: u32 = 2; ++pub const CLOCK_THREAD_CPUTIME_ID: u32 = 3; ++pub const CLOCK_MONOTONIC_RAW: u32 = 4; ++pub const CLOCK_REALTIME_COARSE: u32 = 5; ++pub const CLOCK_MONOTONIC_COARSE: u32 = 6; ++pub const CLOCK_BOOTTIME: u32 = 7; ++pub const CLOCK_REALTIME_ALARM: u32 = 8; ++pub const CLOCK_BOOTTIME_ALARM: u32 = 9; ++pub const CLOCK_TAI: u32 = 11; ++pub const TIMER_ABSTIME: u32 = 1; ++pub const __clock_t_defined: u32 = 1; ++pub const __struct_tm_defined: u32 = 1; ++pub const __clockid_t_defined: u32 = 1; ++pub const __timer_t_defined: u32 = 1; ++pub const __itimerspec_defined: u32 = 1; ++pub const _BITS_TYPES_LOCALE_T_H: u32 = 1; ++pub const _BITS_TYPES___LOCALE_T_H: u32 = 1; ++pub const TIME_UTC: u32 = 1; ++pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1; ++pub const _THREAD_SHARED_TYPES_H: u32 = 1; ++pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1; ++pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 64; ++pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 48; ++pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 8; ++pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 8; ++pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56; ++pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32; ++pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 8; ++pub const __SIZEOF_PTHREAD_COND_T: u32 = 48; ++pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8; ++pub const _THREAD_MUTEX_INTERNAL_H: u32 = 1; ++pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1; ++pub const __have_pthread_attr_t: u32 = 1; ++pub const _BITS_SETJMP_H: u32 = 1; ++pub const __jmp_buf_tag_defined: u32 = 1; ++pub const PTHREAD_STACK_MIN: u32 = 131072; ++pub const PTHREAD_ONCE_INIT: u32 = 0; ++pub const PTHREAD_BARRIER_SERIAL_THREAD: i32 = -1; ++pub const MA_SIMD_ALIGNMENT: u32 = 32; ++pub const __alignas_is_defined: u32 = 1; ++pub const __alignof_is_defined: u32 = 1; ++pub const MA_MIN_CHANNELS: u32 = 1; ++pub const MA_MAX_CHANNELS: u32 = 254; ++pub const MA_MAX_FILTER_ORDER: u32 = 8; ++pub const MA_MAX_LOG_CALLBACKS: u32 = 4; ++pub const MA_CHANNEL_INDEX_NULL: u32 = 255; ++pub const MA_DATA_SOURCE_SELF_MANAGED_RANGE_AND_LOOP_POINT: u32 = 1; ++pub const MA_DATA_FORMAT_FLAG_EXCLUSIVE_MODE: u32 = 2; ++pub const MA_MAX_DEVICE_NAME_LENGTH: u32 = 255; ++pub const MA_RESOURCE_MANAGER_MAX_JOB_THREAD_COUNT: u32 = 64; ++pub const MA_MAX_NODE_BUS_COUNT: u32 = 254; ++pub const MA_MAX_NODE_LOCAL_BUS_COUNT: u32 = 2; ++pub const MA_NODE_BUS_COUNT_UNKNOWN: u32 = 255; ++pub const MA_ENGINE_MAX_LISTENERS: u32 = 4; ++pub const MA_SOUND_SOURCE_CHANNEL_COUNT: u32 = 4294967295; ++pub type wchar_t = core::ffi::c_uint; ++#[repr(C)] ++#[repr(align(16))] ++#[derive(Debug, Copy, Clone)] ++pub struct max_align_t { ++ pub __clang_max_align_nonce1: core::ffi::c_longlong, ++ pub __bindgen_padding_0: u64, ++ pub __clang_max_align_nonce2: u128, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of max_align_t"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of max_align_t"][::core::mem::align_of::() - 16usize]; ++ ["Offset of field: max_align_t::__clang_max_align_nonce1"] ++ [::core::mem::offset_of!(max_align_t, __clang_max_align_nonce1) - 0usize]; ++ ["Offset of field: max_align_t::__clang_max_align_nonce2"] ++ [::core::mem::offset_of!(max_align_t, __clang_max_align_nonce2) - 16usize]; ++}; ++pub type ma_int8 = core::ffi::c_schar; ++pub type ma_uint8 = core::ffi::c_uchar; ++pub type ma_int16 = core::ffi::c_short; ++pub type ma_uint16 = core::ffi::c_ushort; ++pub type ma_int32 = core::ffi::c_int; ++pub type ma_uint32 = core::ffi::c_uint; ++pub type ma_int64 = core::ffi::c_longlong; ++pub type ma_uint64 = core::ffi::c_ulonglong; ++pub type ma_uintptr = ma_uint64; ++pub type ma_bool8 = ma_uint8; ++pub type ma_bool32 = ma_uint32; ++pub type ma_float = f32; ++pub type ma_double = f64; ++pub type ma_handle = *mut core::ffi::c_void; ++pub type ma_ptr = *mut core::ffi::c_void; ++pub type ma_proc = ::core::option::Option; ++pub type __u_char = core::ffi::c_uchar; ++pub type __u_short = core::ffi::c_ushort; ++pub type __u_int = core::ffi::c_uint; ++pub type __u_long = core::ffi::c_ulong; ++pub type __int8_t = core::ffi::c_schar; ++pub type __uint8_t = core::ffi::c_uchar; ++pub type __int16_t = core::ffi::c_short; ++pub type __uint16_t = core::ffi::c_ushort; ++pub type __int32_t = core::ffi::c_int; ++pub type __uint32_t = core::ffi::c_uint; ++pub type __int64_t = core::ffi::c_long; ++pub type __uint64_t = core::ffi::c_ulong; ++pub type __int_least8_t = __int8_t; ++pub type __uint_least8_t = __uint8_t; ++pub type __int_least16_t = __int16_t; ++pub type __uint_least16_t = __uint16_t; ++pub type __int_least32_t = __int32_t; ++pub type __uint_least32_t = __uint32_t; ++pub type __int_least64_t = __int64_t; ++pub type __uint_least64_t = __uint64_t; ++pub type __quad_t = core::ffi::c_long; ++pub type __u_quad_t = core::ffi::c_ulong; ++pub type __intmax_t = core::ffi::c_long; ++pub type __uintmax_t = core::ffi::c_ulong; ++pub type __dev_t = core::ffi::c_ulong; ++pub type __uid_t = core::ffi::c_uint; ++pub type __gid_t = core::ffi::c_uint; ++pub type __ino_t = core::ffi::c_ulong; ++pub type __ino64_t = core::ffi::c_ulong; ++pub type __mode_t = core::ffi::c_uint; ++pub type __nlink_t = core::ffi::c_uint; ++pub type __off_t = core::ffi::c_long; ++pub type __off64_t = core::ffi::c_long; ++pub type __pid_t = core::ffi::c_int; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __fsid_t { ++ pub __val: [core::ffi::c_int; 2usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __fsid_t"][::core::mem::size_of::<__fsid_t>() - 8usize]; ++ ["Alignment of __fsid_t"][::core::mem::align_of::<__fsid_t>() - 4usize]; ++ ["Offset of field: __fsid_t::__val"][::core::mem::offset_of!(__fsid_t, __val) - 0usize]; ++}; ++pub type __clock_t = core::ffi::c_long; ++pub type __rlim_t = core::ffi::c_ulong; ++pub type __rlim64_t = core::ffi::c_ulong; ++pub type __id_t = core::ffi::c_uint; ++pub type __time_t = core::ffi::c_long; ++pub type __useconds_t = core::ffi::c_uint; ++pub type __suseconds_t = core::ffi::c_long; ++pub type __suseconds64_t = core::ffi::c_long; ++pub type __daddr_t = core::ffi::c_int; ++pub type __key_t = core::ffi::c_int; ++pub type __clockid_t = core::ffi::c_int; ++pub type __timer_t = *mut core::ffi::c_void; ++pub type __blksize_t = core::ffi::c_int; ++pub type __blkcnt_t = core::ffi::c_long; ++pub type __blkcnt64_t = core::ffi::c_long; ++pub type __fsblkcnt_t = core::ffi::c_ulong; ++pub type __fsblkcnt64_t = core::ffi::c_ulong; ++pub type __fsfilcnt_t = core::ffi::c_ulong; ++pub type __fsfilcnt64_t = core::ffi::c_ulong; ++pub type __fsword_t = core::ffi::c_long; ++pub type __ssize_t = core::ffi::c_long; ++pub type __syscall_slong_t = core::ffi::c_long; ++pub type __syscall_ulong_t = core::ffi::c_ulong; ++pub type __loff_t = __off64_t; ++pub type __caddr_t = *mut core::ffi::c_char; ++pub type __intptr_t = core::ffi::c_long; ++pub type __socklen_t = core::ffi::c_uint; ++pub type __sig_atomic_t = core::ffi::c_int; ++pub type time_t = __time_t; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct timespec { ++ pub tv_sec: __time_t, ++ pub tv_nsec: __syscall_slong_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of timespec"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of timespec"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: timespec::tv_sec"][::core::mem::offset_of!(timespec, tv_sec) - 0usize]; ++ ["Offset of field: timespec::tv_nsec"][::core::mem::offset_of!(timespec, tv_nsec) - 8usize]; ++}; ++pub type pid_t = __pid_t; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sched_param { ++ pub sched_priority: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sched_param"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of sched_param"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: sched_param::sched_priority"] ++ [::core::mem::offset_of!(sched_param, sched_priority) - 0usize]; ++}; ++pub type __cpu_mask = core::ffi::c_ulong; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct cpu_set_t { ++ pub __bits: [__cpu_mask; 16usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of cpu_set_t"][::core::mem::size_of::() - 128usize]; ++ ["Alignment of cpu_set_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: cpu_set_t::__bits"][::core::mem::offset_of!(cpu_set_t, __bits) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn __sched_cpucount(__setsize: usize, __setp: *const cpu_set_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn __sched_cpualloc(__count: usize) -> *mut cpu_set_t; ++} ++unsafe extern "C" { ++ pub fn __sched_cpufree(__set: *mut cpu_set_t); ++} ++unsafe extern "C" { ++ pub fn sched_setparam(__pid: __pid_t, __param: *const sched_param) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_getparam(__pid: __pid_t, __param: *mut sched_param) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_setscheduler( ++ __pid: __pid_t, ++ __policy: core::ffi::c_int, ++ __param: *const sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_getscheduler(__pid: __pid_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_yield() -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_get_priority_max(__algorithm: core::ffi::c_int) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_get_priority_min(__algorithm: core::ffi::c_int) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_rr_get_interval(__pid: __pid_t, __t: *mut timespec) -> core::ffi::c_int; ++} ++pub type clock_t = __clock_t; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct tm { ++ pub tm_sec: core::ffi::c_int, ++ pub tm_min: core::ffi::c_int, ++ pub tm_hour: core::ffi::c_int, ++ pub tm_mday: core::ffi::c_int, ++ pub tm_mon: core::ffi::c_int, ++ pub tm_year: core::ffi::c_int, ++ pub tm_wday: core::ffi::c_int, ++ pub tm_yday: core::ffi::c_int, ++ pub tm_isdst: core::ffi::c_int, ++ pub tm_gmtoff: core::ffi::c_long, ++ pub tm_zone: *const core::ffi::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of tm"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of tm"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: tm::tm_sec"][::core::mem::offset_of!(tm, tm_sec) - 0usize]; ++ ["Offset of field: tm::tm_min"][::core::mem::offset_of!(tm, tm_min) - 4usize]; ++ ["Offset of field: tm::tm_hour"][::core::mem::offset_of!(tm, tm_hour) - 8usize]; ++ ["Offset of field: tm::tm_mday"][::core::mem::offset_of!(tm, tm_mday) - 12usize]; ++ ["Offset of field: tm::tm_mon"][::core::mem::offset_of!(tm, tm_mon) - 16usize]; ++ ["Offset of field: tm::tm_year"][::core::mem::offset_of!(tm, tm_year) - 20usize]; ++ ["Offset of field: tm::tm_wday"][::core::mem::offset_of!(tm, tm_wday) - 24usize]; ++ ["Offset of field: tm::tm_yday"][::core::mem::offset_of!(tm, tm_yday) - 28usize]; ++ ["Offset of field: tm::tm_isdst"][::core::mem::offset_of!(tm, tm_isdst) - 32usize]; ++ ["Offset of field: tm::tm_gmtoff"][::core::mem::offset_of!(tm, tm_gmtoff) - 40usize]; ++ ["Offset of field: tm::tm_zone"][::core::mem::offset_of!(tm, tm_zone) - 48usize]; ++}; ++pub type clockid_t = __clockid_t; ++pub type timer_t = __timer_t; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct itimerspec { ++ pub it_interval: timespec, ++ pub it_value: timespec, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of itimerspec"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of itimerspec"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: itimerspec::it_interval"] ++ [::core::mem::offset_of!(itimerspec, it_interval) - 0usize]; ++ ["Offset of field: itimerspec::it_value"] ++ [::core::mem::offset_of!(itimerspec, it_value) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sigevent { ++ _unused: [u8; 0], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __locale_struct { ++ pub __locales: [*mut __locale_data; 13usize], ++ pub __ctype_b: *const core::ffi::c_ushort, ++ pub __ctype_tolower: *const core::ffi::c_int, ++ pub __ctype_toupper: *const core::ffi::c_int, ++ pub __names: [*const core::ffi::c_char; 13usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __locale_struct"][::core::mem::size_of::<__locale_struct>() - 232usize]; ++ ["Alignment of __locale_struct"][::core::mem::align_of::<__locale_struct>() - 8usize]; ++ ["Offset of field: __locale_struct::__locales"] ++ [::core::mem::offset_of!(__locale_struct, __locales) - 0usize]; ++ ["Offset of field: __locale_struct::__ctype_b"] ++ [::core::mem::offset_of!(__locale_struct, __ctype_b) - 104usize]; ++ ["Offset of field: __locale_struct::__ctype_tolower"] ++ [::core::mem::offset_of!(__locale_struct, __ctype_tolower) - 112usize]; ++ ["Offset of field: __locale_struct::__ctype_toupper"] ++ [::core::mem::offset_of!(__locale_struct, __ctype_toupper) - 120usize]; ++ ["Offset of field: __locale_struct::__names"] ++ [::core::mem::offset_of!(__locale_struct, __names) - 128usize]; ++}; ++pub type __locale_t = *mut __locale_struct; ++pub type locale_t = __locale_t; ++unsafe extern "C" { ++ pub fn clock() -> clock_t; ++} ++unsafe extern "C" { ++ pub fn time(__timer: *mut time_t) -> time_t; ++} ++unsafe extern "C" { ++ pub fn difftime(__time1: time_t, __time0: time_t) -> f64; ++} ++unsafe extern "C" { ++ pub fn mktime(__tp: *mut tm) -> time_t; ++} ++unsafe extern "C" { ++ pub fn strftime( ++ __s: *mut core::ffi::c_char, ++ __maxsize: usize, ++ __format: *const core::ffi::c_char, ++ __tp: *const tm, ++ ) -> usize; ++} ++unsafe extern "C" { ++ pub fn strftime_l( ++ __s: *mut core::ffi::c_char, ++ __maxsize: usize, ++ __format: *const core::ffi::c_char, ++ __tp: *const tm, ++ __loc: locale_t, ++ ) -> usize; ++} ++unsafe extern "C" { ++ pub fn gmtime(__timer: *const time_t) -> *mut tm; ++} ++unsafe extern "C" { ++ pub fn localtime(__timer: *const time_t) -> *mut tm; ++} ++unsafe extern "C" { ++ pub fn gmtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm; ++} ++unsafe extern "C" { ++ pub fn localtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm; ++} ++unsafe extern "C" { ++ pub fn asctime(__tp: *const tm) -> *mut core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ctime(__timer: *const time_t) -> *mut core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn asctime_r(__tp: *const tm, __buf: *mut core::ffi::c_char) -> *mut core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ctime_r(__timer: *const time_t, __buf: *mut core::ffi::c_char) ++ -> *mut core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub static mut __tzname: [*mut core::ffi::c_char; 2usize]; ++} ++unsafe extern "C" { ++ pub static mut __daylight: core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub static mut __timezone: core::ffi::c_long; ++} ++unsafe extern "C" { ++ pub static mut tzname: [*mut core::ffi::c_char; 2usize]; ++} ++unsafe extern "C" { ++ pub fn tzset(); ++} ++unsafe extern "C" { ++ pub static mut daylight: core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub static mut timezone: core::ffi::c_long; ++} ++unsafe extern "C" { ++ pub fn timegm(__tp: *mut tm) -> time_t; ++} ++unsafe extern "C" { ++ pub fn timelocal(__tp: *mut tm) -> time_t; ++} ++unsafe extern "C" { ++ pub fn dysize(__year: core::ffi::c_int) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn nanosleep( ++ __requested_time: *const timespec, ++ __remaining: *mut timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_getres(__clock_id: clockid_t, __res: *mut timespec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_gettime(__clock_id: clockid_t, __tp: *mut timespec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_settime(__clock_id: clockid_t, __tp: *const timespec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_nanosleep( ++ __clock_id: clockid_t, ++ __flags: core::ffi::c_int, ++ __req: *const timespec, ++ __rem: *mut timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_getcpuclockid(__pid: pid_t, __clock_id: *mut clockid_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timer_create( ++ __clock_id: clockid_t, ++ __evp: *mut sigevent, ++ __timerid: *mut timer_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timer_delete(__timerid: timer_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timer_settime( ++ __timerid: timer_t, ++ __flags: core::ffi::c_int, ++ __value: *const itimerspec, ++ __ovalue: *mut itimerspec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timer_gettime(__timerid: timer_t, __value: *mut itimerspec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timer_getoverrun(__timerid: timer_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timespec_get(__ts: *mut timespec, __base: core::ffi::c_int) -> core::ffi::c_int; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union __atomic_wide_counter { ++ pub __value64: core::ffi::c_ulonglong, ++ pub __value32: __atomic_wide_counter__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __atomic_wide_counter__bindgen_ty_1 { ++ pub __low: core::ffi::c_uint, ++ pub __high: core::ffi::c_uint, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __atomic_wide_counter__bindgen_ty_1"] ++ [::core::mem::size_of::<__atomic_wide_counter__bindgen_ty_1>() - 8usize]; ++ ["Alignment of __atomic_wide_counter__bindgen_ty_1"] ++ [::core::mem::align_of::<__atomic_wide_counter__bindgen_ty_1>() - 4usize]; ++ ["Offset of field: __atomic_wide_counter__bindgen_ty_1::__low"] ++ [::core::mem::offset_of!(__atomic_wide_counter__bindgen_ty_1, __low) - 0usize]; ++ ["Offset of field: __atomic_wide_counter__bindgen_ty_1::__high"] ++ [::core::mem::offset_of!(__atomic_wide_counter__bindgen_ty_1, __high) - 4usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __atomic_wide_counter"][::core::mem::size_of::<__atomic_wide_counter>() - 8usize]; ++ ["Alignment of __atomic_wide_counter"] ++ [::core::mem::align_of::<__atomic_wide_counter>() - 8usize]; ++ ["Offset of field: __atomic_wide_counter::__value64"] ++ [::core::mem::offset_of!(__atomic_wide_counter, __value64) - 0usize]; ++ ["Offset of field: __atomic_wide_counter::__value32"] ++ [::core::mem::offset_of!(__atomic_wide_counter, __value32) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __pthread_internal_list { ++ pub __prev: *mut __pthread_internal_list, ++ pub __next: *mut __pthread_internal_list, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __pthread_internal_list"] ++ [::core::mem::size_of::<__pthread_internal_list>() - 16usize]; ++ ["Alignment of __pthread_internal_list"] ++ [::core::mem::align_of::<__pthread_internal_list>() - 8usize]; ++ ["Offset of field: __pthread_internal_list::__prev"] ++ [::core::mem::offset_of!(__pthread_internal_list, __prev) - 0usize]; ++ ["Offset of field: __pthread_internal_list::__next"] ++ [::core::mem::offset_of!(__pthread_internal_list, __next) - 8usize]; ++}; ++pub type __pthread_list_t = __pthread_internal_list; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __pthread_internal_slist { ++ pub __next: *mut __pthread_internal_slist, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __pthread_internal_slist"] ++ [::core::mem::size_of::<__pthread_internal_slist>() - 8usize]; ++ ["Alignment of __pthread_internal_slist"] ++ [::core::mem::align_of::<__pthread_internal_slist>() - 8usize]; ++ ["Offset of field: __pthread_internal_slist::__next"] ++ [::core::mem::offset_of!(__pthread_internal_slist, __next) - 0usize]; ++}; ++pub type __pthread_slist_t = __pthread_internal_slist; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __pthread_mutex_s { ++ pub __lock: core::ffi::c_int, ++ pub __count: core::ffi::c_uint, ++ pub __owner: core::ffi::c_int, ++ pub __nusers: core::ffi::c_uint, ++ pub __kind: core::ffi::c_int, ++ pub __spins: core::ffi::c_int, ++ pub __list: __pthread_list_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __pthread_mutex_s"][::core::mem::size_of::<__pthread_mutex_s>() - 40usize]; ++ ["Alignment of __pthread_mutex_s"][::core::mem::align_of::<__pthread_mutex_s>() - 8usize]; ++ ["Offset of field: __pthread_mutex_s::__lock"] ++ [::core::mem::offset_of!(__pthread_mutex_s, __lock) - 0usize]; ++ ["Offset of field: __pthread_mutex_s::__count"] ++ [::core::mem::offset_of!(__pthread_mutex_s, __count) - 4usize]; ++ ["Offset of field: __pthread_mutex_s::__owner"] ++ [::core::mem::offset_of!(__pthread_mutex_s, __owner) - 8usize]; ++ ["Offset of field: __pthread_mutex_s::__nusers"] ++ [::core::mem::offset_of!(__pthread_mutex_s, __nusers) - 12usize]; ++ ["Offset of field: __pthread_mutex_s::__kind"] ++ [::core::mem::offset_of!(__pthread_mutex_s, __kind) - 16usize]; ++ ["Offset of field: __pthread_mutex_s::__spins"] ++ [::core::mem::offset_of!(__pthread_mutex_s, __spins) - 20usize]; ++ ["Offset of field: __pthread_mutex_s::__list"] ++ [::core::mem::offset_of!(__pthread_mutex_s, __list) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __pthread_rwlock_arch_t { ++ pub __readers: core::ffi::c_uint, ++ pub __writers: core::ffi::c_uint, ++ pub __wrphase_futex: core::ffi::c_uint, ++ pub __writers_futex: core::ffi::c_uint, ++ pub __pad3: core::ffi::c_uint, ++ pub __pad4: core::ffi::c_uint, ++ pub __cur_writer: core::ffi::c_int, ++ pub __shared: core::ffi::c_int, ++ pub __pad1: core::ffi::c_ulong, ++ pub __pad2: core::ffi::c_ulong, ++ pub __flags: core::ffi::c_uint, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __pthread_rwlock_arch_t"] ++ [::core::mem::size_of::<__pthread_rwlock_arch_t>() - 56usize]; ++ ["Alignment of __pthread_rwlock_arch_t"] ++ [::core::mem::align_of::<__pthread_rwlock_arch_t>() - 8usize]; ++ ["Offset of field: __pthread_rwlock_arch_t::__readers"] ++ [::core::mem::offset_of!(__pthread_rwlock_arch_t, __readers) - 0usize]; ++ ["Offset of field: __pthread_rwlock_arch_t::__writers"] ++ [::core::mem::offset_of!(__pthread_rwlock_arch_t, __writers) - 4usize]; ++ ["Offset of field: __pthread_rwlock_arch_t::__wrphase_futex"] ++ [::core::mem::offset_of!(__pthread_rwlock_arch_t, __wrphase_futex) - 8usize]; ++ ["Offset of field: __pthread_rwlock_arch_t::__writers_futex"] ++ [::core::mem::offset_of!(__pthread_rwlock_arch_t, __writers_futex) - 12usize]; ++ ["Offset of field: __pthread_rwlock_arch_t::__pad3"] ++ [::core::mem::offset_of!(__pthread_rwlock_arch_t, __pad3) - 16usize]; ++ ["Offset of field: __pthread_rwlock_arch_t::__pad4"] ++ [::core::mem::offset_of!(__pthread_rwlock_arch_t, __pad4) - 20usize]; ++ ["Offset of field: __pthread_rwlock_arch_t::__cur_writer"] ++ [::core::mem::offset_of!(__pthread_rwlock_arch_t, __cur_writer) - 24usize]; ++ ["Offset of field: __pthread_rwlock_arch_t::__shared"] ++ [::core::mem::offset_of!(__pthread_rwlock_arch_t, __shared) - 28usize]; ++ ["Offset of field: __pthread_rwlock_arch_t::__pad1"] ++ [::core::mem::offset_of!(__pthread_rwlock_arch_t, __pad1) - 32usize]; ++ ["Offset of field: __pthread_rwlock_arch_t::__pad2"] ++ [::core::mem::offset_of!(__pthread_rwlock_arch_t, __pad2) - 40usize]; ++ ["Offset of field: __pthread_rwlock_arch_t::__flags"] ++ [::core::mem::offset_of!(__pthread_rwlock_arch_t, __flags) - 48usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct __pthread_cond_s { ++ pub __wseq: __atomic_wide_counter, ++ pub __g1_start: __atomic_wide_counter, ++ pub __g_size: [core::ffi::c_uint; 2usize], ++ pub __g1_orig_size: core::ffi::c_uint, ++ pub __wrefs: core::ffi::c_uint, ++ pub __g_signals: [core::ffi::c_uint; 2usize], ++ pub __unused_initialized_1: core::ffi::c_uint, ++ pub __unused_initialized_2: core::ffi::c_uint, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __pthread_cond_s"][::core::mem::size_of::<__pthread_cond_s>() - 48usize]; ++ ["Alignment of __pthread_cond_s"][::core::mem::align_of::<__pthread_cond_s>() - 8usize]; ++ ["Offset of field: __pthread_cond_s::__wseq"] ++ [::core::mem::offset_of!(__pthread_cond_s, __wseq) - 0usize]; ++ ["Offset of field: __pthread_cond_s::__g1_start"] ++ [::core::mem::offset_of!(__pthread_cond_s, __g1_start) - 8usize]; ++ ["Offset of field: __pthread_cond_s::__g_size"] ++ [::core::mem::offset_of!(__pthread_cond_s, __g_size) - 16usize]; ++ ["Offset of field: __pthread_cond_s::__g1_orig_size"] ++ [::core::mem::offset_of!(__pthread_cond_s, __g1_orig_size) - 24usize]; ++ ["Offset of field: __pthread_cond_s::__wrefs"] ++ [::core::mem::offset_of!(__pthread_cond_s, __wrefs) - 28usize]; ++ ["Offset of field: __pthread_cond_s::__g_signals"] ++ [::core::mem::offset_of!(__pthread_cond_s, __g_signals) - 32usize]; ++ ["Offset of field: __pthread_cond_s::__unused_initialized_1"] ++ [::core::mem::offset_of!(__pthread_cond_s, __unused_initialized_1) - 40usize]; ++ ["Offset of field: __pthread_cond_s::__unused_initialized_2"] ++ [::core::mem::offset_of!(__pthread_cond_s, __unused_initialized_2) - 44usize]; ++}; ++pub type __tss_t = core::ffi::c_uint; ++pub type __thrd_t = core::ffi::c_ulong; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __once_flag { ++ pub __data: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __once_flag"][::core::mem::size_of::<__once_flag>() - 4usize]; ++ ["Alignment of __once_flag"][::core::mem::align_of::<__once_flag>() - 4usize]; ++ ["Offset of field: __once_flag::__data"][::core::mem::offset_of!(__once_flag, __data) - 0usize]; ++}; ++pub type pthread_t = core::ffi::c_ulong; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_mutexattr_t { ++ pub __size: [core::ffi::c_char; 8usize], ++ pub __align: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_mutexattr_t"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of pthread_mutexattr_t"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: pthread_mutexattr_t::__size"] ++ [::core::mem::offset_of!(pthread_mutexattr_t, __size) - 0usize]; ++ ["Offset of field: pthread_mutexattr_t::__align"] ++ [::core::mem::offset_of!(pthread_mutexattr_t, __align) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_condattr_t { ++ pub __size: [core::ffi::c_char; 8usize], ++ pub __align: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_condattr_t"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of pthread_condattr_t"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: pthread_condattr_t::__size"] ++ [::core::mem::offset_of!(pthread_condattr_t, __size) - 0usize]; ++ ["Offset of field: pthread_condattr_t::__align"] ++ [::core::mem::offset_of!(pthread_condattr_t, __align) - 0usize]; ++}; ++pub type pthread_key_t = core::ffi::c_uint; ++pub type pthread_once_t = core::ffi::c_int; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_attr_t { ++ pub __size: [core::ffi::c_char; 64usize], ++ pub __align: core::ffi::c_long, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_attr_t"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of pthread_attr_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_attr_t::__size"] ++ [::core::mem::offset_of!(pthread_attr_t, __size) - 0usize]; ++ ["Offset of field: pthread_attr_t::__align"] ++ [::core::mem::offset_of!(pthread_attr_t, __align) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_mutex_t { ++ pub __data: __pthread_mutex_s, ++ pub __size: [core::ffi::c_char; 48usize], ++ pub __align: core::ffi::c_long, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_mutex_t"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of pthread_mutex_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_mutex_t::__data"] ++ [::core::mem::offset_of!(pthread_mutex_t, __data) - 0usize]; ++ ["Offset of field: pthread_mutex_t::__size"] ++ [::core::mem::offset_of!(pthread_mutex_t, __size) - 0usize]; ++ ["Offset of field: pthread_mutex_t::__align"] ++ [::core::mem::offset_of!(pthread_mutex_t, __align) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_cond_t { ++ pub __data: __pthread_cond_s, ++ pub __size: [core::ffi::c_char; 48usize], ++ pub __align: core::ffi::c_longlong, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_cond_t"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of pthread_cond_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_cond_t::__data"] ++ [::core::mem::offset_of!(pthread_cond_t, __data) - 0usize]; ++ ["Offset of field: pthread_cond_t::__size"] ++ [::core::mem::offset_of!(pthread_cond_t, __size) - 0usize]; ++ ["Offset of field: pthread_cond_t::__align"] ++ [::core::mem::offset_of!(pthread_cond_t, __align) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_rwlock_t { ++ pub __data: __pthread_rwlock_arch_t, ++ pub __size: [core::ffi::c_char; 56usize], ++ pub __align: core::ffi::c_long, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_rwlock_t"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of pthread_rwlock_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_rwlock_t::__data"] ++ [::core::mem::offset_of!(pthread_rwlock_t, __data) - 0usize]; ++ ["Offset of field: pthread_rwlock_t::__size"] ++ [::core::mem::offset_of!(pthread_rwlock_t, __size) - 0usize]; ++ ["Offset of field: pthread_rwlock_t::__align"] ++ [::core::mem::offset_of!(pthread_rwlock_t, __align) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_rwlockattr_t { ++ pub __size: [core::ffi::c_char; 8usize], ++ pub __align: core::ffi::c_long, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_rwlockattr_t"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of pthread_rwlockattr_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_rwlockattr_t::__size"] ++ [::core::mem::offset_of!(pthread_rwlockattr_t, __size) - 0usize]; ++ ["Offset of field: pthread_rwlockattr_t::__align"] ++ [::core::mem::offset_of!(pthread_rwlockattr_t, __align) - 0usize]; ++}; ++pub type pthread_spinlock_t = core::ffi::c_int; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_barrier_t { ++ pub __size: [core::ffi::c_char; 32usize], ++ pub __align: core::ffi::c_long, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_barrier_t"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of pthread_barrier_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_barrier_t::__size"] ++ [::core::mem::offset_of!(pthread_barrier_t, __size) - 0usize]; ++ ["Offset of field: pthread_barrier_t::__align"] ++ [::core::mem::offset_of!(pthread_barrier_t, __align) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_barrierattr_t { ++ pub __size: [core::ffi::c_char; 8usize], ++ pub __align: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_barrierattr_t"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of pthread_barrierattr_t"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: pthread_barrierattr_t::__size"] ++ [::core::mem::offset_of!(pthread_barrierattr_t, __size) - 0usize]; ++ ["Offset of field: pthread_barrierattr_t::__align"] ++ [::core::mem::offset_of!(pthread_barrierattr_t, __align) - 0usize]; ++}; ++pub type __jmp_buf = [core::ffi::c_ulonglong; 22usize]; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __sigset_t { ++ pub __val: [core::ffi::c_ulong; 16usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __sigset_t"][::core::mem::size_of::<__sigset_t>() - 128usize]; ++ ["Alignment of __sigset_t"][::core::mem::align_of::<__sigset_t>() - 8usize]; ++ ["Offset of field: __sigset_t::__val"][::core::mem::offset_of!(__sigset_t, __val) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __jmp_buf_tag { ++ pub __jmpbuf: __jmp_buf, ++ pub __mask_was_saved: core::ffi::c_int, ++ pub __saved_mask: __sigset_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __jmp_buf_tag"][::core::mem::size_of::<__jmp_buf_tag>() - 312usize]; ++ ["Alignment of __jmp_buf_tag"][::core::mem::align_of::<__jmp_buf_tag>() - 8usize]; ++ ["Offset of field: __jmp_buf_tag::__jmpbuf"] ++ [::core::mem::offset_of!(__jmp_buf_tag, __jmpbuf) - 0usize]; ++ ["Offset of field: __jmp_buf_tag::__mask_was_saved"] ++ [::core::mem::offset_of!(__jmp_buf_tag, __mask_was_saved) - 176usize]; ++ ["Offset of field: __jmp_buf_tag::__saved_mask"] ++ [::core::mem::offset_of!(__jmp_buf_tag, __saved_mask) - 184usize]; ++}; ++pub const PTHREAD_CREATE_JOINABLE: _bindgen_ty_1 = 0; ++pub const PTHREAD_CREATE_DETACHED: _bindgen_ty_1 = 1; ++pub type _bindgen_ty_1 = core::ffi::c_uint; ++pub const PTHREAD_MUTEX_TIMED_NP: _bindgen_ty_2 = 0; ++pub const PTHREAD_MUTEX_RECURSIVE_NP: _bindgen_ty_2 = 1; ++pub const PTHREAD_MUTEX_ERRORCHECK_NP: _bindgen_ty_2 = 2; ++pub const PTHREAD_MUTEX_ADAPTIVE_NP: _bindgen_ty_2 = 3; ++pub const PTHREAD_MUTEX_NORMAL: _bindgen_ty_2 = 0; ++pub const PTHREAD_MUTEX_RECURSIVE: _bindgen_ty_2 = 1; ++pub const PTHREAD_MUTEX_ERRORCHECK: _bindgen_ty_2 = 2; ++pub const PTHREAD_MUTEX_DEFAULT: _bindgen_ty_2 = 0; ++pub type _bindgen_ty_2 = core::ffi::c_uint; ++pub const PTHREAD_MUTEX_STALLED: _bindgen_ty_3 = 0; ++pub const PTHREAD_MUTEX_STALLED_NP: _bindgen_ty_3 = 0; ++pub const PTHREAD_MUTEX_ROBUST: _bindgen_ty_3 = 1; ++pub const PTHREAD_MUTEX_ROBUST_NP: _bindgen_ty_3 = 1; ++pub type _bindgen_ty_3 = core::ffi::c_uint; ++pub const PTHREAD_PRIO_NONE: _bindgen_ty_4 = 0; ++pub const PTHREAD_PRIO_INHERIT: _bindgen_ty_4 = 1; ++pub const PTHREAD_PRIO_PROTECT: _bindgen_ty_4 = 2; ++pub type _bindgen_ty_4 = core::ffi::c_uint; ++pub const PTHREAD_RWLOCK_PREFER_READER_NP: _bindgen_ty_5 = 0; ++pub const PTHREAD_RWLOCK_PREFER_WRITER_NP: _bindgen_ty_5 = 1; ++pub const PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP: _bindgen_ty_5 = 2; ++pub const PTHREAD_RWLOCK_DEFAULT_NP: _bindgen_ty_5 = 0; ++pub type _bindgen_ty_5 = core::ffi::c_uint; ++pub const PTHREAD_INHERIT_SCHED: _bindgen_ty_6 = 0; ++pub const PTHREAD_EXPLICIT_SCHED: _bindgen_ty_6 = 1; ++pub type _bindgen_ty_6 = core::ffi::c_uint; ++pub const PTHREAD_SCOPE_SYSTEM: _bindgen_ty_7 = 0; ++pub const PTHREAD_SCOPE_PROCESS: _bindgen_ty_7 = 1; ++pub type _bindgen_ty_7 = core::ffi::c_uint; ++pub const PTHREAD_PROCESS_PRIVATE: _bindgen_ty_8 = 0; ++pub const PTHREAD_PROCESS_SHARED: _bindgen_ty_8 = 1; ++pub type _bindgen_ty_8 = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct _pthread_cleanup_buffer { ++ pub __routine: ::core::option::Option, ++ pub __arg: *mut core::ffi::c_void, ++ pub __canceltype: core::ffi::c_int, ++ pub __prev: *mut _pthread_cleanup_buffer, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of _pthread_cleanup_buffer"] ++ [::core::mem::size_of::<_pthread_cleanup_buffer>() - 32usize]; ++ ["Alignment of _pthread_cleanup_buffer"] ++ [::core::mem::align_of::<_pthread_cleanup_buffer>() - 8usize]; ++ ["Offset of field: _pthread_cleanup_buffer::__routine"] ++ [::core::mem::offset_of!(_pthread_cleanup_buffer, __routine) - 0usize]; ++ ["Offset of field: _pthread_cleanup_buffer::__arg"] ++ [::core::mem::offset_of!(_pthread_cleanup_buffer, __arg) - 8usize]; ++ ["Offset of field: _pthread_cleanup_buffer::__canceltype"] ++ [::core::mem::offset_of!(_pthread_cleanup_buffer, __canceltype) - 16usize]; ++ ["Offset of field: _pthread_cleanup_buffer::__prev"] ++ [::core::mem::offset_of!(_pthread_cleanup_buffer, __prev) - 24usize]; ++}; ++pub const PTHREAD_CANCEL_ENABLE: _bindgen_ty_9 = 0; ++pub const PTHREAD_CANCEL_DISABLE: _bindgen_ty_9 = 1; ++pub type _bindgen_ty_9 = core::ffi::c_uint; ++pub const PTHREAD_CANCEL_DEFERRED: _bindgen_ty_10 = 0; ++pub const PTHREAD_CANCEL_ASYNCHRONOUS: _bindgen_ty_10 = 1; ++pub type _bindgen_ty_10 = core::ffi::c_uint; ++unsafe extern "C" { ++ pub fn pthread_create( ++ __newthread: *mut pthread_t, ++ __attr: *const pthread_attr_t, ++ __start_routine: ::core::option::Option< ++ unsafe extern "C" fn(arg1: *mut core::ffi::c_void) -> *mut core::ffi::c_void, ++ >, ++ __arg: *mut core::ffi::c_void, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_exit(__retval: *mut core::ffi::c_void) -> !; ++} ++unsafe extern "C" { ++ pub fn pthread_join( ++ __th: pthread_t, ++ __thread_return: *mut *mut core::ffi::c_void, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_detach(__th: pthread_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_self() -> pthread_t; ++} ++unsafe extern "C" { ++ pub fn pthread_equal(__thread1: pthread_t, __thread2: pthread_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_init(__attr: *mut pthread_attr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_destroy(__attr: *mut pthread_attr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getdetachstate( ++ __attr: *const pthread_attr_t, ++ __detachstate: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setdetachstate( ++ __attr: *mut pthread_attr_t, ++ __detachstate: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getguardsize( ++ __attr: *const pthread_attr_t, ++ __guardsize: *mut usize, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setguardsize( ++ __attr: *mut pthread_attr_t, ++ __guardsize: usize, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getschedparam( ++ __attr: *const pthread_attr_t, ++ __param: *mut sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setschedparam( ++ __attr: *mut pthread_attr_t, ++ __param: *const sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getschedpolicy( ++ __attr: *const pthread_attr_t, ++ __policy: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setschedpolicy( ++ __attr: *mut pthread_attr_t, ++ __policy: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getinheritsched( ++ __attr: *const pthread_attr_t, ++ __inherit: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setinheritsched( ++ __attr: *mut pthread_attr_t, ++ __inherit: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getscope( ++ __attr: *const pthread_attr_t, ++ __scope: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setscope( ++ __attr: *mut pthread_attr_t, ++ __scope: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getstackaddr( ++ __attr: *const pthread_attr_t, ++ __stackaddr: *mut *mut core::ffi::c_void, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setstackaddr( ++ __attr: *mut pthread_attr_t, ++ __stackaddr: *mut core::ffi::c_void, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getstacksize( ++ __attr: *const pthread_attr_t, ++ __stacksize: *mut usize, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setstacksize( ++ __attr: *mut pthread_attr_t, ++ __stacksize: usize, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getstack( ++ __attr: *const pthread_attr_t, ++ __stackaddr: *mut *mut core::ffi::c_void, ++ __stacksize: *mut usize, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setstack( ++ __attr: *mut pthread_attr_t, ++ __stackaddr: *mut core::ffi::c_void, ++ __stacksize: usize, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_setschedparam( ++ __target_thread: pthread_t, ++ __policy: core::ffi::c_int, ++ __param: *const sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_getschedparam( ++ __target_thread: pthread_t, ++ __policy: *mut core::ffi::c_int, ++ __param: *mut sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_setschedprio( ++ __target_thread: pthread_t, ++ __prio: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_once( ++ __once_control: *mut pthread_once_t, ++ __init_routine: ::core::option::Option, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_setcancelstate( ++ __state: core::ffi::c_int, ++ __oldstate: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_setcanceltype( ++ __type: core::ffi::c_int, ++ __oldtype: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cancel(__th: pthread_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_testcancel(); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __cancel_jmp_buf_tag { ++ pub __cancel_jmp_buf: __jmp_buf, ++ pub __mask_was_saved: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __cancel_jmp_buf_tag"][::core::mem::size_of::<__cancel_jmp_buf_tag>() - 184usize]; ++ ["Alignment of __cancel_jmp_buf_tag"][::core::mem::align_of::<__cancel_jmp_buf_tag>() - 8usize]; ++ ["Offset of field: __cancel_jmp_buf_tag::__cancel_jmp_buf"] ++ [::core::mem::offset_of!(__cancel_jmp_buf_tag, __cancel_jmp_buf) - 0usize]; ++ ["Offset of field: __cancel_jmp_buf_tag::__mask_was_saved"] ++ [::core::mem::offset_of!(__cancel_jmp_buf_tag, __mask_was_saved) - 176usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __pthread_unwind_buf_t { ++ pub __cancel_jmp_buf: [__cancel_jmp_buf_tag; 1usize], ++ pub __pad: [*mut core::ffi::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __pthread_unwind_buf_t"][::core::mem::size_of::<__pthread_unwind_buf_t>() - 216usize]; ++ ["Alignment of __pthread_unwind_buf_t"] ++ [::core::mem::align_of::<__pthread_unwind_buf_t>() - 8usize]; ++ ["Offset of field: __pthread_unwind_buf_t::__cancel_jmp_buf"] ++ [::core::mem::offset_of!(__pthread_unwind_buf_t, __cancel_jmp_buf) - 0usize]; ++ ["Offset of field: __pthread_unwind_buf_t::__pad"] ++ [::core::mem::offset_of!(__pthread_unwind_buf_t, __pad) - 184usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __pthread_cleanup_frame { ++ pub __cancel_routine: ++ ::core::option::Option, ++ pub __cancel_arg: *mut core::ffi::c_void, ++ pub __do_it: core::ffi::c_int, ++ pub __cancel_type: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __pthread_cleanup_frame"] ++ [::core::mem::size_of::<__pthread_cleanup_frame>() - 24usize]; ++ ["Alignment of __pthread_cleanup_frame"] ++ [::core::mem::align_of::<__pthread_cleanup_frame>() - 8usize]; ++ ["Offset of field: __pthread_cleanup_frame::__cancel_routine"] ++ [::core::mem::offset_of!(__pthread_cleanup_frame, __cancel_routine) - 0usize]; ++ ["Offset of field: __pthread_cleanup_frame::__cancel_arg"] ++ [::core::mem::offset_of!(__pthread_cleanup_frame, __cancel_arg) - 8usize]; ++ ["Offset of field: __pthread_cleanup_frame::__do_it"] ++ [::core::mem::offset_of!(__pthread_cleanup_frame, __do_it) - 16usize]; ++ ["Offset of field: __pthread_cleanup_frame::__cancel_type"] ++ [::core::mem::offset_of!(__pthread_cleanup_frame, __cancel_type) - 20usize]; ++}; ++unsafe extern "C" { ++ pub fn __pthread_register_cancel(__buf: *mut __pthread_unwind_buf_t); ++} ++unsafe extern "C" { ++ pub fn __pthread_unregister_cancel(__buf: *mut __pthread_unwind_buf_t); ++} ++unsafe extern "C" { ++ pub fn __pthread_unwind_next(__buf: *mut __pthread_unwind_buf_t) -> !; ++} ++unsafe extern "C" { ++ pub fn __sigsetjmp(__env: *mut __jmp_buf_tag, __savemask: core::ffi::c_int) ++ -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_init( ++ __mutex: *mut pthread_mutex_t, ++ __mutexattr: *const pthread_mutexattr_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_destroy(__mutex: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_trylock(__mutex: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_lock(__mutex: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_timedlock( ++ __mutex: *mut pthread_mutex_t, ++ __abstime: *const timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_unlock(__mutex: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_getprioceiling( ++ __mutex: *const pthread_mutex_t, ++ __prioceiling: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_setprioceiling( ++ __mutex: *mut pthread_mutex_t, ++ __prioceiling: core::ffi::c_int, ++ __old_ceiling: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_consistent(__mutex: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_init(__attr: *mut pthread_mutexattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_destroy(__attr: *mut pthread_mutexattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_getpshared( ++ __attr: *const pthread_mutexattr_t, ++ __pshared: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_setpshared( ++ __attr: *mut pthread_mutexattr_t, ++ __pshared: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_gettype( ++ __attr: *const pthread_mutexattr_t, ++ __kind: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_settype( ++ __attr: *mut pthread_mutexattr_t, ++ __kind: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_getprotocol( ++ __attr: *const pthread_mutexattr_t, ++ __protocol: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_setprotocol( ++ __attr: *mut pthread_mutexattr_t, ++ __protocol: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_getprioceiling( ++ __attr: *const pthread_mutexattr_t, ++ __prioceiling: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_setprioceiling( ++ __attr: *mut pthread_mutexattr_t, ++ __prioceiling: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_getrobust( ++ __attr: *const pthread_mutexattr_t, ++ __robustness: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_setrobust( ++ __attr: *mut pthread_mutexattr_t, ++ __robustness: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_init( ++ __rwlock: *mut pthread_rwlock_t, ++ __attr: *const pthread_rwlockattr_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_destroy(__rwlock: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_rdlock(__rwlock: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_tryrdlock(__rwlock: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_timedrdlock( ++ __rwlock: *mut pthread_rwlock_t, ++ __abstime: *const timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_wrlock(__rwlock: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_trywrlock(__rwlock: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_timedwrlock( ++ __rwlock: *mut pthread_rwlock_t, ++ __abstime: *const timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_unlock(__rwlock: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlockattr_init(__attr: *mut pthread_rwlockattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlockattr_destroy(__attr: *mut pthread_rwlockattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlockattr_getpshared( ++ __attr: *const pthread_rwlockattr_t, ++ __pshared: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlockattr_setpshared( ++ __attr: *mut pthread_rwlockattr_t, ++ __pshared: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlockattr_getkind_np( ++ __attr: *const pthread_rwlockattr_t, ++ __pref: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlockattr_setkind_np( ++ __attr: *mut pthread_rwlockattr_t, ++ __pref: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_init( ++ __cond: *mut pthread_cond_t, ++ __cond_attr: *const pthread_condattr_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_destroy(__cond: *mut pthread_cond_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_signal(__cond: *mut pthread_cond_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_broadcast(__cond: *mut pthread_cond_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_wait( ++ __cond: *mut pthread_cond_t, ++ __mutex: *mut pthread_mutex_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_timedwait( ++ __cond: *mut pthread_cond_t, ++ __mutex: *mut pthread_mutex_t, ++ __abstime: *const timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_init(__attr: *mut pthread_condattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_destroy(__attr: *mut pthread_condattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_getpshared( ++ __attr: *const pthread_condattr_t, ++ __pshared: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_setpshared( ++ __attr: *mut pthread_condattr_t, ++ __pshared: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_getclock( ++ __attr: *const pthread_condattr_t, ++ __clock_id: *mut __clockid_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_setclock( ++ __attr: *mut pthread_condattr_t, ++ __clock_id: __clockid_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_init( ++ __lock: *mut pthread_spinlock_t, ++ __pshared: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_destroy(__lock: *mut pthread_spinlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_lock(__lock: *mut pthread_spinlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_trylock(__lock: *mut pthread_spinlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_unlock(__lock: *mut pthread_spinlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrier_init( ++ __barrier: *mut pthread_barrier_t, ++ __attr: *const pthread_barrierattr_t, ++ __count: core::ffi::c_uint, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrier_destroy(__barrier: *mut pthread_barrier_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrier_wait(__barrier: *mut pthread_barrier_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrierattr_init(__attr: *mut pthread_barrierattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrierattr_destroy(__attr: *mut pthread_barrierattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrierattr_getpshared( ++ __attr: *const pthread_barrierattr_t, ++ __pshared: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrierattr_setpshared( ++ __attr: *mut pthread_barrierattr_t, ++ __pshared: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_key_create( ++ __key: *mut pthread_key_t, ++ __destr_function: ::core::option::Option< ++ unsafe extern "C" fn(arg1: *mut core::ffi::c_void), ++ >, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_key_delete(__key: pthread_key_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_getspecific(__key: pthread_key_t) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn pthread_setspecific( ++ __key: pthread_key_t, ++ __pointer: *const core::ffi::c_void, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_getcpuclockid( ++ __thread_id: pthread_t, ++ __clock_id: *mut __clockid_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_atfork( ++ __prepare: ::core::option::Option, ++ __parent: ::core::option::Option, ++ __child: ::core::option::Option, ++ ) -> core::ffi::c_int; ++} ++pub type ma_pthread_t = pthread_t; ++pub type ma_pthread_mutex_t = pthread_mutex_t; ++pub type ma_pthread_cond_t = pthread_cond_t; ++pub type ma_wchar_win32 = ma_uint16; ++pub const ma_log_level_MA_LOG_LEVEL_DEBUG: ma_log_level = 4; ++pub const ma_log_level_MA_LOG_LEVEL_INFO: ma_log_level = 3; ++pub const ma_log_level_MA_LOG_LEVEL_WARNING: ma_log_level = 2; ++pub const ma_log_level_MA_LOG_LEVEL_ERROR: ma_log_level = 1; ++pub type ma_log_level = core::ffi::c_uint; ++pub type ma_channel = ma_uint8; ++pub const _ma_channel_position_MA_CHANNEL_NONE: _ma_channel_position = 0; ++pub const _ma_channel_position_MA_CHANNEL_MONO: _ma_channel_position = 1; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_LEFT: _ma_channel_position = 2; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_RIGHT: _ma_channel_position = 3; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_CENTER: _ma_channel_position = 4; ++pub const _ma_channel_position_MA_CHANNEL_LFE: _ma_channel_position = 5; ++pub const _ma_channel_position_MA_CHANNEL_BACK_LEFT: _ma_channel_position = 6; ++pub const _ma_channel_position_MA_CHANNEL_BACK_RIGHT: _ma_channel_position = 7; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_LEFT_CENTER: _ma_channel_position = 8; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_RIGHT_CENTER: _ma_channel_position = 9; ++pub const _ma_channel_position_MA_CHANNEL_BACK_CENTER: _ma_channel_position = 10; ++pub const _ma_channel_position_MA_CHANNEL_SIDE_LEFT: _ma_channel_position = 11; ++pub const _ma_channel_position_MA_CHANNEL_SIDE_RIGHT: _ma_channel_position = 12; ++pub const _ma_channel_position_MA_CHANNEL_TOP_CENTER: _ma_channel_position = 13; ++pub const _ma_channel_position_MA_CHANNEL_TOP_FRONT_LEFT: _ma_channel_position = 14; ++pub const _ma_channel_position_MA_CHANNEL_TOP_FRONT_CENTER: _ma_channel_position = 15; ++pub const _ma_channel_position_MA_CHANNEL_TOP_FRONT_RIGHT: _ma_channel_position = 16; ++pub const _ma_channel_position_MA_CHANNEL_TOP_BACK_LEFT: _ma_channel_position = 17; ++pub const _ma_channel_position_MA_CHANNEL_TOP_BACK_CENTER: _ma_channel_position = 18; ++pub const _ma_channel_position_MA_CHANNEL_TOP_BACK_RIGHT: _ma_channel_position = 19; ++pub const _ma_channel_position_MA_CHANNEL_AUX_0: _ma_channel_position = 20; ++pub const _ma_channel_position_MA_CHANNEL_AUX_1: _ma_channel_position = 21; ++pub const _ma_channel_position_MA_CHANNEL_AUX_2: _ma_channel_position = 22; ++pub const _ma_channel_position_MA_CHANNEL_AUX_3: _ma_channel_position = 23; ++pub const _ma_channel_position_MA_CHANNEL_AUX_4: _ma_channel_position = 24; ++pub const _ma_channel_position_MA_CHANNEL_AUX_5: _ma_channel_position = 25; ++pub const _ma_channel_position_MA_CHANNEL_AUX_6: _ma_channel_position = 26; ++pub const _ma_channel_position_MA_CHANNEL_AUX_7: _ma_channel_position = 27; ++pub const _ma_channel_position_MA_CHANNEL_AUX_8: _ma_channel_position = 28; ++pub const _ma_channel_position_MA_CHANNEL_AUX_9: _ma_channel_position = 29; ++pub const _ma_channel_position_MA_CHANNEL_AUX_10: _ma_channel_position = 30; ++pub const _ma_channel_position_MA_CHANNEL_AUX_11: _ma_channel_position = 31; ++pub const _ma_channel_position_MA_CHANNEL_AUX_12: _ma_channel_position = 32; ++pub const _ma_channel_position_MA_CHANNEL_AUX_13: _ma_channel_position = 33; ++pub const _ma_channel_position_MA_CHANNEL_AUX_14: _ma_channel_position = 34; ++pub const _ma_channel_position_MA_CHANNEL_AUX_15: _ma_channel_position = 35; ++pub const _ma_channel_position_MA_CHANNEL_AUX_16: _ma_channel_position = 36; ++pub const _ma_channel_position_MA_CHANNEL_AUX_17: _ma_channel_position = 37; ++pub const _ma_channel_position_MA_CHANNEL_AUX_18: _ma_channel_position = 38; ++pub const _ma_channel_position_MA_CHANNEL_AUX_19: _ma_channel_position = 39; ++pub const _ma_channel_position_MA_CHANNEL_AUX_20: _ma_channel_position = 40; ++pub const _ma_channel_position_MA_CHANNEL_AUX_21: _ma_channel_position = 41; ++pub const _ma_channel_position_MA_CHANNEL_AUX_22: _ma_channel_position = 42; ++pub const _ma_channel_position_MA_CHANNEL_AUX_23: _ma_channel_position = 43; ++pub const _ma_channel_position_MA_CHANNEL_AUX_24: _ma_channel_position = 44; ++pub const _ma_channel_position_MA_CHANNEL_AUX_25: _ma_channel_position = 45; ++pub const _ma_channel_position_MA_CHANNEL_AUX_26: _ma_channel_position = 46; ++pub const _ma_channel_position_MA_CHANNEL_AUX_27: _ma_channel_position = 47; ++pub const _ma_channel_position_MA_CHANNEL_AUX_28: _ma_channel_position = 48; ++pub const _ma_channel_position_MA_CHANNEL_AUX_29: _ma_channel_position = 49; ++pub const _ma_channel_position_MA_CHANNEL_AUX_30: _ma_channel_position = 50; ++pub const _ma_channel_position_MA_CHANNEL_AUX_31: _ma_channel_position = 51; ++pub const _ma_channel_position_MA_CHANNEL_LEFT: _ma_channel_position = 2; ++pub const _ma_channel_position_MA_CHANNEL_RIGHT: _ma_channel_position = 3; ++pub const _ma_channel_position_MA_CHANNEL_POSITION_COUNT: _ma_channel_position = 52; ++pub type _ma_channel_position = core::ffi::c_uint; ++pub const ma_result_MA_SUCCESS: ma_result = 0; ++pub const ma_result_MA_ERROR: ma_result = -1; ++pub const ma_result_MA_INVALID_ARGS: ma_result = -2; ++pub const ma_result_MA_INVALID_OPERATION: ma_result = -3; ++pub const ma_result_MA_OUT_OF_MEMORY: ma_result = -4; ++pub const ma_result_MA_OUT_OF_RANGE: ma_result = -5; ++pub const ma_result_MA_ACCESS_DENIED: ma_result = -6; ++pub const ma_result_MA_DOES_NOT_EXIST: ma_result = -7; ++pub const ma_result_MA_ALREADY_EXISTS: ma_result = -8; ++pub const ma_result_MA_TOO_MANY_OPEN_FILES: ma_result = -9; ++pub const ma_result_MA_INVALID_FILE: ma_result = -10; ++pub const ma_result_MA_TOO_BIG: ma_result = -11; ++pub const ma_result_MA_PATH_TOO_LONG: ma_result = -12; ++pub const ma_result_MA_NAME_TOO_LONG: ma_result = -13; ++pub const ma_result_MA_NOT_DIRECTORY: ma_result = -14; ++pub const ma_result_MA_IS_DIRECTORY: ma_result = -15; ++pub const ma_result_MA_DIRECTORY_NOT_EMPTY: ma_result = -16; ++pub const ma_result_MA_AT_END: ma_result = -17; ++pub const ma_result_MA_NO_SPACE: ma_result = -18; ++pub const ma_result_MA_BUSY: ma_result = -19; ++pub const ma_result_MA_IO_ERROR: ma_result = -20; ++pub const ma_result_MA_INTERRUPT: ma_result = -21; ++pub const ma_result_MA_UNAVAILABLE: ma_result = -22; ++pub const ma_result_MA_ALREADY_IN_USE: ma_result = -23; ++pub const ma_result_MA_BAD_ADDRESS: ma_result = -24; ++pub const ma_result_MA_BAD_SEEK: ma_result = -25; ++pub const ma_result_MA_BAD_PIPE: ma_result = -26; ++pub const ma_result_MA_DEADLOCK: ma_result = -27; ++pub const ma_result_MA_TOO_MANY_LINKS: ma_result = -28; ++pub const ma_result_MA_NOT_IMPLEMENTED: ma_result = -29; ++pub const ma_result_MA_NO_MESSAGE: ma_result = -30; ++pub const ma_result_MA_BAD_MESSAGE: ma_result = -31; ++pub const ma_result_MA_NO_DATA_AVAILABLE: ma_result = -32; ++pub const ma_result_MA_INVALID_DATA: ma_result = -33; ++pub const ma_result_MA_TIMEOUT: ma_result = -34; ++pub const ma_result_MA_NO_NETWORK: ma_result = -35; ++pub const ma_result_MA_NOT_UNIQUE: ma_result = -36; ++pub const ma_result_MA_NOT_SOCKET: ma_result = -37; ++pub const ma_result_MA_NO_ADDRESS: ma_result = -38; ++pub const ma_result_MA_BAD_PROTOCOL: ma_result = -39; ++pub const ma_result_MA_PROTOCOL_UNAVAILABLE: ma_result = -40; ++pub const ma_result_MA_PROTOCOL_NOT_SUPPORTED: ma_result = -41; ++pub const ma_result_MA_PROTOCOL_FAMILY_NOT_SUPPORTED: ma_result = -42; ++pub const ma_result_MA_ADDRESS_FAMILY_NOT_SUPPORTED: ma_result = -43; ++pub const ma_result_MA_SOCKET_NOT_SUPPORTED: ma_result = -44; ++pub const ma_result_MA_CONNECTION_RESET: ma_result = -45; ++pub const ma_result_MA_ALREADY_CONNECTED: ma_result = -46; ++pub const ma_result_MA_NOT_CONNECTED: ma_result = -47; ++pub const ma_result_MA_CONNECTION_REFUSED: ma_result = -48; ++pub const ma_result_MA_NO_HOST: ma_result = -49; ++pub const ma_result_MA_IN_PROGRESS: ma_result = -50; ++pub const ma_result_MA_CANCELLED: ma_result = -51; ++pub const ma_result_MA_MEMORY_ALREADY_MAPPED: ma_result = -52; ++pub const ma_result_MA_CRC_MISMATCH: ma_result = -100; ++pub const ma_result_MA_FORMAT_NOT_SUPPORTED: ma_result = -200; ++pub const ma_result_MA_DEVICE_TYPE_NOT_SUPPORTED: ma_result = -201; ++pub const ma_result_MA_SHARE_MODE_NOT_SUPPORTED: ma_result = -202; ++pub const ma_result_MA_NO_BACKEND: ma_result = -203; ++pub const ma_result_MA_NO_DEVICE: ma_result = -204; ++pub const ma_result_MA_API_NOT_FOUND: ma_result = -205; ++pub const ma_result_MA_INVALID_DEVICE_CONFIG: ma_result = -206; ++pub const ma_result_MA_LOOP: ma_result = -207; ++pub const ma_result_MA_BACKEND_NOT_ENABLED: ma_result = -208; ++pub const ma_result_MA_DEVICE_NOT_INITIALIZED: ma_result = -300; ++pub const ma_result_MA_DEVICE_ALREADY_INITIALIZED: ma_result = -301; ++pub const ma_result_MA_DEVICE_NOT_STARTED: ma_result = -302; ++pub const ma_result_MA_DEVICE_NOT_STOPPED: ma_result = -303; ++pub const ma_result_MA_FAILED_TO_INIT_BACKEND: ma_result = -400; ++pub const ma_result_MA_FAILED_TO_OPEN_BACKEND_DEVICE: ma_result = -401; ++pub const ma_result_MA_FAILED_TO_START_BACKEND_DEVICE: ma_result = -402; ++pub const ma_result_MA_FAILED_TO_STOP_BACKEND_DEVICE: ma_result = -403; ++pub type ma_result = core::ffi::c_int; ++pub const ma_stream_format_ma_stream_format_pcm: ma_stream_format = 0; ++pub type ma_stream_format = core::ffi::c_uint; ++pub const ma_stream_layout_ma_stream_layout_interleaved: ma_stream_layout = 0; ++pub const ma_stream_layout_ma_stream_layout_deinterleaved: ma_stream_layout = 1; ++pub type ma_stream_layout = core::ffi::c_uint; ++pub const ma_dither_mode_ma_dither_mode_none: ma_dither_mode = 0; ++pub const ma_dither_mode_ma_dither_mode_rectangle: ma_dither_mode = 1; ++pub const ma_dither_mode_ma_dither_mode_triangle: ma_dither_mode = 2; ++pub type ma_dither_mode = core::ffi::c_uint; ++pub const ma_format_ma_format_unknown: ma_format = 0; ++pub const ma_format_ma_format_u8: ma_format = 1; ++pub const ma_format_ma_format_s16: ma_format = 2; ++pub const ma_format_ma_format_s24: ma_format = 3; ++pub const ma_format_ma_format_s32: ma_format = 4; ++pub const ma_format_ma_format_f32: ma_format = 5; ++pub const ma_format_ma_format_count: ma_format = 6; ++pub type ma_format = core::ffi::c_uint; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_48000: ma_standard_sample_rate = 48000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_44100: ma_standard_sample_rate = 44100; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_32000: ma_standard_sample_rate = 32000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_24000: ma_standard_sample_rate = 24000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_22050: ma_standard_sample_rate = 22050; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_88200: ma_standard_sample_rate = 88200; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_96000: ma_standard_sample_rate = 96000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_176400: ma_standard_sample_rate = 176400; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_192000: ma_standard_sample_rate = 192000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_16000: ma_standard_sample_rate = 16000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_11025: ma_standard_sample_rate = 11025; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_8000: ma_standard_sample_rate = 8000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_352800: ma_standard_sample_rate = 352800; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_384000: ma_standard_sample_rate = 384000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_min: ma_standard_sample_rate = 8000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_max: ma_standard_sample_rate = 384000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_count: ma_standard_sample_rate = 14; ++pub type ma_standard_sample_rate = core::ffi::c_uint; ++pub const ma_channel_mix_mode_ma_channel_mix_mode_rectangular: ma_channel_mix_mode = 0; ++pub const ma_channel_mix_mode_ma_channel_mix_mode_simple: ma_channel_mix_mode = 1; ++pub const ma_channel_mix_mode_ma_channel_mix_mode_custom_weights: ma_channel_mix_mode = 2; ++pub const ma_channel_mix_mode_ma_channel_mix_mode_default: ma_channel_mix_mode = 0; ++pub type ma_channel_mix_mode = core::ffi::c_uint; ++pub const ma_standard_channel_map_ma_standard_channel_map_microsoft: ma_standard_channel_map = 0; ++pub const ma_standard_channel_map_ma_standard_channel_map_alsa: ma_standard_channel_map = 1; ++pub const ma_standard_channel_map_ma_standard_channel_map_rfc3551: ma_standard_channel_map = 2; ++pub const ma_standard_channel_map_ma_standard_channel_map_flac: ma_standard_channel_map = 3; ++pub const ma_standard_channel_map_ma_standard_channel_map_vorbis: ma_standard_channel_map = 4; ++pub const ma_standard_channel_map_ma_standard_channel_map_sound4: ma_standard_channel_map = 5; ++pub const ma_standard_channel_map_ma_standard_channel_map_sndio: ma_standard_channel_map = 6; ++pub const ma_standard_channel_map_ma_standard_channel_map_webaudio: ma_standard_channel_map = 3; ++pub const ma_standard_channel_map_ma_standard_channel_map_default: ma_standard_channel_map = 0; ++pub type ma_standard_channel_map = core::ffi::c_uint; ++pub const ma_performance_profile_ma_performance_profile_low_latency: ma_performance_profile = 0; ++pub const ma_performance_profile_ma_performance_profile_conservative: ma_performance_profile = 1; ++pub type ma_performance_profile = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_allocation_callbacks { ++ pub pUserData: *mut core::ffi::c_void, ++ pub onMalloc: ::core::option::Option< ++ unsafe extern "C" fn( ++ sz: usize, ++ pUserData: *mut core::ffi::c_void, ++ ) -> *mut core::ffi::c_void, ++ >, ++ pub onRealloc: ::core::option::Option< ++ unsafe extern "C" fn( ++ p: *mut core::ffi::c_void, ++ sz: usize, ++ pUserData: *mut core::ffi::c_void, ++ ) -> *mut core::ffi::c_void, ++ >, ++ pub onFree: ::core::option::Option< ++ unsafe extern "C" fn(p: *mut core::ffi::c_void, pUserData: *mut core::ffi::c_void), ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_allocation_callbacks"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_allocation_callbacks"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_allocation_callbacks::pUserData"] ++ [::core::mem::offset_of!(ma_allocation_callbacks, pUserData) - 0usize]; ++ ["Offset of field: ma_allocation_callbacks::onMalloc"] ++ [::core::mem::offset_of!(ma_allocation_callbacks, onMalloc) - 8usize]; ++ ["Offset of field: ma_allocation_callbacks::onRealloc"] ++ [::core::mem::offset_of!(ma_allocation_callbacks, onRealloc) - 16usize]; ++ ["Offset of field: ma_allocation_callbacks::onFree"] ++ [::core::mem::offset_of!(ma_allocation_callbacks, onFree) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lcg { ++ pub state: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lcg"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_lcg"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_lcg::state"][::core::mem::offset_of!(ma_lcg, state) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_uint32 { ++ pub value: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_uint32"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_uint32"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_uint32::value"] ++ [::core::mem::offset_of!(ma_atomic_uint32, value) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_int32 { ++ pub value: ma_int32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_int32"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_int32"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_int32::value"] ++ [::core::mem::offset_of!(ma_atomic_int32, value) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_uint64 { ++ pub value: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_uint64"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_atomic_uint64"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_atomic_uint64::value"] ++ [::core::mem::offset_of!(ma_atomic_uint64, value) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_float { ++ pub value: ma_float, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_float"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_float"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_float::value"] ++ [::core::mem::offset_of!(ma_atomic_float, value) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_bool32 { ++ pub value: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_bool32"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_bool32"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_bool32::value"] ++ [::core::mem::offset_of!(ma_atomic_bool32, value) - 0usize]; ++}; ++pub type ma_spinlock = ma_uint32; ++pub const ma_thread_priority_ma_thread_priority_idle: ma_thread_priority = -5; ++pub const ma_thread_priority_ma_thread_priority_lowest: ma_thread_priority = -4; ++pub const ma_thread_priority_ma_thread_priority_low: ma_thread_priority = -3; ++pub const ma_thread_priority_ma_thread_priority_normal: ma_thread_priority = -2; ++pub const ma_thread_priority_ma_thread_priority_high: ma_thread_priority = -1; ++pub const ma_thread_priority_ma_thread_priority_highest: ma_thread_priority = 0; ++pub const ma_thread_priority_ma_thread_priority_realtime: ma_thread_priority = 1; ++pub const ma_thread_priority_ma_thread_priority_default: ma_thread_priority = 0; ++pub type ma_thread_priority = core::ffi::c_int; ++pub type ma_thread = ma_pthread_t; ++pub type ma_mutex = ma_pthread_mutex_t; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_event { ++ pub value: ma_uint32, ++ pub lock: ma_pthread_mutex_t, ++ pub cond: ma_pthread_cond_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_event"][::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_event"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_event::value"][::core::mem::offset_of!(ma_event, value) - 0usize]; ++ ["Offset of field: ma_event::lock"][::core::mem::offset_of!(ma_event, lock) - 8usize]; ++ ["Offset of field: ma_event::cond"][::core::mem::offset_of!(ma_event, cond) - 56usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_semaphore { ++ pub value: core::ffi::c_int, ++ pub lock: ma_pthread_mutex_t, ++ pub cond: ma_pthread_cond_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_semaphore"][::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_semaphore"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_semaphore::value"][::core::mem::offset_of!(ma_semaphore, value) - 0usize]; ++ ["Offset of field: ma_semaphore::lock"][::core::mem::offset_of!(ma_semaphore, lock) - 8usize]; ++ ["Offset of field: ma_semaphore::cond"][::core::mem::offset_of!(ma_semaphore, cond) - 56usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_version(pMajor: *mut ma_uint32, pMinor: *mut ma_uint32, pRevision: *mut ma_uint32); ++} ++unsafe extern "C" { ++ pub fn ma_version_string() -> *const core::ffi::c_char; ++} ++pub type __gnuc_va_list = __BindgenOpaqueArray; ++pub type va_list = __BindgenOpaqueArray; ++pub type ma_log_callback_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ level: ma_uint32, ++ pMessage: *const core::ffi::c_char, ++ ), ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_log_callback { ++ pub onLog: ma_log_callback_proc, ++ pub pUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_log_callback"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_log_callback"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_log_callback::onLog"] ++ [::core::mem::offset_of!(ma_log_callback, onLog) - 0usize]; ++ ["Offset of field: ma_log_callback::pUserData"] ++ [::core::mem::offset_of!(ma_log_callback, pUserData) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_log_callback_init( ++ onLog: ma_log_callback_proc, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_log_callback; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_log { ++ pub callbacks: [ma_log_callback; 4usize], ++ pub callbackCount: ma_uint32, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub lock: ma_mutex, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_log"][::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_log"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_log::callbacks"][::core::mem::offset_of!(ma_log, callbacks) - 0usize]; ++ ["Offset of field: ma_log::callbackCount"] ++ [::core::mem::offset_of!(ma_log, callbackCount) - 64usize]; ++ ["Offset of field: ma_log::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_log, allocationCallbacks) - 72usize]; ++ ["Offset of field: ma_log::lock"][::core::mem::offset_of!(ma_log, lock) - 104usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_log_init( ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pLog: *mut ma_log, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_uninit(pLog: *mut ma_log); ++} ++unsafe extern "C" { ++ pub fn ma_log_register_callback(pLog: *mut ma_log, callback: ma_log_callback) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_unregister_callback(pLog: *mut ma_log, callback: ma_log_callback) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_post( ++ pLog: *mut ma_log, ++ level: ma_uint32, ++ pMessage: *const core::ffi::c_char, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_postv( ++ pLog: *mut ma_log, ++ level: ma_uint32, ++ pFormat: *const core::ffi::c_char, ++ args: va_list, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_postf( ++ pLog: *mut ma_log, ++ level: ma_uint32, ++ pFormat: *const core::ffi::c_char, ++ ... ++ ) -> ma_result; ++} ++#[doc = "Biquad Filtering"] ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_biquad_coefficient { ++ pub f32_: f32, ++ pub s32: ma_int32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad_coefficient"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_biquad_coefficient"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_biquad_coefficient::f32_"] ++ [::core::mem::offset_of!(ma_biquad_coefficient, f32_) - 0usize]; ++ ["Offset of field: ma_biquad_coefficient::s32"] ++ [::core::mem::offset_of!(ma_biquad_coefficient, s32) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_biquad_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub b0: f64, ++ pub b1: f64, ++ pub b2: f64, ++ pub a0: f64, ++ pub a1: f64, ++ pub a2: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad_config"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_biquad_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_biquad_config::format"] ++ [::core::mem::offset_of!(ma_biquad_config, format) - 0usize]; ++ ["Offset of field: ma_biquad_config::channels"] ++ [::core::mem::offset_of!(ma_biquad_config, channels) - 4usize]; ++ ["Offset of field: ma_biquad_config::b0"] ++ [::core::mem::offset_of!(ma_biquad_config, b0) - 8usize]; ++ ["Offset of field: ma_biquad_config::b1"] ++ [::core::mem::offset_of!(ma_biquad_config, b1) - 16usize]; ++ ["Offset of field: ma_biquad_config::b2"] ++ [::core::mem::offset_of!(ma_biquad_config, b2) - 24usize]; ++ ["Offset of field: ma_biquad_config::a0"] ++ [::core::mem::offset_of!(ma_biquad_config, a0) - 32usize]; ++ ["Offset of field: ma_biquad_config::a1"] ++ [::core::mem::offset_of!(ma_biquad_config, a1) - 40usize]; ++ ["Offset of field: ma_biquad_config::a2"] ++ [::core::mem::offset_of!(ma_biquad_config, a2) - 48usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_biquad_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ b0: f64, ++ b1: f64, ++ b2: f64, ++ a0: f64, ++ a1: f64, ++ a2: f64, ++ ) -> ma_biquad_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_biquad { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub b0: ma_biquad_coefficient, ++ pub b1: ma_biquad_coefficient, ++ pub b2: ma_biquad_coefficient, ++ pub a1: ma_biquad_coefficient, ++ pub a2: ma_biquad_coefficient, ++ pub pR1: *mut ma_biquad_coefficient, ++ pub pR2: *mut ma_biquad_coefficient, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_biquad"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_biquad::format"][::core::mem::offset_of!(ma_biquad, format) - 0usize]; ++ ["Offset of field: ma_biquad::channels"][::core::mem::offset_of!(ma_biquad, channels) - 4usize]; ++ ["Offset of field: ma_biquad::b0"][::core::mem::offset_of!(ma_biquad, b0) - 8usize]; ++ ["Offset of field: ma_biquad::b1"][::core::mem::offset_of!(ma_biquad, b1) - 12usize]; ++ ["Offset of field: ma_biquad::b2"][::core::mem::offset_of!(ma_biquad, b2) - 16usize]; ++ ["Offset of field: ma_biquad::a1"][::core::mem::offset_of!(ma_biquad, a1) - 20usize]; ++ ["Offset of field: ma_biquad::a2"][::core::mem::offset_of!(ma_biquad, a2) - 24usize]; ++ ["Offset of field: ma_biquad::pR1"][::core::mem::offset_of!(ma_biquad, pR1) - 32usize]; ++ ["Offset of field: ma_biquad::pR2"][::core::mem::offset_of!(ma_biquad, pR2) - 40usize]; ++ ["Offset of field: ma_biquad::_pHeap"][::core::mem::offset_of!(ma_biquad, _pHeap) - 48usize]; ++ ["Offset of field: ma_biquad::_ownsHeap"] ++ [::core::mem::offset_of!(ma_biquad, _ownsHeap) - 56usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_biquad_get_heap_size( ++ pConfig: *const ma_biquad_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_init_preallocated( ++ pConfig: *const ma_biquad_config, ++ pHeap: *mut core::ffi::c_void, ++ pBQ: *mut ma_biquad, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_init( ++ pConfig: *const ma_biquad_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pBQ: *mut ma_biquad, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_uninit( ++ pBQ: *mut ma_biquad, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_biquad_reinit(pConfig: *const ma_biquad_config, pBQ: *mut ma_biquad) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_clear_cache(pBQ: *mut ma_biquad) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_process_pcm_frames( ++ pBQ: *mut ma_biquad, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_get_latency(pBQ: *const ma_biquad) -> ma_uint32; ++} ++#[doc = "Low-Pass Filtering"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf1_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub q: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf1_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_lpf1_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf1_config::format"] ++ [::core::mem::offset_of!(ma_lpf1_config, format) - 0usize]; ++ ["Offset of field: ma_lpf1_config::channels"] ++ [::core::mem::offset_of!(ma_lpf1_config, channels) - 4usize]; ++ ["Offset of field: ma_lpf1_config::sampleRate"] ++ [::core::mem::offset_of!(ma_lpf1_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_lpf1_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_lpf1_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_lpf1_config::q"][::core::mem::offset_of!(ma_lpf1_config, q) - 24usize]; ++}; ++#[doc = "Low-Pass Filtering"] ++pub type ma_lpf2_config = ma_lpf1_config; ++unsafe extern "C" { ++ pub fn ma_lpf1_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ ) -> ma_lpf1_config; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ q: f64, ++ ) -> ma_lpf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_lpf1 { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub a: ma_biquad_coefficient, ++ pub pR1: *mut ma_biquad_coefficient, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf1"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_lpf1"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf1::format"][::core::mem::offset_of!(ma_lpf1, format) - 0usize]; ++ ["Offset of field: ma_lpf1::channels"][::core::mem::offset_of!(ma_lpf1, channels) - 4usize]; ++ ["Offset of field: ma_lpf1::a"][::core::mem::offset_of!(ma_lpf1, a) - 8usize]; ++ ["Offset of field: ma_lpf1::pR1"][::core::mem::offset_of!(ma_lpf1, pR1) - 16usize]; ++ ["Offset of field: ma_lpf1::_pHeap"][::core::mem::offset_of!(ma_lpf1, _pHeap) - 24usize]; ++ ["Offset of field: ma_lpf1::_ownsHeap"][::core::mem::offset_of!(ma_lpf1, _ownsHeap) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf1_get_heap_size( ++ pConfig: *const ma_lpf1_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_init_preallocated( ++ pConfig: *const ma_lpf1_config, ++ pHeap: *mut core::ffi::c_void, ++ pLPF: *mut ma_lpf1, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_init( ++ pConfig: *const ma_lpf1_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pLPF: *mut ma_lpf1, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_uninit(pLPF: *mut ma_lpf1, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_reinit(pConfig: *const ma_lpf1_config, pLPF: *mut ma_lpf1) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_clear_cache(pLPF: *mut ma_lpf1) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_process_pcm_frames( ++ pLPF: *mut ma_lpf1, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_get_latency(pLPF: *const ma_lpf1) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_lpf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_lpf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf2::bq"][::core::mem::offset_of!(ma_lpf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf2_get_heap_size( ++ pConfig: *const ma_lpf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_init_preallocated( ++ pConfig: *const ma_lpf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pHPF: *mut ma_lpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_init( ++ pConfig: *const ma_lpf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pLPF: *mut ma_lpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_uninit(pLPF: *mut ma_lpf2, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_reinit(pConfig: *const ma_lpf2_config, pLPF: *mut ma_lpf2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_clear_cache(pLPF: *mut ma_lpf2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_process_pcm_frames( ++ pLPF: *mut ma_lpf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_get_latency(pLPF: *const ma_lpf2) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub order: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_lpf_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf_config::format"] ++ [::core::mem::offset_of!(ma_lpf_config, format) - 0usize]; ++ ["Offset of field: ma_lpf_config::channels"] ++ [::core::mem::offset_of!(ma_lpf_config, channels) - 4usize]; ++ ["Offset of field: ma_lpf_config::sampleRate"] ++ [::core::mem::offset_of!(ma_lpf_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_lpf_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_lpf_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_lpf_config::order"] ++ [::core::mem::offset_of!(ma_lpf_config, order) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_lpf_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub lpf1Count: ma_uint32, ++ pub lpf2Count: ma_uint32, ++ pub pLPF1: *mut ma_lpf1, ++ pub pLPF2: *mut ma_lpf2, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_lpf"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf::format"][::core::mem::offset_of!(ma_lpf, format) - 0usize]; ++ ["Offset of field: ma_lpf::channels"][::core::mem::offset_of!(ma_lpf, channels) - 4usize]; ++ ["Offset of field: ma_lpf::sampleRate"][::core::mem::offset_of!(ma_lpf, sampleRate) - 8usize]; ++ ["Offset of field: ma_lpf::lpf1Count"][::core::mem::offset_of!(ma_lpf, lpf1Count) - 12usize]; ++ ["Offset of field: ma_lpf::lpf2Count"][::core::mem::offset_of!(ma_lpf, lpf2Count) - 16usize]; ++ ["Offset of field: ma_lpf::pLPF1"][::core::mem::offset_of!(ma_lpf, pLPF1) - 24usize]; ++ ["Offset of field: ma_lpf::pLPF2"][::core::mem::offset_of!(ma_lpf, pLPF2) - 32usize]; ++ ["Offset of field: ma_lpf::_pHeap"][::core::mem::offset_of!(ma_lpf, _pHeap) - 40usize]; ++ ["Offset of field: ma_lpf::_ownsHeap"][::core::mem::offset_of!(ma_lpf, _ownsHeap) - 48usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf_get_heap_size( ++ pConfig: *const ma_lpf_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_init_preallocated( ++ pConfig: *const ma_lpf_config, ++ pHeap: *mut core::ffi::c_void, ++ pLPF: *mut ma_lpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_init( ++ pConfig: *const ma_lpf_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pLPF: *mut ma_lpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_uninit(pLPF: *mut ma_lpf, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_lpf_reinit(pConfig: *const ma_lpf_config, pLPF: *mut ma_lpf) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_clear_cache(pLPF: *mut ma_lpf) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_process_pcm_frames( ++ pLPF: *mut ma_lpf, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_get_latency(pLPF: *const ma_lpf) -> ma_uint32; ++} ++#[doc = "High-Pass Filtering"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf1_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub q: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf1_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_hpf1_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf1_config::format"] ++ [::core::mem::offset_of!(ma_hpf1_config, format) - 0usize]; ++ ["Offset of field: ma_hpf1_config::channels"] ++ [::core::mem::offset_of!(ma_hpf1_config, channels) - 4usize]; ++ ["Offset of field: ma_hpf1_config::sampleRate"] ++ [::core::mem::offset_of!(ma_hpf1_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_hpf1_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_hpf1_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_hpf1_config::q"][::core::mem::offset_of!(ma_hpf1_config, q) - 24usize]; ++}; ++#[doc = "High-Pass Filtering"] ++pub type ma_hpf2_config = ma_hpf1_config; ++unsafe extern "C" { ++ pub fn ma_hpf1_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ ) -> ma_hpf1_config; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ q: f64, ++ ) -> ma_hpf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_hpf1 { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub a: ma_biquad_coefficient, ++ pub pR1: *mut ma_biquad_coefficient, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf1"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_hpf1"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf1::format"][::core::mem::offset_of!(ma_hpf1, format) - 0usize]; ++ ["Offset of field: ma_hpf1::channels"][::core::mem::offset_of!(ma_hpf1, channels) - 4usize]; ++ ["Offset of field: ma_hpf1::a"][::core::mem::offset_of!(ma_hpf1, a) - 8usize]; ++ ["Offset of field: ma_hpf1::pR1"][::core::mem::offset_of!(ma_hpf1, pR1) - 16usize]; ++ ["Offset of field: ma_hpf1::_pHeap"][::core::mem::offset_of!(ma_hpf1, _pHeap) - 24usize]; ++ ["Offset of field: ma_hpf1::_ownsHeap"][::core::mem::offset_of!(ma_hpf1, _ownsHeap) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf1_get_heap_size( ++ pConfig: *const ma_hpf1_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_init_preallocated( ++ pConfig: *const ma_hpf1_config, ++ pHeap: *mut core::ffi::c_void, ++ pLPF: *mut ma_hpf1, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_init( ++ pConfig: *const ma_hpf1_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pHPF: *mut ma_hpf1, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_uninit(pHPF: *mut ma_hpf1, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_reinit(pConfig: *const ma_hpf1_config, pHPF: *mut ma_hpf1) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_process_pcm_frames( ++ pHPF: *mut ma_hpf1, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_get_latency(pHPF: *const ma_hpf1) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_hpf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_hpf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf2::bq"][::core::mem::offset_of!(ma_hpf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf2_get_heap_size( ++ pConfig: *const ma_hpf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_init_preallocated( ++ pConfig: *const ma_hpf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pHPF: *mut ma_hpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_init( ++ pConfig: *const ma_hpf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pHPF: *mut ma_hpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_uninit(pHPF: *mut ma_hpf2, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_reinit(pConfig: *const ma_hpf2_config, pHPF: *mut ma_hpf2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_process_pcm_frames( ++ pHPF: *mut ma_hpf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_get_latency(pHPF: *const ma_hpf2) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub order: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_hpf_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf_config::format"] ++ [::core::mem::offset_of!(ma_hpf_config, format) - 0usize]; ++ ["Offset of field: ma_hpf_config::channels"] ++ [::core::mem::offset_of!(ma_hpf_config, channels) - 4usize]; ++ ["Offset of field: ma_hpf_config::sampleRate"] ++ [::core::mem::offset_of!(ma_hpf_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_hpf_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_hpf_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_hpf_config::order"] ++ [::core::mem::offset_of!(ma_hpf_config, order) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_hpf_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub hpf1Count: ma_uint32, ++ pub hpf2Count: ma_uint32, ++ pub pHPF1: *mut ma_hpf1, ++ pub pHPF2: *mut ma_hpf2, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_hpf"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf::format"][::core::mem::offset_of!(ma_hpf, format) - 0usize]; ++ ["Offset of field: ma_hpf::channels"][::core::mem::offset_of!(ma_hpf, channels) - 4usize]; ++ ["Offset of field: ma_hpf::sampleRate"][::core::mem::offset_of!(ma_hpf, sampleRate) - 8usize]; ++ ["Offset of field: ma_hpf::hpf1Count"][::core::mem::offset_of!(ma_hpf, hpf1Count) - 12usize]; ++ ["Offset of field: ma_hpf::hpf2Count"][::core::mem::offset_of!(ma_hpf, hpf2Count) - 16usize]; ++ ["Offset of field: ma_hpf::pHPF1"][::core::mem::offset_of!(ma_hpf, pHPF1) - 24usize]; ++ ["Offset of field: ma_hpf::pHPF2"][::core::mem::offset_of!(ma_hpf, pHPF2) - 32usize]; ++ ["Offset of field: ma_hpf::_pHeap"][::core::mem::offset_of!(ma_hpf, _pHeap) - 40usize]; ++ ["Offset of field: ma_hpf::_ownsHeap"][::core::mem::offset_of!(ma_hpf, _ownsHeap) - 48usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf_get_heap_size( ++ pConfig: *const ma_hpf_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_init_preallocated( ++ pConfig: *const ma_hpf_config, ++ pHeap: *mut core::ffi::c_void, ++ pLPF: *mut ma_hpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_init( ++ pConfig: *const ma_hpf_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pHPF: *mut ma_hpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_uninit(pHPF: *mut ma_hpf, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_hpf_reinit(pConfig: *const ma_hpf_config, pHPF: *mut ma_hpf) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_process_pcm_frames( ++ pHPF: *mut ma_hpf, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_get_latency(pHPF: *const ma_hpf) -> ma_uint32; ++} ++#[doc = "Band-Pass Filtering"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub q: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf2_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_bpf2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf2_config::format"] ++ [::core::mem::offset_of!(ma_bpf2_config, format) - 0usize]; ++ ["Offset of field: ma_bpf2_config::channels"] ++ [::core::mem::offset_of!(ma_bpf2_config, channels) - 4usize]; ++ ["Offset of field: ma_bpf2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_bpf2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_bpf2_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_bpf2_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_bpf2_config::q"][::core::mem::offset_of!(ma_bpf2_config, q) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ q: f64, ++ ) -> ma_bpf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_bpf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_bpf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf2::bq"][::core::mem::offset_of!(ma_bpf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf2_get_heap_size( ++ pConfig: *const ma_bpf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_init_preallocated( ++ pConfig: *const ma_bpf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pBPF: *mut ma_bpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_init( ++ pConfig: *const ma_bpf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pBPF: *mut ma_bpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_uninit(pBPF: *mut ma_bpf2, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_reinit(pConfig: *const ma_bpf2_config, pBPF: *mut ma_bpf2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_process_pcm_frames( ++ pBPF: *mut ma_bpf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_get_latency(pBPF: *const ma_bpf2) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub order: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_bpf_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf_config::format"] ++ [::core::mem::offset_of!(ma_bpf_config, format) - 0usize]; ++ ["Offset of field: ma_bpf_config::channels"] ++ [::core::mem::offset_of!(ma_bpf_config, channels) - 4usize]; ++ ["Offset of field: ma_bpf_config::sampleRate"] ++ [::core::mem::offset_of!(ma_bpf_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_bpf_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_bpf_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_bpf_config::order"] ++ [::core::mem::offset_of!(ma_bpf_config, order) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_bpf_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub bpf2Count: ma_uint32, ++ pub pBPF2: *mut ma_bpf2, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_bpf"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf::format"][::core::mem::offset_of!(ma_bpf, format) - 0usize]; ++ ["Offset of field: ma_bpf::channels"][::core::mem::offset_of!(ma_bpf, channels) - 4usize]; ++ ["Offset of field: ma_bpf::bpf2Count"][::core::mem::offset_of!(ma_bpf, bpf2Count) - 8usize]; ++ ["Offset of field: ma_bpf::pBPF2"][::core::mem::offset_of!(ma_bpf, pBPF2) - 16usize]; ++ ["Offset of field: ma_bpf::_pHeap"][::core::mem::offset_of!(ma_bpf, _pHeap) - 24usize]; ++ ["Offset of field: ma_bpf::_ownsHeap"][::core::mem::offset_of!(ma_bpf, _ownsHeap) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf_get_heap_size( ++ pConfig: *const ma_bpf_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_init_preallocated( ++ pConfig: *const ma_bpf_config, ++ pHeap: *mut core::ffi::c_void, ++ pBPF: *mut ma_bpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_init( ++ pConfig: *const ma_bpf_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pBPF: *mut ma_bpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_uninit(pBPF: *mut ma_bpf, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_bpf_reinit(pConfig: *const ma_bpf_config, pBPF: *mut ma_bpf) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_process_pcm_frames( ++ pBPF: *mut ma_bpf, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_get_latency(pBPF: *const ma_bpf) -> ma_uint32; ++} ++#[doc = "Notching Filter"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_notch2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub q: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_notch2_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_notch2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_notch2_config::format"] ++ [::core::mem::offset_of!(ma_notch2_config, format) - 0usize]; ++ ["Offset of field: ma_notch2_config::channels"] ++ [::core::mem::offset_of!(ma_notch2_config, channels) - 4usize]; ++ ["Offset of field: ma_notch2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_notch2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_notch2_config::q"] ++ [::core::mem::offset_of!(ma_notch2_config, q) - 16usize]; ++ ["Offset of field: ma_notch2_config::frequency"] ++ [::core::mem::offset_of!(ma_notch2_config, frequency) - 24usize]; ++}; ++#[doc = "Notching Filter"] ++pub type ma_notch_config = ma_notch2_config; ++unsafe extern "C" { ++ pub fn ma_notch2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ q: f64, ++ frequency: f64, ++ ) -> ma_notch2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_notch2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_notch2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_notch2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_notch2::bq"][::core::mem::offset_of!(ma_notch2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_notch2_get_heap_size( ++ pConfig: *const ma_notch2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_init_preallocated( ++ pConfig: *const ma_notch2_config, ++ pHeap: *mut core::ffi::c_void, ++ pFilter: *mut ma_notch2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_init( ++ pConfig: *const ma_notch2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pFilter: *mut ma_notch2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_uninit( ++ pFilter: *mut ma_notch2, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_notch2_reinit(pConfig: *const ma_notch2_config, pFilter: *mut ma_notch2) ++ -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_process_pcm_frames( ++ pFilter: *mut ma_notch2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_get_latency(pFilter: *const ma_notch2) -> ma_uint32; ++} ++#[doc = "Peaking EQ Filter"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_peak2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub gainDB: f64, ++ pub q: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_peak2_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_peak2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_peak2_config::format"] ++ [::core::mem::offset_of!(ma_peak2_config, format) - 0usize]; ++ ["Offset of field: ma_peak2_config::channels"] ++ [::core::mem::offset_of!(ma_peak2_config, channels) - 4usize]; ++ ["Offset of field: ma_peak2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_peak2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_peak2_config::gainDB"] ++ [::core::mem::offset_of!(ma_peak2_config, gainDB) - 16usize]; ++ ["Offset of field: ma_peak2_config::q"][::core::mem::offset_of!(ma_peak2_config, q) - 24usize]; ++ ["Offset of field: ma_peak2_config::frequency"] ++ [::core::mem::offset_of!(ma_peak2_config, frequency) - 32usize]; ++}; ++#[doc = "Peaking EQ Filter"] ++pub type ma_peak_config = ma_peak2_config; ++unsafe extern "C" { ++ pub fn ma_peak2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ q: f64, ++ frequency: f64, ++ ) -> ma_peak2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_peak2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_peak2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_peak2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_peak2::bq"][::core::mem::offset_of!(ma_peak2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_peak2_get_heap_size( ++ pConfig: *const ma_peak2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_init_preallocated( ++ pConfig: *const ma_peak2_config, ++ pHeap: *mut core::ffi::c_void, ++ pFilter: *mut ma_peak2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_init( ++ pConfig: *const ma_peak2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pFilter: *mut ma_peak2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_uninit( ++ pFilter: *mut ma_peak2, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_peak2_reinit(pConfig: *const ma_peak2_config, pFilter: *mut ma_peak2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_process_pcm_frames( ++ pFilter: *mut ma_peak2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_get_latency(pFilter: *const ma_peak2) -> ma_uint32; ++} ++#[doc = "Low Shelf Filter"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_loshelf2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub gainDB: f64, ++ pub shelfSlope: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_loshelf2_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_loshelf2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_loshelf2_config::format"] ++ [::core::mem::offset_of!(ma_loshelf2_config, format) - 0usize]; ++ ["Offset of field: ma_loshelf2_config::channels"] ++ [::core::mem::offset_of!(ma_loshelf2_config, channels) - 4usize]; ++ ["Offset of field: ma_loshelf2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_loshelf2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_loshelf2_config::gainDB"] ++ [::core::mem::offset_of!(ma_loshelf2_config, gainDB) - 16usize]; ++ ["Offset of field: ma_loshelf2_config::shelfSlope"] ++ [::core::mem::offset_of!(ma_loshelf2_config, shelfSlope) - 24usize]; ++ ["Offset of field: ma_loshelf2_config::frequency"] ++ [::core::mem::offset_of!(ma_loshelf2_config, frequency) - 32usize]; ++}; ++#[doc = "Low Shelf Filter"] ++pub type ma_loshelf_config = ma_loshelf2_config; ++unsafe extern "C" { ++ pub fn ma_loshelf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ shelfSlope: f64, ++ frequency: f64, ++ ) -> ma_loshelf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_loshelf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_loshelf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_loshelf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_loshelf2::bq"][::core::mem::offset_of!(ma_loshelf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_loshelf2_get_heap_size( ++ pConfig: *const ma_loshelf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_init_preallocated( ++ pConfig: *const ma_loshelf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pFilter: *mut ma_loshelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_init( ++ pConfig: *const ma_loshelf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pFilter: *mut ma_loshelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_uninit( ++ pFilter: *mut ma_loshelf2, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_reinit( ++ pConfig: *const ma_loshelf2_config, ++ pFilter: *mut ma_loshelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_process_pcm_frames( ++ pFilter: *mut ma_loshelf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_get_latency(pFilter: *const ma_loshelf2) -> ma_uint32; ++} ++#[doc = "High Shelf Filter"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hishelf2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub gainDB: f64, ++ pub shelfSlope: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hishelf2_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_hishelf2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hishelf2_config::format"] ++ [::core::mem::offset_of!(ma_hishelf2_config, format) - 0usize]; ++ ["Offset of field: ma_hishelf2_config::channels"] ++ [::core::mem::offset_of!(ma_hishelf2_config, channels) - 4usize]; ++ ["Offset of field: ma_hishelf2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_hishelf2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_hishelf2_config::gainDB"] ++ [::core::mem::offset_of!(ma_hishelf2_config, gainDB) - 16usize]; ++ ["Offset of field: ma_hishelf2_config::shelfSlope"] ++ [::core::mem::offset_of!(ma_hishelf2_config, shelfSlope) - 24usize]; ++ ["Offset of field: ma_hishelf2_config::frequency"] ++ [::core::mem::offset_of!(ma_hishelf2_config, frequency) - 32usize]; ++}; ++#[doc = "High Shelf Filter"] ++pub type ma_hishelf_config = ma_hishelf2_config; ++unsafe extern "C" { ++ pub fn ma_hishelf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ shelfSlope: f64, ++ frequency: f64, ++ ) -> ma_hishelf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_hishelf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hishelf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_hishelf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hishelf2::bq"][::core::mem::offset_of!(ma_hishelf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hishelf2_get_heap_size( ++ pConfig: *const ma_hishelf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_init_preallocated( ++ pConfig: *const ma_hishelf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pFilter: *mut ma_hishelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_init( ++ pConfig: *const ma_hishelf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pFilter: *mut ma_hishelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_uninit( ++ pFilter: *mut ma_hishelf2, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_reinit( ++ pConfig: *const ma_hishelf2_config, ++ pFilter: *mut ma_hishelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_process_pcm_frames( ++ pFilter: *mut ma_hishelf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_get_latency(pFilter: *const ma_hishelf2) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_delay_config { ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub delayInFrames: ma_uint32, ++ pub delayStart: ma_bool32, ++ pub wet: f32, ++ pub dry: f32, ++ pub decay: f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_delay_config"][::core::mem::size_of::() - 28usize]; ++ ["Alignment of ma_delay_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_delay_config::channels"] ++ [::core::mem::offset_of!(ma_delay_config, channels) - 0usize]; ++ ["Offset of field: ma_delay_config::sampleRate"] ++ [::core::mem::offset_of!(ma_delay_config, sampleRate) - 4usize]; ++ ["Offset of field: ma_delay_config::delayInFrames"] ++ [::core::mem::offset_of!(ma_delay_config, delayInFrames) - 8usize]; ++ ["Offset of field: ma_delay_config::delayStart"] ++ [::core::mem::offset_of!(ma_delay_config, delayStart) - 12usize]; ++ ["Offset of field: ma_delay_config::wet"] ++ [::core::mem::offset_of!(ma_delay_config, wet) - 16usize]; ++ ["Offset of field: ma_delay_config::dry"] ++ [::core::mem::offset_of!(ma_delay_config, dry) - 20usize]; ++ ["Offset of field: ma_delay_config::decay"] ++ [::core::mem::offset_of!(ma_delay_config, decay) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_delay_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ delayInFrames: ma_uint32, ++ decay: f32, ++ ) -> ma_delay_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_delay { ++ pub config: ma_delay_config, ++ pub cursor: ma_uint32, ++ pub bufferSizeInFrames: ma_uint32, ++ pub pBuffer: *mut f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_delay"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_delay"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_delay::config"][::core::mem::offset_of!(ma_delay, config) - 0usize]; ++ ["Offset of field: ma_delay::cursor"][::core::mem::offset_of!(ma_delay, cursor) - 28usize]; ++ ["Offset of field: ma_delay::bufferSizeInFrames"] ++ [::core::mem::offset_of!(ma_delay, bufferSizeInFrames) - 32usize]; ++ ["Offset of field: ma_delay::pBuffer"][::core::mem::offset_of!(ma_delay, pBuffer) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_delay_init( ++ pConfig: *const ma_delay_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pDelay: *mut ma_delay, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_delay_uninit( ++ pDelay: *mut ma_delay, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_delay_process_pcm_frames( ++ pDelay: *mut ma_delay, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_delay_set_wet(pDelay: *mut ma_delay, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_get_wet(pDelay: *const ma_delay) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_delay_set_dry(pDelay: *mut ma_delay, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_get_dry(pDelay: *const ma_delay) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_delay_set_decay(pDelay: *mut ma_delay, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_get_decay(pDelay: *const ma_delay) -> f32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_gainer_config { ++ pub channels: ma_uint32, ++ pub smoothTimeInFrames: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_gainer_config"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_gainer_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_gainer_config::channels"] ++ [::core::mem::offset_of!(ma_gainer_config, channels) - 0usize]; ++ ["Offset of field: ma_gainer_config::smoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_gainer_config, smoothTimeInFrames) - 4usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_gainer_config_init( ++ channels: ma_uint32, ++ smoothTimeInFrames: ma_uint32, ++ ) -> ma_gainer_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_gainer { ++ pub config: ma_gainer_config, ++ pub t: ma_uint32, ++ pub masterVolume: f32, ++ pub pOldGains: *mut f32, ++ pub pNewGains: *mut f32, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_gainer"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_gainer"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_gainer::config"][::core::mem::offset_of!(ma_gainer, config) - 0usize]; ++ ["Offset of field: ma_gainer::t"][::core::mem::offset_of!(ma_gainer, t) - 8usize]; ++ ["Offset of field: ma_gainer::masterVolume"] ++ [::core::mem::offset_of!(ma_gainer, masterVolume) - 12usize]; ++ ["Offset of field: ma_gainer::pOldGains"] ++ [::core::mem::offset_of!(ma_gainer, pOldGains) - 16usize]; ++ ["Offset of field: ma_gainer::pNewGains"] ++ [::core::mem::offset_of!(ma_gainer, pNewGains) - 24usize]; ++ ["Offset of field: ma_gainer::_pHeap"][::core::mem::offset_of!(ma_gainer, _pHeap) - 32usize]; ++ ["Offset of field: ma_gainer::_ownsHeap"] ++ [::core::mem::offset_of!(ma_gainer, _ownsHeap) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_gainer_get_heap_size( ++ pConfig: *const ma_gainer_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_init_preallocated( ++ pConfig: *const ma_gainer_config, ++ pHeap: *mut core::ffi::c_void, ++ pGainer: *mut ma_gainer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_init( ++ pConfig: *const ma_gainer_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pGainer: *mut ma_gainer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_uninit( ++ pGainer: *mut ma_gainer, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_gainer_process_pcm_frames( ++ pGainer: *mut ma_gainer, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_set_gain(pGainer: *mut ma_gainer, newGain: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_set_gains(pGainer: *mut ma_gainer, pNewGains: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_set_master_volume(pGainer: *mut ma_gainer, volume: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_get_master_volume(pGainer: *const ma_gainer, pVolume: *mut f32) -> ma_result; ++} ++pub const ma_pan_mode_ma_pan_mode_balance: ma_pan_mode = 0; ++pub const ma_pan_mode_ma_pan_mode_pan: ma_pan_mode = 1; ++pub type ma_pan_mode = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_panner_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub mode: ma_pan_mode, ++ pub pan: f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_panner_config"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_panner_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_panner_config::format"] ++ [::core::mem::offset_of!(ma_panner_config, format) - 0usize]; ++ ["Offset of field: ma_panner_config::channels"] ++ [::core::mem::offset_of!(ma_panner_config, channels) - 4usize]; ++ ["Offset of field: ma_panner_config::mode"] ++ [::core::mem::offset_of!(ma_panner_config, mode) - 8usize]; ++ ["Offset of field: ma_panner_config::pan"] ++ [::core::mem::offset_of!(ma_panner_config, pan) - 12usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_panner_config_init(format: ma_format, channels: ma_uint32) -> ma_panner_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_panner { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub mode: ma_pan_mode, ++ pub pan: f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_panner"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_panner"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_panner::format"][::core::mem::offset_of!(ma_panner, format) - 0usize]; ++ ["Offset of field: ma_panner::channels"][::core::mem::offset_of!(ma_panner, channels) - 4usize]; ++ ["Offset of field: ma_panner::mode"][::core::mem::offset_of!(ma_panner, mode) - 8usize]; ++ ["Offset of field: ma_panner::pan"][::core::mem::offset_of!(ma_panner, pan) - 12usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_panner_init(pConfig: *const ma_panner_config, pPanner: *mut ma_panner) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_panner_process_pcm_frames( ++ pPanner: *mut ma_panner, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_panner_set_mode(pPanner: *mut ma_panner, mode: ma_pan_mode); ++} ++unsafe extern "C" { ++ pub fn ma_panner_get_mode(pPanner: *const ma_panner) -> ma_pan_mode; ++} ++unsafe extern "C" { ++ pub fn ma_panner_set_pan(pPanner: *mut ma_panner, pan: f32); ++} ++unsafe extern "C" { ++ pub fn ma_panner_get_pan(pPanner: *const ma_panner) -> f32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_fader_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_fader_config"][::core::mem::size_of::() - 12usize]; ++ ["Alignment of ma_fader_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_fader_config::format"] ++ [::core::mem::offset_of!(ma_fader_config, format) - 0usize]; ++ ["Offset of field: ma_fader_config::channels"] ++ [::core::mem::offset_of!(ma_fader_config, channels) - 4usize]; ++ ["Offset of field: ma_fader_config::sampleRate"] ++ [::core::mem::offset_of!(ma_fader_config, sampleRate) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_fader_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_fader_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_fader { ++ pub config: ma_fader_config, ++ pub volumeBeg: f32, ++ pub volumeEnd: f32, ++ pub lengthInFrames: ma_uint64, ++ pub cursorInFrames: ma_int64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_fader"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_fader"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_fader::config"][::core::mem::offset_of!(ma_fader, config) - 0usize]; ++ ["Offset of field: ma_fader::volumeBeg"] ++ [::core::mem::offset_of!(ma_fader, volumeBeg) - 12usize]; ++ ["Offset of field: ma_fader::volumeEnd"] ++ [::core::mem::offset_of!(ma_fader, volumeEnd) - 16usize]; ++ ["Offset of field: ma_fader::lengthInFrames"] ++ [::core::mem::offset_of!(ma_fader, lengthInFrames) - 24usize]; ++ ["Offset of field: ma_fader::cursorInFrames"] ++ [::core::mem::offset_of!(ma_fader, cursorInFrames) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_fader_init(pConfig: *const ma_fader_config, pFader: *mut ma_fader) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fader_process_pcm_frames( ++ pFader: *mut ma_fader, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fader_get_data_format( ++ pFader: *const ma_fader, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_fader_set_fade( ++ pFader: *mut ma_fader, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ lengthInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_fader_set_fade_ex( ++ pFader: *mut ma_fader, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ lengthInFrames: ma_uint64, ++ startOffsetInFrames: ma_int64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_fader_get_current_volume(pFader: *const ma_fader) -> f32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_vec3f { ++ pub x: f32, ++ pub y: f32, ++ pub z: f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_vec3f"][::core::mem::size_of::() - 12usize]; ++ ["Alignment of ma_vec3f"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_vec3f::x"][::core::mem::offset_of!(ma_vec3f, x) - 0usize]; ++ ["Offset of field: ma_vec3f::y"][::core::mem::offset_of!(ma_vec3f, y) - 4usize]; ++ ["Offset of field: ma_vec3f::z"][::core::mem::offset_of!(ma_vec3f, z) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_vec3f { ++ pub v: ma_vec3f, ++ pub lock: ma_spinlock, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_vec3f"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_atomic_vec3f"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_vec3f::v"][::core::mem::offset_of!(ma_atomic_vec3f, v) - 0usize]; ++ ["Offset of field: ma_atomic_vec3f::lock"] ++ [::core::mem::offset_of!(ma_atomic_vec3f, lock) - 12usize]; ++}; ++pub const ma_attenuation_model_ma_attenuation_model_none: ma_attenuation_model = 0; ++pub const ma_attenuation_model_ma_attenuation_model_inverse: ma_attenuation_model = 1; ++pub const ma_attenuation_model_ma_attenuation_model_linear: ma_attenuation_model = 2; ++pub const ma_attenuation_model_ma_attenuation_model_exponential: ma_attenuation_model = 3; ++pub type ma_attenuation_model = core::ffi::c_uint; ++pub const ma_positioning_ma_positioning_absolute: ma_positioning = 0; ++pub const ma_positioning_ma_positioning_relative: ma_positioning = 1; ++pub type ma_positioning = core::ffi::c_uint; ++pub const ma_handedness_ma_handedness_right: ma_handedness = 0; ++pub const ma_handedness_ma_handedness_left: ma_handedness = 1; ++pub type ma_handedness = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_spatializer_listener_config { ++ pub channelsOut: ma_uint32, ++ pub pChannelMapOut: *mut ma_channel, ++ pub handedness: ma_handedness, ++ pub coneInnerAngleInRadians: f32, ++ pub coneOuterAngleInRadians: f32, ++ pub coneOuterGain: f32, ++ pub speedOfSound: f32, ++ pub worldUp: ma_vec3f, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_spatializer_listener_config"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_spatializer_listener_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_spatializer_listener_config::channelsOut"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, channelsOut) - 0usize]; ++ ["Offset of field: ma_spatializer_listener_config::pChannelMapOut"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, pChannelMapOut) - 8usize]; ++ ["Offset of field: ma_spatializer_listener_config::handedness"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, handedness) - 16usize]; ++ ["Offset of field: ma_spatializer_listener_config::coneInnerAngleInRadians"][::core::mem::offset_of!( ++ ma_spatializer_listener_config, ++ coneInnerAngleInRadians ++ ) - 20usize]; ++ ["Offset of field: ma_spatializer_listener_config::coneOuterAngleInRadians"][::core::mem::offset_of!( ++ ma_spatializer_listener_config, ++ coneOuterAngleInRadians ++ ) - 24usize]; ++ ["Offset of field: ma_spatializer_listener_config::coneOuterGain"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, coneOuterGain) - 28usize]; ++ ["Offset of field: ma_spatializer_listener_config::speedOfSound"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, speedOfSound) - 32usize]; ++ ["Offset of field: ma_spatializer_listener_config::worldUp"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, worldUp) - 36usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_config_init( ++ channelsOut: ma_uint32, ++ ) -> ma_spatializer_listener_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_spatializer_listener { ++ pub config: ma_spatializer_listener_config, ++ pub position: ma_atomic_vec3f, ++ pub direction: ma_atomic_vec3f, ++ pub velocity: ma_atomic_vec3f, ++ pub isEnabled: ma_bool32, ++ pub _ownsHeap: ma_bool32, ++ pub _pHeap: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_spatializer_listener"] ++ [::core::mem::size_of::() - 112usize]; ++ ["Alignment of ma_spatializer_listener"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_spatializer_listener::config"] ++ [::core::mem::offset_of!(ma_spatializer_listener, config) - 0usize]; ++ ["Offset of field: ma_spatializer_listener::position"] ++ [::core::mem::offset_of!(ma_spatializer_listener, position) - 48usize]; ++ ["Offset of field: ma_spatializer_listener::direction"] ++ [::core::mem::offset_of!(ma_spatializer_listener, direction) - 64usize]; ++ ["Offset of field: ma_spatializer_listener::velocity"] ++ [::core::mem::offset_of!(ma_spatializer_listener, velocity) - 80usize]; ++ ["Offset of field: ma_spatializer_listener::isEnabled"] ++ [::core::mem::offset_of!(ma_spatializer_listener, isEnabled) - 96usize]; ++ ["Offset of field: ma_spatializer_listener::_ownsHeap"] ++ [::core::mem::offset_of!(ma_spatializer_listener, _ownsHeap) - 100usize]; ++ ["Offset of field: ma_spatializer_listener::_pHeap"] ++ [::core::mem::offset_of!(ma_spatializer_listener, _pHeap) - 104usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_heap_size( ++ pConfig: *const ma_spatializer_listener_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_init_preallocated( ++ pConfig: *const ma_spatializer_listener_config, ++ pHeap: *mut core::ffi::c_void, ++ pListener: *mut ma_spatializer_listener, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_init( ++ pConfig: *const ma_spatializer_listener_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pListener: *mut ma_spatializer_listener, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_uninit( ++ pListener: *mut ma_spatializer_listener, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_channel_map( ++ pListener: *mut ma_spatializer_listener, ++ ) -> *mut ma_channel; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_cone( ++ pListener: *mut ma_spatializer_listener, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_cone( ++ pListener: *const ma_spatializer_listener, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_position( ++ pListener: *mut ma_spatializer_listener, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_position( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_direction( ++ pListener: *mut ma_spatializer_listener, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_direction( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_velocity( ++ pListener: *mut ma_spatializer_listener, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_velocity( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_speed_of_sound( ++ pListener: *mut ma_spatializer_listener, ++ speedOfSound: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_speed_of_sound( ++ pListener: *const ma_spatializer_listener, ++ ) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_world_up( ++ pListener: *mut ma_spatializer_listener, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_world_up( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_enabled( ++ pListener: *mut ma_spatializer_listener, ++ isEnabled: ma_bool32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_is_enabled( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_bool32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_spatializer_config { ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub pChannelMapIn: *mut ma_channel, ++ pub attenuationModel: ma_attenuation_model, ++ pub positioning: ma_positioning, ++ pub handedness: ma_handedness, ++ pub minGain: f32, ++ pub maxGain: f32, ++ pub minDistance: f32, ++ pub maxDistance: f32, ++ pub rolloff: f32, ++ pub coneInnerAngleInRadians: f32, ++ pub coneOuterAngleInRadians: f32, ++ pub coneOuterGain: f32, ++ pub dopplerFactor: f32, ++ pub directionalAttenuationFactor: f32, ++ pub minSpatializationChannelGain: f32, ++ pub gainSmoothTimeInFrames: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_spatializer_config"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_spatializer_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_spatializer_config::channelsIn"] ++ [::core::mem::offset_of!(ma_spatializer_config, channelsIn) - 0usize]; ++ ["Offset of field: ma_spatializer_config::channelsOut"] ++ [::core::mem::offset_of!(ma_spatializer_config, channelsOut) - 4usize]; ++ ["Offset of field: ma_spatializer_config::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_spatializer_config, pChannelMapIn) - 8usize]; ++ ["Offset of field: ma_spatializer_config::attenuationModel"] ++ [::core::mem::offset_of!(ma_spatializer_config, attenuationModel) - 16usize]; ++ ["Offset of field: ma_spatializer_config::positioning"] ++ [::core::mem::offset_of!(ma_spatializer_config, positioning) - 20usize]; ++ ["Offset of field: ma_spatializer_config::handedness"] ++ [::core::mem::offset_of!(ma_spatializer_config, handedness) - 24usize]; ++ ["Offset of field: ma_spatializer_config::minGain"] ++ [::core::mem::offset_of!(ma_spatializer_config, minGain) - 28usize]; ++ ["Offset of field: ma_spatializer_config::maxGain"] ++ [::core::mem::offset_of!(ma_spatializer_config, maxGain) - 32usize]; ++ ["Offset of field: ma_spatializer_config::minDistance"] ++ [::core::mem::offset_of!(ma_spatializer_config, minDistance) - 36usize]; ++ ["Offset of field: ma_spatializer_config::maxDistance"] ++ [::core::mem::offset_of!(ma_spatializer_config, maxDistance) - 40usize]; ++ ["Offset of field: ma_spatializer_config::rolloff"] ++ [::core::mem::offset_of!(ma_spatializer_config, rolloff) - 44usize]; ++ ["Offset of field: ma_spatializer_config::coneInnerAngleInRadians"] ++ [::core::mem::offset_of!(ma_spatializer_config, coneInnerAngleInRadians) - 48usize]; ++ ["Offset of field: ma_spatializer_config::coneOuterAngleInRadians"] ++ [::core::mem::offset_of!(ma_spatializer_config, coneOuterAngleInRadians) - 52usize]; ++ ["Offset of field: ma_spatializer_config::coneOuterGain"] ++ [::core::mem::offset_of!(ma_spatializer_config, coneOuterGain) - 56usize]; ++ ["Offset of field: ma_spatializer_config::dopplerFactor"] ++ [::core::mem::offset_of!(ma_spatializer_config, dopplerFactor) - 60usize]; ++ ["Offset of field: ma_spatializer_config::directionalAttenuationFactor"] ++ [::core::mem::offset_of!(ma_spatializer_config, directionalAttenuationFactor) - 64usize]; ++ ["Offset of field: ma_spatializer_config::minSpatializationChannelGain"] ++ [::core::mem::offset_of!(ma_spatializer_config, minSpatializationChannelGain) - 68usize]; ++ ["Offset of field: ma_spatializer_config::gainSmoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_spatializer_config, gainSmoothTimeInFrames) - 72usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_spatializer_config_init( ++ channelsIn: ma_uint32, ++ channelsOut: ma_uint32, ++ ) -> ma_spatializer_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_spatializer { ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub pChannelMapIn: *mut ma_channel, ++ pub attenuationModel: ma_attenuation_model, ++ pub positioning: ma_positioning, ++ pub handedness: ma_handedness, ++ pub minGain: f32, ++ pub maxGain: f32, ++ pub minDistance: f32, ++ pub maxDistance: f32, ++ pub rolloff: f32, ++ pub coneInnerAngleInRadians: f32, ++ pub coneOuterAngleInRadians: f32, ++ pub coneOuterGain: f32, ++ pub dopplerFactor: f32, ++ pub directionalAttenuationFactor: f32, ++ pub gainSmoothTimeInFrames: ma_uint32, ++ pub position: ma_atomic_vec3f, ++ pub direction: ma_atomic_vec3f, ++ pub velocity: ma_atomic_vec3f, ++ pub dopplerPitch: f32, ++ pub minSpatializationChannelGain: f32, ++ pub gainer: ma_gainer, ++ pub pNewChannelGainsOut: *mut f32, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_spatializer"][::core::mem::size_of::() - 200usize]; ++ ["Alignment of ma_spatializer"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_spatializer::channelsIn"] ++ [::core::mem::offset_of!(ma_spatializer, channelsIn) - 0usize]; ++ ["Offset of field: ma_spatializer::channelsOut"] ++ [::core::mem::offset_of!(ma_spatializer, channelsOut) - 4usize]; ++ ["Offset of field: ma_spatializer::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_spatializer, pChannelMapIn) - 8usize]; ++ ["Offset of field: ma_spatializer::attenuationModel"] ++ [::core::mem::offset_of!(ma_spatializer, attenuationModel) - 16usize]; ++ ["Offset of field: ma_spatializer::positioning"] ++ [::core::mem::offset_of!(ma_spatializer, positioning) - 20usize]; ++ ["Offset of field: ma_spatializer::handedness"] ++ [::core::mem::offset_of!(ma_spatializer, handedness) - 24usize]; ++ ["Offset of field: ma_spatializer::minGain"] ++ [::core::mem::offset_of!(ma_spatializer, minGain) - 28usize]; ++ ["Offset of field: ma_spatializer::maxGain"] ++ [::core::mem::offset_of!(ma_spatializer, maxGain) - 32usize]; ++ ["Offset of field: ma_spatializer::minDistance"] ++ [::core::mem::offset_of!(ma_spatializer, minDistance) - 36usize]; ++ ["Offset of field: ma_spatializer::maxDistance"] ++ [::core::mem::offset_of!(ma_spatializer, maxDistance) - 40usize]; ++ ["Offset of field: ma_spatializer::rolloff"] ++ [::core::mem::offset_of!(ma_spatializer, rolloff) - 44usize]; ++ ["Offset of field: ma_spatializer::coneInnerAngleInRadians"] ++ [::core::mem::offset_of!(ma_spatializer, coneInnerAngleInRadians) - 48usize]; ++ ["Offset of field: ma_spatializer::coneOuterAngleInRadians"] ++ [::core::mem::offset_of!(ma_spatializer, coneOuterAngleInRadians) - 52usize]; ++ ["Offset of field: ma_spatializer::coneOuterGain"] ++ [::core::mem::offset_of!(ma_spatializer, coneOuterGain) - 56usize]; ++ ["Offset of field: ma_spatializer::dopplerFactor"] ++ [::core::mem::offset_of!(ma_spatializer, dopplerFactor) - 60usize]; ++ ["Offset of field: ma_spatializer::directionalAttenuationFactor"] ++ [::core::mem::offset_of!(ma_spatializer, directionalAttenuationFactor) - 64usize]; ++ ["Offset of field: ma_spatializer::gainSmoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_spatializer, gainSmoothTimeInFrames) - 68usize]; ++ ["Offset of field: ma_spatializer::position"] ++ [::core::mem::offset_of!(ma_spatializer, position) - 72usize]; ++ ["Offset of field: ma_spatializer::direction"] ++ [::core::mem::offset_of!(ma_spatializer, direction) - 88usize]; ++ ["Offset of field: ma_spatializer::velocity"] ++ [::core::mem::offset_of!(ma_spatializer, velocity) - 104usize]; ++ ["Offset of field: ma_spatializer::dopplerPitch"] ++ [::core::mem::offset_of!(ma_spatializer, dopplerPitch) - 120usize]; ++ ["Offset of field: ma_spatializer::minSpatializationChannelGain"] ++ [::core::mem::offset_of!(ma_spatializer, minSpatializationChannelGain) - 124usize]; ++ ["Offset of field: ma_spatializer::gainer"] ++ [::core::mem::offset_of!(ma_spatializer, gainer) - 128usize]; ++ ["Offset of field: ma_spatializer::pNewChannelGainsOut"] ++ [::core::mem::offset_of!(ma_spatializer, pNewChannelGainsOut) - 176usize]; ++ ["Offset of field: ma_spatializer::_pHeap"] ++ [::core::mem::offset_of!(ma_spatializer, _pHeap) - 184usize]; ++ ["Offset of field: ma_spatializer::_ownsHeap"] ++ [::core::mem::offset_of!(ma_spatializer, _ownsHeap) - 192usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_spatializer_get_heap_size( ++ pConfig: *const ma_spatializer_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_init_preallocated( ++ pConfig: *const ma_spatializer_config, ++ pHeap: *mut core::ffi::c_void, ++ pSpatializer: *mut ma_spatializer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_init( ++ pConfig: *const ma_spatializer_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pSpatializer: *mut ma_spatializer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_uninit( ++ pSpatializer: *mut ma_spatializer, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_process_pcm_frames( ++ pSpatializer: *mut ma_spatializer, ++ pListener: *mut ma_spatializer_listener, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_master_volume( ++ pSpatializer: *mut ma_spatializer, ++ volume: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_master_volume( ++ pSpatializer: *const ma_spatializer, ++ pVolume: *mut f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_input_channels(pSpatializer: *const ma_spatializer) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_output_channels(pSpatializer: *const ma_spatializer) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_attenuation_model( ++ pSpatializer: *mut ma_spatializer, ++ attenuationModel: ma_attenuation_model, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_attenuation_model( ++ pSpatializer: *const ma_spatializer, ++ ) -> ma_attenuation_model; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_positioning( ++ pSpatializer: *mut ma_spatializer, ++ positioning: ma_positioning, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_positioning(pSpatializer: *const ma_spatializer) -> ma_positioning; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_rolloff(pSpatializer: *mut ma_spatializer, rolloff: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_rolloff(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_min_gain(pSpatializer: *mut ma_spatializer, minGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_min_gain(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_max_gain(pSpatializer: *mut ma_spatializer, maxGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_max_gain(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_min_distance(pSpatializer: *mut ma_spatializer, minDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_min_distance(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_max_distance(pSpatializer: *mut ma_spatializer, maxDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_max_distance(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_cone( ++ pSpatializer: *mut ma_spatializer, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_cone( ++ pSpatializer: *const ma_spatializer, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_doppler_factor(pSpatializer: *mut ma_spatializer, dopplerFactor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_doppler_factor(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_directional_attenuation_factor( ++ pSpatializer: *mut ma_spatializer, ++ directionalAttenuationFactor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_directional_attenuation_factor( ++ pSpatializer: *const ma_spatializer, ++ ) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_position(pSpatializer: *mut ma_spatializer, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_position(pSpatializer: *const ma_spatializer) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_direction(pSpatializer: *mut ma_spatializer, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_direction(pSpatializer: *const ma_spatializer) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_velocity(pSpatializer: *mut ma_spatializer, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_velocity(pSpatializer: *const ma_spatializer) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_relative_position_and_direction( ++ pSpatializer: *const ma_spatializer, ++ pListener: *const ma_spatializer_listener, ++ pRelativePos: *mut ma_vec3f, ++ pRelativeDir: *mut ma_vec3f, ++ ); ++} ++#[doc = "Resampling"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_linear_resampler_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub lpfOrder: ma_uint32, ++ pub lpfNyquistFactor: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_linear_resampler_config"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_linear_resampler_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_linear_resampler_config::format"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, format) - 0usize]; ++ ["Offset of field: ma_linear_resampler_config::channels"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, channels) - 4usize]; ++ ["Offset of field: ma_linear_resampler_config::sampleRateIn"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, sampleRateIn) - 8usize]; ++ ["Offset of field: ma_linear_resampler_config::sampleRateOut"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, sampleRateOut) - 12usize]; ++ ["Offset of field: ma_linear_resampler_config::lpfOrder"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, lpfOrder) - 16usize]; ++ ["Offset of field: ma_linear_resampler_config::lpfNyquistFactor"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, lpfNyquistFactor) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_linear_resampler_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_linear_resampler_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_linear_resampler { ++ pub config: ma_linear_resampler_config, ++ pub inAdvanceInt: ma_uint32, ++ pub inAdvanceFrac: ma_uint32, ++ pub inTimeInt: ma_uint32, ++ pub inTimeFrac: ma_uint32, ++ pub x0: ma_linear_resampler__bindgen_ty_1, ++ pub x1: ma_linear_resampler__bindgen_ty_2, ++ pub lpf: ma_lpf, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_linear_resampler__bindgen_ty_1 { ++ pub f32_: *mut f32, ++ pub s16: *mut ma_int16, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_linear_resampler__bindgen_ty_1"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_linear_resampler__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_linear_resampler__bindgen_ty_1::f32_"] ++ [::core::mem::offset_of!(ma_linear_resampler__bindgen_ty_1, f32_) - 0usize]; ++ ["Offset of field: ma_linear_resampler__bindgen_ty_1::s16"] ++ [::core::mem::offset_of!(ma_linear_resampler__bindgen_ty_1, s16) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_linear_resampler__bindgen_ty_2 { ++ pub f32_: *mut f32, ++ pub s16: *mut ma_int16, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_linear_resampler__bindgen_ty_2"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_linear_resampler__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_linear_resampler__bindgen_ty_2::f32_"] ++ [::core::mem::offset_of!(ma_linear_resampler__bindgen_ty_2, f32_) - 0usize]; ++ ["Offset of field: ma_linear_resampler__bindgen_ty_2::s16"] ++ [::core::mem::offset_of!(ma_linear_resampler__bindgen_ty_2, s16) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_linear_resampler"][::core::mem::size_of::() - 136usize]; ++ ["Alignment of ma_linear_resampler"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_linear_resampler::config"] ++ [::core::mem::offset_of!(ma_linear_resampler, config) - 0usize]; ++ ["Offset of field: ma_linear_resampler::inAdvanceInt"] ++ [::core::mem::offset_of!(ma_linear_resampler, inAdvanceInt) - 32usize]; ++ ["Offset of field: ma_linear_resampler::inAdvanceFrac"] ++ [::core::mem::offset_of!(ma_linear_resampler, inAdvanceFrac) - 36usize]; ++ ["Offset of field: ma_linear_resampler::inTimeInt"] ++ [::core::mem::offset_of!(ma_linear_resampler, inTimeInt) - 40usize]; ++ ["Offset of field: ma_linear_resampler::inTimeFrac"] ++ [::core::mem::offset_of!(ma_linear_resampler, inTimeFrac) - 44usize]; ++ ["Offset of field: ma_linear_resampler::x0"] ++ [::core::mem::offset_of!(ma_linear_resampler, x0) - 48usize]; ++ ["Offset of field: ma_linear_resampler::x1"] ++ [::core::mem::offset_of!(ma_linear_resampler, x1) - 56usize]; ++ ["Offset of field: ma_linear_resampler::lpf"] ++ [::core::mem::offset_of!(ma_linear_resampler, lpf) - 64usize]; ++ ["Offset of field: ma_linear_resampler::_pHeap"] ++ [::core::mem::offset_of!(ma_linear_resampler, _pHeap) - 120usize]; ++ ["Offset of field: ma_linear_resampler::_ownsHeap"] ++ [::core::mem::offset_of!(ma_linear_resampler, _ownsHeap) - 128usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_heap_size( ++ pConfig: *const ma_linear_resampler_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_init_preallocated( ++ pConfig: *const ma_linear_resampler_config, ++ pHeap: *mut core::ffi::c_void, ++ pResampler: *mut ma_linear_resampler, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_init( ++ pConfig: *const ma_linear_resampler_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pResampler: *mut ma_linear_resampler, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_uninit( ++ pResampler: *mut ma_linear_resampler, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_process_pcm_frames( ++ pResampler: *mut ma_linear_resampler, ++ pFramesIn: *const core::ffi::c_void, ++ pFrameCountIn: *mut ma_uint64, ++ pFramesOut: *mut core::ffi::c_void, ++ pFrameCountOut: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_set_rate( ++ pResampler: *mut ma_linear_resampler, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_set_rate_ratio( ++ pResampler: *mut ma_linear_resampler, ++ ratioInOut: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_input_latency( ++ pResampler: *const ma_linear_resampler, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_output_latency( ++ pResampler: *const ma_linear_resampler, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_required_input_frame_count( ++ pResampler: *const ma_linear_resampler, ++ outputFrameCount: ma_uint64, ++ pInputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_expected_output_frame_count( ++ pResampler: *const ma_linear_resampler, ++ inputFrameCount: ma_uint64, ++ pOutputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_reset(pResampler: *mut ma_linear_resampler) -> ma_result; ++} ++pub type ma_resampling_backend = core::ffi::c_void; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resampling_backend_vtable { ++ pub onGetHeapSize: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_resampler_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result, ++ >, ++ pub onInit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_resampler_config, ++ pHeap: *mut core::ffi::c_void, ++ ppBackend: *mut *mut ma_resampling_backend, ++ ) -> ma_result, ++ >, ++ pub onUninit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_resampling_backend, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ), ++ >, ++ pub onProcess: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_resampling_backend, ++ pFramesIn: *const core::ffi::c_void, ++ pFrameCountIn: *mut ma_uint64, ++ pFramesOut: *mut core::ffi::c_void, ++ pFrameCountOut: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onSetRate: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_resampling_backend, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_result, ++ >, ++ pub onGetInputLatency: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *const ma_resampling_backend, ++ ) -> ma_uint64, ++ >, ++ pub onGetOutputLatency: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *const ma_resampling_backend, ++ ) -> ma_uint64, ++ >, ++ pub onGetRequiredInputFrameCount: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *const ma_resampling_backend, ++ outputFrameCount: ma_uint64, ++ pInputFrameCount: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onGetExpectedOutputFrameCount: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *const ma_resampling_backend, ++ inputFrameCount: ma_uint64, ++ pOutputFrameCount: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onReset: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_resampling_backend, ++ ) -> ma_result, ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampling_backend_vtable"] ++ [::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_resampling_backend_vtable"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetHeapSize"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onGetHeapSize) - 0usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onInit"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onInit) - 8usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onUninit"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onUninit) - 16usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onProcess"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onProcess) - 24usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onSetRate"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onSetRate) - 32usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetInputLatency"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onGetInputLatency) - 40usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetOutputLatency"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onGetOutputLatency) - 48usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetRequiredInputFrameCount"][::core::mem::offset_of!( ++ ma_resampling_backend_vtable, ++ onGetRequiredInputFrameCount ++ ) - 56usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetExpectedOutputFrameCount"][::core::mem::offset_of!( ++ ma_resampling_backend_vtable, ++ onGetExpectedOutputFrameCount ++ ) - 64usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onReset"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onReset) - 72usize]; ++}; ++pub const ma_resample_algorithm_ma_resample_algorithm_linear: ma_resample_algorithm = 0; ++pub const ma_resample_algorithm_ma_resample_algorithm_custom: ma_resample_algorithm = 1; ++pub type ma_resample_algorithm = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resampler_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub algorithm: ma_resample_algorithm, ++ pub pBackendVTable: *mut ma_resampling_backend_vtable, ++ pub pBackendUserData: *mut core::ffi::c_void, ++ pub linear: ma_resampler_config__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resampler_config__bindgen_ty_1 { ++ pub lpfOrder: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampler_config__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_resampler_config__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_resampler_config__bindgen_ty_1::lpfOrder"] ++ [::core::mem::offset_of!(ma_resampler_config__bindgen_ty_1, lpfOrder) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampler_config"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_resampler_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resampler_config::format"] ++ [::core::mem::offset_of!(ma_resampler_config, format) - 0usize]; ++ ["Offset of field: ma_resampler_config::channels"] ++ [::core::mem::offset_of!(ma_resampler_config, channels) - 4usize]; ++ ["Offset of field: ma_resampler_config::sampleRateIn"] ++ [::core::mem::offset_of!(ma_resampler_config, sampleRateIn) - 8usize]; ++ ["Offset of field: ma_resampler_config::sampleRateOut"] ++ [::core::mem::offset_of!(ma_resampler_config, sampleRateOut) - 12usize]; ++ ["Offset of field: ma_resampler_config::algorithm"] ++ [::core::mem::offset_of!(ma_resampler_config, algorithm) - 16usize]; ++ ["Offset of field: ma_resampler_config::pBackendVTable"] ++ [::core::mem::offset_of!(ma_resampler_config, pBackendVTable) - 24usize]; ++ ["Offset of field: ma_resampler_config::pBackendUserData"] ++ [::core::mem::offset_of!(ma_resampler_config, pBackendUserData) - 32usize]; ++ ["Offset of field: ma_resampler_config::linear"] ++ [::core::mem::offset_of!(ma_resampler_config, linear) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resampler_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ algorithm: ma_resample_algorithm, ++ ) -> ma_resampler_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resampler { ++ pub pBackend: *mut ma_resampling_backend, ++ pub pBackendVTable: *mut ma_resampling_backend_vtable, ++ pub pBackendUserData: *mut core::ffi::c_void, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub state: ma_resampler__bindgen_ty_1, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_resampler__bindgen_ty_1 { ++ pub linear: ma_linear_resampler, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampler__bindgen_ty_1"] ++ [::core::mem::size_of::() - 136usize]; ++ ["Alignment of ma_resampler__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resampler__bindgen_ty_1::linear"] ++ [::core::mem::offset_of!(ma_resampler__bindgen_ty_1, linear) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampler"][::core::mem::size_of::() - 192usize]; ++ ["Alignment of ma_resampler"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resampler::pBackend"] ++ [::core::mem::offset_of!(ma_resampler, pBackend) - 0usize]; ++ ["Offset of field: ma_resampler::pBackendVTable"] ++ [::core::mem::offset_of!(ma_resampler, pBackendVTable) - 8usize]; ++ ["Offset of field: ma_resampler::pBackendUserData"] ++ [::core::mem::offset_of!(ma_resampler, pBackendUserData) - 16usize]; ++ ["Offset of field: ma_resampler::format"] ++ [::core::mem::offset_of!(ma_resampler, format) - 24usize]; ++ ["Offset of field: ma_resampler::channels"] ++ [::core::mem::offset_of!(ma_resampler, channels) - 28usize]; ++ ["Offset of field: ma_resampler::sampleRateIn"] ++ [::core::mem::offset_of!(ma_resampler, sampleRateIn) - 32usize]; ++ ["Offset of field: ma_resampler::sampleRateOut"] ++ [::core::mem::offset_of!(ma_resampler, sampleRateOut) - 36usize]; ++ ["Offset of field: ma_resampler::state"] ++ [::core::mem::offset_of!(ma_resampler, state) - 40usize]; ++ ["Offset of field: ma_resampler::_pHeap"] ++ [::core::mem::offset_of!(ma_resampler, _pHeap) - 176usize]; ++ ["Offset of field: ma_resampler::_ownsHeap"] ++ [::core::mem::offset_of!(ma_resampler, _ownsHeap) - 184usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resampler_get_heap_size( ++ pConfig: *const ma_resampler_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_init_preallocated( ++ pConfig: *const ma_resampler_config, ++ pHeap: *mut core::ffi::c_void, ++ pResampler: *mut ma_resampler, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_init( ++ pConfig: *const ma_resampler_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pResampler: *mut ma_resampler, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_uninit( ++ pResampler: *mut ma_resampler, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_resampler_process_pcm_frames( ++ pResampler: *mut ma_resampler, ++ pFramesIn: *const core::ffi::c_void, ++ pFrameCountIn: *mut ma_uint64, ++ pFramesOut: *mut core::ffi::c_void, ++ pFrameCountOut: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_set_rate( ++ pResampler: *mut ma_resampler, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_set_rate_ratio(pResampler: *mut ma_resampler, ratio: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_get_input_latency(pResampler: *const ma_resampler) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_get_output_latency(pResampler: *const ma_resampler) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_get_required_input_frame_count( ++ pResampler: *const ma_resampler, ++ outputFrameCount: ma_uint64, ++ pInputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_get_expected_output_frame_count( ++ pResampler: *const ma_resampler, ++ inputFrameCount: ma_uint64, ++ pOutputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_reset(pResampler: *mut ma_resampler) -> ma_result; ++} ++pub const ma_channel_conversion_path_ma_channel_conversion_path_unknown: ++ ma_channel_conversion_path = 0; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_passthrough: ++ ma_channel_conversion_path = 1; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_mono_out: ++ ma_channel_conversion_path = 2; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_mono_in: ++ ma_channel_conversion_path = 3; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_shuffle: ++ ma_channel_conversion_path = 4; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_weights: ++ ma_channel_conversion_path = 5; ++#[doc = "Channel Conversion"] ++pub type ma_channel_conversion_path = core::ffi::c_uint; ++pub const ma_mono_expansion_mode_ma_mono_expansion_mode_duplicate: ma_mono_expansion_mode = 0; ++pub const ma_mono_expansion_mode_ma_mono_expansion_mode_average: ma_mono_expansion_mode = 1; ++pub const ma_mono_expansion_mode_ma_mono_expansion_mode_stereo_only: ma_mono_expansion_mode = 2; ++pub const ma_mono_expansion_mode_ma_mono_expansion_mode_default: ma_mono_expansion_mode = 0; ++pub type ma_mono_expansion_mode = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_channel_converter_config { ++ pub format: ma_format, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub pChannelMapIn: *const ma_channel, ++ pub pChannelMapOut: *const ma_channel, ++ pub mixingMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub ppWeights: *mut *mut f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_channel_converter_config"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_channel_converter_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_channel_converter_config::format"] ++ [::core::mem::offset_of!(ma_channel_converter_config, format) - 0usize]; ++ ["Offset of field: ma_channel_converter_config::channelsIn"] ++ [::core::mem::offset_of!(ma_channel_converter_config, channelsIn) - 4usize]; ++ ["Offset of field: ma_channel_converter_config::channelsOut"] ++ [::core::mem::offset_of!(ma_channel_converter_config, channelsOut) - 8usize]; ++ ["Offset of field: ma_channel_converter_config::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_channel_converter_config, pChannelMapIn) - 16usize]; ++ ["Offset of field: ma_channel_converter_config::pChannelMapOut"] ++ [::core::mem::offset_of!(ma_channel_converter_config, pChannelMapOut) - 24usize]; ++ ["Offset of field: ma_channel_converter_config::mixingMode"] ++ [::core::mem::offset_of!(ma_channel_converter_config, mixingMode) - 32usize]; ++ ["Offset of field: ma_channel_converter_config::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_channel_converter_config, ++ calculateLFEFromSpatialChannels ++ ) - 36usize]; ++ ["Offset of field: ma_channel_converter_config::ppWeights"] ++ [::core::mem::offset_of!(ma_channel_converter_config, ppWeights) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_channel_converter_config_init( ++ format: ma_format, ++ channelsIn: ma_uint32, ++ pChannelMapIn: *const ma_channel, ++ channelsOut: ma_uint32, ++ pChannelMapOut: *const ma_channel, ++ mixingMode: ma_channel_mix_mode, ++ ) -> ma_channel_converter_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_channel_converter { ++ pub format: ma_format, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub mixingMode: ma_channel_mix_mode, ++ pub conversionPath: ma_channel_conversion_path, ++ pub pChannelMapIn: *mut ma_channel, ++ pub pChannelMapOut: *mut ma_channel, ++ pub pShuffleTable: *mut ma_uint8, ++ pub weights: ma_channel_converter__bindgen_ty_1, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_channel_converter__bindgen_ty_1 { ++ pub f32_: *mut *mut f32, ++ pub s16: *mut *mut ma_int32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_channel_converter__bindgen_ty_1"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_channel_converter__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_channel_converter__bindgen_ty_1::f32_"] ++ [::core::mem::offset_of!(ma_channel_converter__bindgen_ty_1, f32_) - 0usize]; ++ ["Offset of field: ma_channel_converter__bindgen_ty_1::s16"] ++ [::core::mem::offset_of!(ma_channel_converter__bindgen_ty_1, s16) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_channel_converter"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_channel_converter"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_channel_converter::format"] ++ [::core::mem::offset_of!(ma_channel_converter, format) - 0usize]; ++ ["Offset of field: ma_channel_converter::channelsIn"] ++ [::core::mem::offset_of!(ma_channel_converter, channelsIn) - 4usize]; ++ ["Offset of field: ma_channel_converter::channelsOut"] ++ [::core::mem::offset_of!(ma_channel_converter, channelsOut) - 8usize]; ++ ["Offset of field: ma_channel_converter::mixingMode"] ++ [::core::mem::offset_of!(ma_channel_converter, mixingMode) - 12usize]; ++ ["Offset of field: ma_channel_converter::conversionPath"] ++ [::core::mem::offset_of!(ma_channel_converter, conversionPath) - 16usize]; ++ ["Offset of field: ma_channel_converter::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_channel_converter, pChannelMapIn) - 24usize]; ++ ["Offset of field: ma_channel_converter::pChannelMapOut"] ++ [::core::mem::offset_of!(ma_channel_converter, pChannelMapOut) - 32usize]; ++ ["Offset of field: ma_channel_converter::pShuffleTable"] ++ [::core::mem::offset_of!(ma_channel_converter, pShuffleTable) - 40usize]; ++ ["Offset of field: ma_channel_converter::weights"] ++ [::core::mem::offset_of!(ma_channel_converter, weights) - 48usize]; ++ ["Offset of field: ma_channel_converter::_pHeap"] ++ [::core::mem::offset_of!(ma_channel_converter, _pHeap) - 56usize]; ++ ["Offset of field: ma_channel_converter::_ownsHeap"] ++ [::core::mem::offset_of!(ma_channel_converter, _ownsHeap) - 64usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_channel_converter_get_heap_size( ++ pConfig: *const ma_channel_converter_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_init_preallocated( ++ pConfig: *const ma_channel_converter_config, ++ pHeap: *mut core::ffi::c_void, ++ pConverter: *mut ma_channel_converter, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_init( ++ pConfig: *const ma_channel_converter_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pConverter: *mut ma_channel_converter, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_uninit( ++ pConverter: *mut ma_channel_converter, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_process_pcm_frames( ++ pConverter: *mut ma_channel_converter, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_get_input_channel_map( ++ pConverter: *const ma_channel_converter, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_get_output_channel_map( ++ pConverter: *const ma_channel_converter, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++#[doc = "Data Conversion"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_converter_config { ++ pub formatIn: ma_format, ++ pub formatOut: ma_format, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub pChannelMapIn: *mut ma_channel, ++ pub pChannelMapOut: *mut ma_channel, ++ pub ditherMode: ma_dither_mode, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub ppChannelWeights: *mut *mut f32, ++ pub allowDynamicSampleRate: ma_bool32, ++ pub resampling: ma_resampler_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_converter_config"] ++ [::core::mem::size_of::() - 120usize]; ++ ["Alignment of ma_data_converter_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_converter_config::formatIn"] ++ [::core::mem::offset_of!(ma_data_converter_config, formatIn) - 0usize]; ++ ["Offset of field: ma_data_converter_config::formatOut"] ++ [::core::mem::offset_of!(ma_data_converter_config, formatOut) - 4usize]; ++ ["Offset of field: ma_data_converter_config::channelsIn"] ++ [::core::mem::offset_of!(ma_data_converter_config, channelsIn) - 8usize]; ++ ["Offset of field: ma_data_converter_config::channelsOut"] ++ [::core::mem::offset_of!(ma_data_converter_config, channelsOut) - 12usize]; ++ ["Offset of field: ma_data_converter_config::sampleRateIn"] ++ [::core::mem::offset_of!(ma_data_converter_config, sampleRateIn) - 16usize]; ++ ["Offset of field: ma_data_converter_config::sampleRateOut"] ++ [::core::mem::offset_of!(ma_data_converter_config, sampleRateOut) - 20usize]; ++ ["Offset of field: ma_data_converter_config::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_data_converter_config, pChannelMapIn) - 24usize]; ++ ["Offset of field: ma_data_converter_config::pChannelMapOut"] ++ [::core::mem::offset_of!(ma_data_converter_config, pChannelMapOut) - 32usize]; ++ ["Offset of field: ma_data_converter_config::ditherMode"] ++ [::core::mem::offset_of!(ma_data_converter_config, ditherMode) - 40usize]; ++ ["Offset of field: ma_data_converter_config::channelMixMode"] ++ [::core::mem::offset_of!(ma_data_converter_config, channelMixMode) - 44usize]; ++ ["Offset of field: ma_data_converter_config::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_data_converter_config, ++ calculateLFEFromSpatialChannels ++ ) - 48usize]; ++ ["Offset of field: ma_data_converter_config::ppChannelWeights"] ++ [::core::mem::offset_of!(ma_data_converter_config, ppChannelWeights) - 56usize]; ++ ["Offset of field: ma_data_converter_config::allowDynamicSampleRate"] ++ [::core::mem::offset_of!(ma_data_converter_config, allowDynamicSampleRate) - 64usize]; ++ ["Offset of field: ma_data_converter_config::resampling"] ++ [::core::mem::offset_of!(ma_data_converter_config, resampling) - 72usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_converter_config_init_default() -> ma_data_converter_config; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_config_init( ++ formatIn: ma_format, ++ formatOut: ma_format, ++ channelsIn: ma_uint32, ++ channelsOut: ma_uint32, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_data_converter_config; ++} ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_passthrough: ++ ma_data_converter_execution_path = 0; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_format_only: ++ ma_data_converter_execution_path = 1; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_channels_only: ++ ma_data_converter_execution_path = 2; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_resample_only: ++ ma_data_converter_execution_path = 3; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_resample_first: ++ ma_data_converter_execution_path = 4; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_channels_first: ++ ma_data_converter_execution_path = 5; ++pub type ma_data_converter_execution_path = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_data_converter { ++ pub formatIn: ma_format, ++ pub formatOut: ma_format, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub ditherMode: ma_dither_mode, ++ pub executionPath: ma_data_converter_execution_path, ++ pub channelConverter: ma_channel_converter, ++ pub resampler: ma_resampler, ++ pub hasPreFormatConversion: ma_bool8, ++ pub hasPostFormatConversion: ma_bool8, ++ pub hasChannelConverter: ma_bool8, ++ pub hasResampler: ma_bool8, ++ pub isPassthrough: ma_bool8, ++ pub _ownsHeap: ma_bool8, ++ pub _pHeap: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_converter"][::core::mem::size_of::() - 312usize]; ++ ["Alignment of ma_data_converter"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_converter::formatIn"] ++ [::core::mem::offset_of!(ma_data_converter, formatIn) - 0usize]; ++ ["Offset of field: ma_data_converter::formatOut"] ++ [::core::mem::offset_of!(ma_data_converter, formatOut) - 4usize]; ++ ["Offset of field: ma_data_converter::channelsIn"] ++ [::core::mem::offset_of!(ma_data_converter, channelsIn) - 8usize]; ++ ["Offset of field: ma_data_converter::channelsOut"] ++ [::core::mem::offset_of!(ma_data_converter, channelsOut) - 12usize]; ++ ["Offset of field: ma_data_converter::sampleRateIn"] ++ [::core::mem::offset_of!(ma_data_converter, sampleRateIn) - 16usize]; ++ ["Offset of field: ma_data_converter::sampleRateOut"] ++ [::core::mem::offset_of!(ma_data_converter, sampleRateOut) - 20usize]; ++ ["Offset of field: ma_data_converter::ditherMode"] ++ [::core::mem::offset_of!(ma_data_converter, ditherMode) - 24usize]; ++ ["Offset of field: ma_data_converter::executionPath"] ++ [::core::mem::offset_of!(ma_data_converter, executionPath) - 28usize]; ++ ["Offset of field: ma_data_converter::channelConverter"] ++ [::core::mem::offset_of!(ma_data_converter, channelConverter) - 32usize]; ++ ["Offset of field: ma_data_converter::resampler"] ++ [::core::mem::offset_of!(ma_data_converter, resampler) - 104usize]; ++ ["Offset of field: ma_data_converter::hasPreFormatConversion"] ++ [::core::mem::offset_of!(ma_data_converter, hasPreFormatConversion) - 296usize]; ++ ["Offset of field: ma_data_converter::hasPostFormatConversion"] ++ [::core::mem::offset_of!(ma_data_converter, hasPostFormatConversion) - 297usize]; ++ ["Offset of field: ma_data_converter::hasChannelConverter"] ++ [::core::mem::offset_of!(ma_data_converter, hasChannelConverter) - 298usize]; ++ ["Offset of field: ma_data_converter::hasResampler"] ++ [::core::mem::offset_of!(ma_data_converter, hasResampler) - 299usize]; ++ ["Offset of field: ma_data_converter::isPassthrough"] ++ [::core::mem::offset_of!(ma_data_converter, isPassthrough) - 300usize]; ++ ["Offset of field: ma_data_converter::_ownsHeap"] ++ [::core::mem::offset_of!(ma_data_converter, _ownsHeap) - 301usize]; ++ ["Offset of field: ma_data_converter::_pHeap"] ++ [::core::mem::offset_of!(ma_data_converter, _pHeap) - 304usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_converter_get_heap_size( ++ pConfig: *const ma_data_converter_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_init_preallocated( ++ pConfig: *const ma_data_converter_config, ++ pHeap: *mut core::ffi::c_void, ++ pConverter: *mut ma_data_converter, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_init( ++ pConfig: *const ma_data_converter_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pConverter: *mut ma_data_converter, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_uninit( ++ pConverter: *mut ma_data_converter, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_process_pcm_frames( ++ pConverter: *mut ma_data_converter, ++ pFramesIn: *const core::ffi::c_void, ++ pFrameCountIn: *mut ma_uint64, ++ pFramesOut: *mut core::ffi::c_void, ++ pFrameCountOut: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_set_rate( ++ pConverter: *mut ma_data_converter, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_set_rate_ratio( ++ pConverter: *mut ma_data_converter, ++ ratioInOut: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_input_latency(pConverter: *const ma_data_converter) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_output_latency(pConverter: *const ma_data_converter) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_required_input_frame_count( ++ pConverter: *const ma_data_converter, ++ outputFrameCount: ma_uint64, ++ pInputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_expected_output_frame_count( ++ pConverter: *const ma_data_converter, ++ inputFrameCount: ma_uint64, ++ pOutputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_input_channel_map( ++ pConverter: *const ma_data_converter, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_output_channel_map( ++ pConverter: *const ma_data_converter, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_reset(pConverter: *mut ma_data_converter) -> ma_result; ++} ++unsafe extern "C" { ++ #[doc = "Format Conversion"] ++ pub fn ma_pcm_u8_to_s16( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_u8_to_s24( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_u8_to_s32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_u8_to_f32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s16_to_u8( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s16_to_s24( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s16_to_s32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s16_to_f32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s24_to_u8( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s24_to_s16( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s24_to_s32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s24_to_f32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s32_to_u8( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s32_to_s16( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s32_to_s24( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s32_to_f32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_f32_to_u8( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_f32_to_s16( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_f32_to_s24( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_f32_to_s32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_convert( ++ pOut: *mut core::ffi::c_void, ++ formatOut: ma_format, ++ pIn: *const core::ffi::c_void, ++ formatIn: ma_format, ++ sampleCount: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_convert_pcm_frames_format( ++ pOut: *mut core::ffi::c_void, ++ formatOut: ma_format, ++ pIn: *const core::ffi::c_void, ++ formatIn: ma_format, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_deinterleave_pcm_frames( ++ format: ma_format, ++ channels: ma_uint32, ++ frameCount: ma_uint64, ++ pInterleavedPCMFrames: *const core::ffi::c_void, ++ ppDeinterleavedPCMFrames: *mut *mut core::ffi::c_void, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_interleave_pcm_frames( ++ format: ma_format, ++ channels: ma_uint32, ++ frameCount: ma_uint64, ++ ppDeinterleavedPCMFrames: *mut *const core::ffi::c_void, ++ pInterleavedPCMFrames: *mut core::ffi::c_void, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_get_channel( ++ pChannelMap: *const ma_channel, ++ channelCount: ma_uint32, ++ channelIndex: ma_uint32, ++ ) -> ma_channel; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_init_blank(pChannelMap: *mut ma_channel, channels: ma_uint32); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_init_standard( ++ standardChannelMap: ma_standard_channel_map, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_copy(pOut: *mut ma_channel, pIn: *const ma_channel, channels: ma_uint32); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_copy_or_default( ++ pOut: *mut ma_channel, ++ channelMapCapOut: usize, ++ pIn: *const ma_channel, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_is_valid( ++ pChannelMap: *const ma_channel, ++ channels: ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_is_equal( ++ pChannelMapA: *const ma_channel, ++ pChannelMapB: *const ma_channel, ++ channels: ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_is_blank( ++ pChannelMap: *const ma_channel, ++ channels: ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_contains_channel_position( ++ channels: ma_uint32, ++ pChannelMap: *const ma_channel, ++ channelPosition: ma_channel, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_find_channel_position( ++ channels: ma_uint32, ++ pChannelMap: *const ma_channel, ++ channelPosition: ma_channel, ++ pChannelIndex: *mut ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_to_string( ++ pChannelMap: *const ma_channel, ++ channels: ma_uint32, ++ pBufferOut: *mut core::ffi::c_char, ++ bufferCap: usize, ++ ) -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_channel_position_to_string(channel: ma_channel) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ #[doc = "Conversion Helpers"] ++ pub fn ma_convert_frames( ++ pOut: *mut core::ffi::c_void, ++ frameCountOut: ma_uint64, ++ formatOut: ma_format, ++ channelsOut: ma_uint32, ++ sampleRateOut: ma_uint32, ++ pIn: *const core::ffi::c_void, ++ frameCountIn: ma_uint64, ++ formatIn: ma_format, ++ channelsIn: ma_uint32, ++ sampleRateIn: ma_uint32, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_convert_frames_ex( ++ pOut: *mut core::ffi::c_void, ++ frameCountOut: ma_uint64, ++ pIn: *const core::ffi::c_void, ++ frameCountIn: ma_uint64, ++ pConfig: *const ma_data_converter_config, ++ ) -> ma_uint64; ++} ++#[doc = "Data Source"] ++pub type ma_data_source = core::ffi::c_void; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_vtable { ++ pub onRead: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDataSource: *mut ma_data_source, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onSeek: ::core::option::Option< ++ unsafe extern "C" fn(pDataSource: *mut ma_data_source, frameIndex: ma_uint64) -> ma_result, ++ >, ++ pub onGetDataFormat: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDataSource: *mut ma_data_source, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result, ++ >, ++ pub onGetCursor: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDataSource: *mut ma_data_source, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onGetLength: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDataSource: *mut ma_data_source, ++ pLength: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onSetLooping: ::core::option::Option< ++ unsafe extern "C" fn(pDataSource: *mut ma_data_source, isLooping: ma_bool32) -> ma_result, ++ >, ++ pub flags: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_vtable"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_data_source_vtable"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_vtable::onRead"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onRead) - 0usize]; ++ ["Offset of field: ma_data_source_vtable::onSeek"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onSeek) - 8usize]; ++ ["Offset of field: ma_data_source_vtable::onGetDataFormat"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onGetDataFormat) - 16usize]; ++ ["Offset of field: ma_data_source_vtable::onGetCursor"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onGetCursor) - 24usize]; ++ ["Offset of field: ma_data_source_vtable::onGetLength"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onGetLength) - 32usize]; ++ ["Offset of field: ma_data_source_vtable::onSetLooping"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onSetLooping) - 40usize]; ++ ["Offset of field: ma_data_source_vtable::flags"] ++ [::core::mem::offset_of!(ma_data_source_vtable, flags) - 48usize]; ++}; ++pub type ma_data_source_get_next_proc = ::core::option::Option< ++ unsafe extern "C" fn(pDataSource: *mut ma_data_source) -> *mut ma_data_source, ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_config { ++ pub vtable: *const ma_data_source_vtable, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_config"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_data_source_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_config::vtable"] ++ [::core::mem::offset_of!(ma_data_source_config, vtable) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_source_config_init() -> ma_data_source_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_base { ++ pub vtable: *const ma_data_source_vtable, ++ pub rangeBegInFrames: ma_uint64, ++ pub rangeEndInFrames: ma_uint64, ++ pub loopBegInFrames: ma_uint64, ++ pub loopEndInFrames: ma_uint64, ++ pub pCurrent: *mut ma_data_source, ++ pub pNext: *mut ma_data_source, ++ pub onGetNext: ma_data_source_get_next_proc, ++ pub isLooping: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_base"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_data_source_base"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_base::vtable"] ++ [::core::mem::offset_of!(ma_data_source_base, vtable) - 0usize]; ++ ["Offset of field: ma_data_source_base::rangeBegInFrames"] ++ [::core::mem::offset_of!(ma_data_source_base, rangeBegInFrames) - 8usize]; ++ ["Offset of field: ma_data_source_base::rangeEndInFrames"] ++ [::core::mem::offset_of!(ma_data_source_base, rangeEndInFrames) - 16usize]; ++ ["Offset of field: ma_data_source_base::loopBegInFrames"] ++ [::core::mem::offset_of!(ma_data_source_base, loopBegInFrames) - 24usize]; ++ ["Offset of field: ma_data_source_base::loopEndInFrames"] ++ [::core::mem::offset_of!(ma_data_source_base, loopEndInFrames) - 32usize]; ++ ["Offset of field: ma_data_source_base::pCurrent"] ++ [::core::mem::offset_of!(ma_data_source_base, pCurrent) - 40usize]; ++ ["Offset of field: ma_data_source_base::pNext"] ++ [::core::mem::offset_of!(ma_data_source_base, pNext) - 48usize]; ++ ["Offset of field: ma_data_source_base::onGetNext"] ++ [::core::mem::offset_of!(ma_data_source_base, onGetNext) - 56usize]; ++ ["Offset of field: ma_data_source_base::isLooping"] ++ [::core::mem::offset_of!(ma_data_source_base, isLooping) - 64usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_source_init( ++ pConfig: *const ma_data_source_config, ++ pDataSource: *mut ma_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_uninit(pDataSource: *mut ma_data_source); ++} ++unsafe extern "C" { ++ pub fn ma_data_source_read_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_seek_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ frameCount: ma_uint64, ++ pFramesSeeked: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_seek_to_pcm_frame( ++ pDataSource: *mut ma_data_source, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_seek_seconds( ++ pDataSource: *mut ma_data_source, ++ secondCount: f32, ++ pSecondsSeeked: *mut f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_seek_to_second( ++ pDataSource: *mut ma_data_source, ++ seekPointInSeconds: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_data_format( ++ pDataSource: *mut ma_data_source, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_cursor_in_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_length_in_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_cursor_in_seconds( ++ pDataSource: *mut ma_data_source, ++ pCursor: *mut f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_length_in_seconds( ++ pDataSource: *mut ma_data_source, ++ pLength: *mut f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_looping( ++ pDataSource: *mut ma_data_source, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_is_looping(pDataSource: *const ma_data_source) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_range_in_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ rangeBegInFrames: ma_uint64, ++ rangeEndInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_range_in_pcm_frames( ++ pDataSource: *const ma_data_source, ++ pRangeBegInFrames: *mut ma_uint64, ++ pRangeEndInFrames: *mut ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_loop_point_in_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ loopBegInFrames: ma_uint64, ++ loopEndInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_loop_point_in_pcm_frames( ++ pDataSource: *const ma_data_source, ++ pLoopBegInFrames: *mut ma_uint64, ++ pLoopEndInFrames: *mut ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_current( ++ pDataSource: *mut ma_data_source, ++ pCurrentDataSource: *mut ma_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_current(pDataSource: *const ma_data_source) -> *mut ma_data_source; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_next( ++ pDataSource: *mut ma_data_source, ++ pNextDataSource: *mut ma_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_next(pDataSource: *const ma_data_source) -> *mut ma_data_source; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_next_callback( ++ pDataSource: *mut ma_data_source, ++ onGetNext: ma_data_source_get_next_proc, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_next_callback( ++ pDataSource: *const ma_data_source, ++ ) -> ma_data_source_get_next_proc; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_audio_buffer_ref { ++ pub ds: ma_data_source_base, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cursor: ma_uint64, ++ pub sizeInFrames: ma_uint64, ++ pub pData: *const core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_audio_buffer_ref"][::core::mem::size_of::() - 112usize]; ++ ["Alignment of ma_audio_buffer_ref"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_audio_buffer_ref::ds"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, ds) - 0usize]; ++ ["Offset of field: ma_audio_buffer_ref::format"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, format) - 72usize]; ++ ["Offset of field: ma_audio_buffer_ref::channels"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, channels) - 76usize]; ++ ["Offset of field: ma_audio_buffer_ref::sampleRate"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, sampleRate) - 80usize]; ++ ["Offset of field: ma_audio_buffer_ref::cursor"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, cursor) - 88usize]; ++ ["Offset of field: ma_audio_buffer_ref::sizeInFrames"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, sizeInFrames) - 96usize]; ++ ["Offset of field: ma_audio_buffer_ref::pData"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, pData) - 104usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_init( ++ format: ma_format, ++ channels: ma_uint32, ++ pData: *const core::ffi::c_void, ++ sizeInFrames: ma_uint64, ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_uninit(pAudioBufferRef: *mut ma_audio_buffer_ref); ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_set_data( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ pData: *const core::ffi::c_void, ++ sizeInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_read_pcm_frames( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ loop_: ma_bool32, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_seek_to_pcm_frame( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_map( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ ppFramesOut: *mut *mut core::ffi::c_void, ++ pFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_unmap( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_at_end(pAudioBufferRef: *const ma_audio_buffer_ref) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_get_cursor_in_pcm_frames( ++ pAudioBufferRef: *const ma_audio_buffer_ref, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_get_length_in_pcm_frames( ++ pAudioBufferRef: *const ma_audio_buffer_ref, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_get_available_frames( ++ pAudioBufferRef: *const ma_audio_buffer_ref, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_audio_buffer_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub sizeInFrames: ma_uint64, ++ pub pData: *const core::ffi::c_void, ++ pub allocationCallbacks: ma_allocation_callbacks, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_audio_buffer_config"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_audio_buffer_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_audio_buffer_config::format"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, format) - 0usize]; ++ ["Offset of field: ma_audio_buffer_config::channels"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, channels) - 4usize]; ++ ["Offset of field: ma_audio_buffer_config::sampleRate"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_audio_buffer_config::sizeInFrames"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, sizeInFrames) - 16usize]; ++ ["Offset of field: ma_audio_buffer_config::pData"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, pData) - 24usize]; ++ ["Offset of field: ma_audio_buffer_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, allocationCallbacks) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_audio_buffer_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sizeInFrames: ma_uint64, ++ pData: *const core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_audio_buffer_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_audio_buffer { ++ pub ref_: ma_audio_buffer_ref, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub ownsData: ma_bool32, ++ pub _pExtraData: [ma_uint8; 1usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_audio_buffer"][::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_audio_buffer"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_audio_buffer::ref_"] ++ [::core::mem::offset_of!(ma_audio_buffer, ref_) - 0usize]; ++ ["Offset of field: ma_audio_buffer::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_audio_buffer, allocationCallbacks) - 112usize]; ++ ["Offset of field: ma_audio_buffer::ownsData"] ++ [::core::mem::offset_of!(ma_audio_buffer, ownsData) - 144usize]; ++ ["Offset of field: ma_audio_buffer::_pExtraData"] ++ [::core::mem::offset_of!(ma_audio_buffer, _pExtraData) - 148usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_audio_buffer_init( ++ pConfig: *const ma_audio_buffer_config, ++ pAudioBuffer: *mut ma_audio_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_init_copy( ++ pConfig: *const ma_audio_buffer_config, ++ pAudioBuffer: *mut ma_audio_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_alloc_and_init( ++ pConfig: *const ma_audio_buffer_config, ++ ppAudioBuffer: *mut *mut ma_audio_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_uninit(pAudioBuffer: *mut ma_audio_buffer); ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_uninit_and_free(pAudioBuffer: *mut ma_audio_buffer); ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_read_pcm_frames( ++ pAudioBuffer: *mut ma_audio_buffer, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ loop_: ma_bool32, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_seek_to_pcm_frame( ++ pAudioBuffer: *mut ma_audio_buffer, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_map( ++ pAudioBuffer: *mut ma_audio_buffer, ++ ppFramesOut: *mut *mut core::ffi::c_void, ++ pFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_unmap( ++ pAudioBuffer: *mut ma_audio_buffer, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_at_end(pAudioBuffer: *const ma_audio_buffer) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_get_cursor_in_pcm_frames( ++ pAudioBuffer: *const ma_audio_buffer, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_get_length_in_pcm_frames( ++ pAudioBuffer: *const ma_audio_buffer, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_get_available_frames( ++ pAudioBuffer: *const ma_audio_buffer, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_paged_audio_buffer_page { ++ pub pNext: *mut ma_paged_audio_buffer_page, ++ pub sizeInFrames: ma_uint64, ++ pub pAudioData: [ma_uint8; 1usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_paged_audio_buffer_page"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_paged_audio_buffer_page"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_page::pNext"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_page, pNext) - 0usize]; ++ ["Offset of field: ma_paged_audio_buffer_page::sizeInFrames"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_page, sizeInFrames) - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_page::pAudioData"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_page, pAudioData) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_paged_audio_buffer_data { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub head: ma_paged_audio_buffer_page, ++ pub pTail: *mut ma_paged_audio_buffer_page, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_paged_audio_buffer_data"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_paged_audio_buffer_data"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_data::format"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_data, format) - 0usize]; ++ ["Offset of field: ma_paged_audio_buffer_data::channels"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_data, channels) - 4usize]; ++ ["Offset of field: ma_paged_audio_buffer_data::head"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_data, head) - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_data::pTail"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_data, pTail) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_init( ++ format: ma_format, ++ channels: ma_uint32, ++ pData: *mut ma_paged_audio_buffer_data, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_uninit( ++ pData: *mut ma_paged_audio_buffer_data, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_get_head( ++ pData: *mut ma_paged_audio_buffer_data, ++ ) -> *mut ma_paged_audio_buffer_page; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_get_tail( ++ pData: *mut ma_paged_audio_buffer_data, ++ ) -> *mut ma_paged_audio_buffer_page; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_get_length_in_pcm_frames( ++ pData: *mut ma_paged_audio_buffer_data, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_allocate_page( ++ pData: *mut ma_paged_audio_buffer_data, ++ pageSizeInFrames: ma_uint64, ++ pInitialData: *const core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppPage: *mut *mut ma_paged_audio_buffer_page, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_free_page( ++ pData: *mut ma_paged_audio_buffer_data, ++ pPage: *mut ma_paged_audio_buffer_page, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_append_page( ++ pData: *mut ma_paged_audio_buffer_data, ++ pPage: *mut ma_paged_audio_buffer_page, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_allocate_and_append_page( ++ pData: *mut ma_paged_audio_buffer_data, ++ pageSizeInFrames: ma_uint32, ++ pInitialData: *const core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_paged_audio_buffer_config { ++ pub pData: *mut ma_paged_audio_buffer_data, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_paged_audio_buffer_config"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_paged_audio_buffer_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_config::pData"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_config, pData) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_config_init( ++ pData: *mut ma_paged_audio_buffer_data, ++ ) -> ma_paged_audio_buffer_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_paged_audio_buffer { ++ pub ds: ma_data_source_base, ++ pub pData: *mut ma_paged_audio_buffer_data, ++ pub pCurrent: *mut ma_paged_audio_buffer_page, ++ pub relativeCursor: ma_uint64, ++ pub absoluteCursor: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_paged_audio_buffer"][::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_paged_audio_buffer"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer::ds"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, ds) - 0usize]; ++ ["Offset of field: ma_paged_audio_buffer::pData"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, pData) - 72usize]; ++ ["Offset of field: ma_paged_audio_buffer::pCurrent"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, pCurrent) - 80usize]; ++ ["Offset of field: ma_paged_audio_buffer::relativeCursor"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, relativeCursor) - 88usize]; ++ ["Offset of field: ma_paged_audio_buffer::absoluteCursor"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, absoluteCursor) - 96usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_init( ++ pConfig: *const ma_paged_audio_buffer_config, ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_uninit(pPagedAudioBuffer: *mut ma_paged_audio_buffer); ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_read_pcm_frames( ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_seek_to_pcm_frame( ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_get_cursor_in_pcm_frames( ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_get_length_in_pcm_frames( ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++#[doc = "Ring Buffer"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_rb { ++ pub pBuffer: *mut core::ffi::c_void, ++ pub subbufferSizeInBytes: ma_uint32, ++ pub subbufferCount: ma_uint32, ++ pub subbufferStrideInBytes: ma_uint32, ++ pub encodedReadOffset: ma_uint32, ++ pub encodedWriteOffset: ma_uint32, ++ pub ownsBuffer: ma_bool8, ++ pub clearOnWriteAcquire: ma_bool8, ++ pub allocationCallbacks: ma_allocation_callbacks, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_rb"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_rb"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_rb::pBuffer"][::core::mem::offset_of!(ma_rb, pBuffer) - 0usize]; ++ ["Offset of field: ma_rb::subbufferSizeInBytes"] ++ [::core::mem::offset_of!(ma_rb, subbufferSizeInBytes) - 8usize]; ++ ["Offset of field: ma_rb::subbufferCount"] ++ [::core::mem::offset_of!(ma_rb, subbufferCount) - 12usize]; ++ ["Offset of field: ma_rb::subbufferStrideInBytes"] ++ [::core::mem::offset_of!(ma_rb, subbufferStrideInBytes) - 16usize]; ++ ["Offset of field: ma_rb::encodedReadOffset"] ++ [::core::mem::offset_of!(ma_rb, encodedReadOffset) - 20usize]; ++ ["Offset of field: ma_rb::encodedWriteOffset"] ++ [::core::mem::offset_of!(ma_rb, encodedWriteOffset) - 24usize]; ++ ["Offset of field: ma_rb::ownsBuffer"][::core::mem::offset_of!(ma_rb, ownsBuffer) - 28usize]; ++ ["Offset of field: ma_rb::clearOnWriteAcquire"] ++ [::core::mem::offset_of!(ma_rb, clearOnWriteAcquire) - 29usize]; ++ ["Offset of field: ma_rb::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_rb, allocationCallbacks) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_rb_init_ex( ++ subbufferSizeInBytes: usize, ++ subbufferCount: usize, ++ subbufferStrideInBytes: usize, ++ pOptionalPreallocatedBuffer: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_init( ++ bufferSizeInBytes: usize, ++ pOptionalPreallocatedBuffer: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_uninit(pRB: *mut ma_rb); ++} ++unsafe extern "C" { ++ pub fn ma_rb_reset(pRB: *mut ma_rb); ++} ++unsafe extern "C" { ++ pub fn ma_rb_acquire_read( ++ pRB: *mut ma_rb, ++ pSizeInBytes: *mut usize, ++ ppBufferOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_commit_read(pRB: *mut ma_rb, sizeInBytes: usize) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_acquire_write( ++ pRB: *mut ma_rb, ++ pSizeInBytes: *mut usize, ++ ppBufferOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_commit_write(pRB: *mut ma_rb, sizeInBytes: usize) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_seek_read(pRB: *mut ma_rb, offsetInBytes: usize) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_seek_write(pRB: *mut ma_rb, offsetInBytes: usize) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_pointer_distance(pRB: *mut ma_rb) -> ma_int32; ++} ++unsafe extern "C" { ++ pub fn ma_rb_available_read(pRB: *mut ma_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_rb_available_write(pRB: *mut ma_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_rb_get_subbuffer_size(pRB: *mut ma_rb) -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_rb_get_subbuffer_stride(pRB: *mut ma_rb) -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_rb_get_subbuffer_offset(pRB: *mut ma_rb, subbufferIndex: usize) -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_rb_get_subbuffer_ptr( ++ pRB: *mut ma_rb, ++ subbufferIndex: usize, ++ pBuffer: *mut core::ffi::c_void, ++ ) -> *mut core::ffi::c_void; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_pcm_rb { ++ pub ds: ma_data_source_base, ++ pub rb: ma_rb, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_pcm_rb"][::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_pcm_rb"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_pcm_rb::ds"][::core::mem::offset_of!(ma_pcm_rb, ds) - 0usize]; ++ ["Offset of field: ma_pcm_rb::rb"][::core::mem::offset_of!(ma_pcm_rb, rb) - 72usize]; ++ ["Offset of field: ma_pcm_rb::format"][::core::mem::offset_of!(ma_pcm_rb, format) - 136usize]; ++ ["Offset of field: ma_pcm_rb::channels"] ++ [::core::mem::offset_of!(ma_pcm_rb, channels) - 140usize]; ++ ["Offset of field: ma_pcm_rb::sampleRate"] ++ [::core::mem::offset_of!(ma_pcm_rb, sampleRate) - 144usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_pcm_rb_init_ex( ++ format: ma_format, ++ channels: ma_uint32, ++ subbufferSizeInFrames: ma_uint32, ++ subbufferCount: ma_uint32, ++ subbufferStrideInFrames: ma_uint32, ++ pOptionalPreallocatedBuffer: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_pcm_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_init( ++ format: ma_format, ++ channels: ma_uint32, ++ bufferSizeInFrames: ma_uint32, ++ pOptionalPreallocatedBuffer: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_pcm_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_uninit(pRB: *mut ma_pcm_rb); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_reset(pRB: *mut ma_pcm_rb); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_acquire_read( ++ pRB: *mut ma_pcm_rb, ++ pSizeInFrames: *mut ma_uint32, ++ ppBufferOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_commit_read(pRB: *mut ma_pcm_rb, sizeInFrames: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_acquire_write( ++ pRB: *mut ma_pcm_rb, ++ pSizeInFrames: *mut ma_uint32, ++ ppBufferOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_commit_write(pRB: *mut ma_pcm_rb, sizeInFrames: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_seek_read(pRB: *mut ma_pcm_rb, offsetInFrames: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_seek_write(pRB: *mut ma_pcm_rb, offsetInFrames: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_pointer_distance(pRB: *mut ma_pcm_rb) -> ma_int32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_available_read(pRB: *mut ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_available_write(pRB: *mut ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_subbuffer_size(pRB: *mut ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_subbuffer_stride(pRB: *mut ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_subbuffer_offset( ++ pRB: *mut ma_pcm_rb, ++ subbufferIndex: ma_uint32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_subbuffer_ptr( ++ pRB: *mut ma_pcm_rb, ++ subbufferIndex: ma_uint32, ++ pBuffer: *mut core::ffi::c_void, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_format(pRB: *const ma_pcm_rb) -> ma_format; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_channels(pRB: *const ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_sample_rate(pRB: *const ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_set_sample_rate(pRB: *mut ma_pcm_rb, sampleRate: ma_uint32); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_duplex_rb { ++ pub rb: ma_pcm_rb, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_duplex_rb"][::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_duplex_rb"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_duplex_rb::rb"][::core::mem::offset_of!(ma_duplex_rb, rb) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_duplex_rb_init( ++ captureFormat: ma_format, ++ captureChannels: ma_uint32, ++ sampleRate: ma_uint32, ++ captureInternalSampleRate: ma_uint32, ++ captureInternalPeriodSizeInFrames: ma_uint32, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_duplex_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_duplex_rb_uninit(pRB: *mut ma_duplex_rb) -> ma_result; ++} ++unsafe extern "C" { ++ #[doc = "Miscellaneous Helpers"] ++ pub fn ma_result_description(result: ma_result) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ma_malloc( ++ sz: usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_calloc( ++ sz: usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_realloc( ++ p: *mut core::ffi::c_void, ++ sz: usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_free(p: *mut core::ffi::c_void, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_aligned_malloc( ++ sz: usize, ++ alignment: usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_aligned_free( ++ p: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_get_format_name(format: ma_format) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ma_blend_f32( ++ pOut: *mut f32, ++ pInA: *mut f32, ++ pInB: *mut f32, ++ factor: f32, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_get_bytes_per_sample(format: ma_format) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_log_level_to_string(logLevel: ma_uint32) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ #[doc = "Synchronization"] ++ pub fn ma_spinlock_lock(pSpinlock: *mut ma_spinlock) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spinlock_lock_noyield(pSpinlock: *mut ma_spinlock) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spinlock_unlock(pSpinlock: *mut ma_spinlock) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_mutex_init(pMutex: *mut ma_mutex) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_mutex_uninit(pMutex: *mut ma_mutex); ++} ++unsafe extern "C" { ++ pub fn ma_mutex_lock(pMutex: *mut ma_mutex); ++} ++unsafe extern "C" { ++ pub fn ma_mutex_unlock(pMutex: *mut ma_mutex); ++} ++unsafe extern "C" { ++ pub fn ma_event_init(pEvent: *mut ma_event) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_event_uninit(pEvent: *mut ma_event); ++} ++unsafe extern "C" { ++ pub fn ma_event_wait(pEvent: *mut ma_event) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_event_signal(pEvent: *mut ma_event) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_semaphore_init( ++ initialValue: core::ffi::c_int, ++ pSemaphore: *mut ma_semaphore, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_semaphore_uninit(pSemaphore: *mut ma_semaphore); ++} ++unsafe extern "C" { ++ pub fn ma_semaphore_wait(pSemaphore: *mut ma_semaphore) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_semaphore_release(pSemaphore: *mut ma_semaphore) -> ma_result; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_fence { ++ pub e: ma_event, ++ pub counter: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_fence"][::core::mem::size_of::() - 112usize]; ++ ["Alignment of ma_fence"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_fence::e"][::core::mem::offset_of!(ma_fence, e) - 0usize]; ++ ["Offset of field: ma_fence::counter"][::core::mem::offset_of!(ma_fence, counter) - 104usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_fence_init(pFence: *mut ma_fence) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fence_uninit(pFence: *mut ma_fence); ++} ++unsafe extern "C" { ++ pub fn ma_fence_acquire(pFence: *mut ma_fence) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fence_release(pFence: *mut ma_fence) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fence_wait(pFence: *mut ma_fence) -> ma_result; ++} ++pub type ma_async_notification = core::ffi::c_void; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_async_notification_callbacks { ++ pub onSignal: ++ ::core::option::Option, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_async_notification_callbacks"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_async_notification_callbacks"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_async_notification_callbacks::onSignal"] ++ [::core::mem::offset_of!(ma_async_notification_callbacks, onSignal) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_async_notification_signal(pNotification: *mut ma_async_notification) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_async_notification_poll { ++ pub cb: ma_async_notification_callbacks, ++ pub signalled: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_async_notification_poll"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_async_notification_poll"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_async_notification_poll::cb"] ++ [::core::mem::offset_of!(ma_async_notification_poll, cb) - 0usize]; ++ ["Offset of field: ma_async_notification_poll::signalled"] ++ [::core::mem::offset_of!(ma_async_notification_poll, signalled) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_async_notification_poll_init( ++ pNotificationPoll: *mut ma_async_notification_poll, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_async_notification_poll_is_signalled( ++ pNotificationPoll: *const ma_async_notification_poll, ++ ) -> ma_bool32; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_async_notification_event { ++ pub cb: ma_async_notification_callbacks, ++ pub e: ma_event, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_async_notification_event"] ++ [::core::mem::size_of::() - 112usize]; ++ ["Alignment of ma_async_notification_event"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_async_notification_event::cb"] ++ [::core::mem::offset_of!(ma_async_notification_event, cb) - 0usize]; ++ ["Offset of field: ma_async_notification_event::e"] ++ [::core::mem::offset_of!(ma_async_notification_event, e) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_async_notification_event_init( ++ pNotificationEvent: *mut ma_async_notification_event, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_async_notification_event_uninit( ++ pNotificationEvent: *mut ma_async_notification_event, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_async_notification_event_wait( ++ pNotificationEvent: *mut ma_async_notification_event, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_async_notification_event_signal( ++ pNotificationEvent: *mut ma_async_notification_event, ++ ) -> ma_result; ++} ++#[doc = "Job Queue"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_slot_allocator_config { ++ pub capacity: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_slot_allocator_config"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_slot_allocator_config"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_slot_allocator_config::capacity"] ++ [::core::mem::offset_of!(ma_slot_allocator_config, capacity) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_slot_allocator_config_init(capacity: ma_uint32) -> ma_slot_allocator_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_slot_allocator_group { ++ pub bitfield: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_slot_allocator_group"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_slot_allocator_group"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_slot_allocator_group::bitfield"] ++ [::core::mem::offset_of!(ma_slot_allocator_group, bitfield) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_slot_allocator { ++ pub pGroups: *mut ma_slot_allocator_group, ++ pub pSlots: *mut ma_uint32, ++ pub count: ma_uint32, ++ pub capacity: ma_uint32, ++ pub _ownsHeap: ma_bool32, ++ pub _pHeap: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_slot_allocator"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_slot_allocator"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_slot_allocator::pGroups"] ++ [::core::mem::offset_of!(ma_slot_allocator, pGroups) - 0usize]; ++ ["Offset of field: ma_slot_allocator::pSlots"] ++ [::core::mem::offset_of!(ma_slot_allocator, pSlots) - 8usize]; ++ ["Offset of field: ma_slot_allocator::count"] ++ [::core::mem::offset_of!(ma_slot_allocator, count) - 16usize]; ++ ["Offset of field: ma_slot_allocator::capacity"] ++ [::core::mem::offset_of!(ma_slot_allocator, capacity) - 20usize]; ++ ["Offset of field: ma_slot_allocator::_ownsHeap"] ++ [::core::mem::offset_of!(ma_slot_allocator, _ownsHeap) - 24usize]; ++ ["Offset of field: ma_slot_allocator::_pHeap"] ++ [::core::mem::offset_of!(ma_slot_allocator, _pHeap) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_slot_allocator_get_heap_size( ++ pConfig: *const ma_slot_allocator_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_init_preallocated( ++ pConfig: *const ma_slot_allocator_config, ++ pHeap: *mut core::ffi::c_void, ++ pAllocator: *mut ma_slot_allocator, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_init( ++ pConfig: *const ma_slot_allocator_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pAllocator: *mut ma_slot_allocator, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_uninit( ++ pAllocator: *mut ma_slot_allocator, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_alloc( ++ pAllocator: *mut ma_slot_allocator, ++ pSlot: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_free(pAllocator: *mut ma_slot_allocator, slot: ma_uint64) ++ -> ma_result; ++} ++pub type ma_job_proc = ::core::option::Option ma_result>; ++pub const ma_job_type_MA_JOB_TYPE_QUIT: ma_job_type = 0; ++pub const ma_job_type_MA_JOB_TYPE_CUSTOM: ma_job_type = 1; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER_NODE: ma_job_type = 2; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER_NODE: ma_job_type = 3; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE: ma_job_type = 4; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER: ma_job_type = 5; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER: ma_job_type = 6; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_STREAM: ma_job_type = 7; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_STREAM: ma_job_type = 8; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_STREAM: ma_job_type = 9; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_SEEK_DATA_STREAM: ma_job_type = 10; ++pub const ma_job_type_MA_JOB_TYPE_DEVICE_AAUDIO_REROUTE: ma_job_type = 11; ++pub const ma_job_type_MA_JOB_TYPE_COUNT: ma_job_type = 12; ++pub type ma_job_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_job { ++ pub toc: ma_job__bindgen_ty_1, ++ pub next: ma_uint64, ++ pub order: ma_uint32, ++ pub data: ma_job__bindgen_ty_2, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_1 { ++ pub breakup: ma_job__bindgen_ty_1__bindgen_ty_1, ++ pub allocation: ma_uint64, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_1__bindgen_ty_1 { ++ pub code: ma_uint16, ++ pub slot: ma_uint16, ++ pub refcount: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_job__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_job__bindgen_ty_1__bindgen_ty_1::code"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1__bindgen_ty_1, code) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_1__bindgen_ty_1::slot"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1__bindgen_ty_1, slot) - 2usize]; ++ ["Offset of field: ma_job__bindgen_ty_1__bindgen_ty_1::refcount"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1__bindgen_ty_1, refcount) - 4usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_1"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_job__bindgen_ty_1"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_1::breakup"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1, breakup) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_1::allocation"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1, allocation) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_2 { ++ pub custom: ma_job__bindgen_ty_2__bindgen_ty_1, ++ pub resourceManager: ma_job__bindgen_ty_2__bindgen_ty_2, ++ pub device: ma_job__bindgen_ty_2__bindgen_ty_3, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_1 { ++ pub proc_: ma_job_proc, ++ pub data0: ma_uintptr, ++ pub data1: ma_uintptr, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_1::proc_"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_1, proc_) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_1::data0"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_1, data0) - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_1::data1"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_1, data1) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_2__bindgen_ty_2 { ++ pub loadDataBufferNode: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pub freeDataBufferNode: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pub pageDataBufferNode: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pub loadDataBuffer: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pub freeDataBuffer: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5, ++ pub loadDataStream: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pub freeDataStream: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7, ++ pub pageDataStream: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8, ++ pub seekDataStream: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1 { ++ pub pResourceManager: *mut core::ffi::c_void, ++ pub pDataBufferNode: *mut core::ffi::c_void, ++ pub pFilePath: *mut core::ffi::c_char, ++ pub pFilePathW: *mut wchar_t, ++ pub flags: ma_uint32, ++ pub pInitNotification: *mut ma_async_notification, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pInitFence: *mut ma_fence, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pResourceManager"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pResourceManager ++ ) ++ - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pDataBufferNode"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pDataBufferNode ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pFilePath"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pFilePath ++ ) - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pFilePathW"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pFilePathW ++ ) - 24usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::flags"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ flags ++ ) - 32usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pInitNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pInitNotification ++ ) ++ - 40usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pDoneNotification ++ ) ++ - 48usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pInitFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pInitFence ++ ) - 56usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pDoneFence ++ ) - 64usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2 { ++ pub pResourceManager: *mut core::ffi::c_void, ++ pub pDataBufferNode: *mut core::ffi::c_void, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2::pResourceManager"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pResourceManager ++ ) ++ - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2::pDataBufferNode"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pDataBufferNode ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pDoneNotification ++ ) ++ - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pDoneFence ++ ) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3 { ++ pub pResourceManager: *mut core::ffi::c_void, ++ pub pDataBufferNode: *mut core::ffi::c_void, ++ pub pDecoder: *mut core::ffi::c_void, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pResourceManager"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pResourceManager ++ ) ++ - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pDataBufferNode"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pDataBufferNode ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pDecoder"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pDecoder ++ ) - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pDoneNotification ++ ) ++ - 24usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pDoneFence ++ ) - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4 { ++ pub pDataBuffer: *mut core::ffi::c_void, ++ pub pInitNotification: *mut ma_async_notification, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pInitFence: *mut ma_fence, ++ pub pDoneFence: *mut ma_fence, ++ pub rangeBegInPCMFrames: ma_uint64, ++ pub rangeEndInPCMFrames: ma_uint64, ++ pub loopPointBegInPCMFrames: ma_uint64, ++ pub loopPointEndInPCMFrames: ma_uint64, ++ pub isLooping: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4"] ++ [::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pDataBuffer"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pDataBuffer ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pInitNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pInitNotification ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pDoneNotification ++ ) ++ - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pInitFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pInitFence ++ ) - 24usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pDoneFence ++ ) - 32usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::rangeBegInPCMFrames"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ rangeBegInPCMFrames ++ ) ++ - 40usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::rangeEndInPCMFrames"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ rangeEndInPCMFrames ++ ) ++ - 48usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::loopPointBegInPCMFrames"] ++ [::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ loopPointBegInPCMFrames ++ ) - 56usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::loopPointEndInPCMFrames"] ++ [::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ loopPointEndInPCMFrames ++ ) - 64usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::isLooping"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ isLooping ++ ) - 72usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5 { ++ pub pDataBuffer: *mut core::ffi::c_void, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5::pDataBuffer"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5, ++ pDataBuffer ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5, ++ pDoneNotification ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5, ++ pDoneFence ++ ) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6 { ++ pub pDataStream: *mut core::ffi::c_void, ++ pub pFilePath: *mut core::ffi::c_char, ++ pub pFilePathW: *mut wchar_t, ++ pub initialSeekPoint: ma_uint64, ++ pub pInitNotification: *mut ma_async_notification, ++ pub pInitFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pDataStream"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pDataStream ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pFilePath"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pFilePath ++ ) - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pFilePathW"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pFilePathW ++ ) - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::initialSeekPoint"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ initialSeekPoint ++ ) ++ - 24usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pInitNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pInitNotification ++ ) ++ - 32usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pInitFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pInitFence ++ ) - 40usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7 { ++ pub pDataStream: *mut core::ffi::c_void, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7::pDataStream"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7, ++ pDataStream ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7, ++ pDoneNotification ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7, ++ pDoneFence ++ ) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8 { ++ pub pDataStream: *mut core::ffi::c_void, ++ pub pageIndex: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8::pDataStream"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8, ++ pDataStream ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8::pageIndex"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8, ++ pageIndex ++ ) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9 { ++ pub pDataStream: *mut core::ffi::c_void, ++ pub frameIndex: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9::pDataStream"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9, ++ pDataStream ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9::frameIndex"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9, ++ frameIndex ++ ) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2"] ++ [::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::loadDataBufferNode"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, loadDataBufferNode) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::freeDataBufferNode"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, freeDataBufferNode) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::pageDataBufferNode"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, pageDataBufferNode) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::loadDataBuffer"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, loadDataBuffer) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::freeDataBuffer"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, freeDataBuffer) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::loadDataStream"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, loadDataStream) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::freeDataStream"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, freeDataStream) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::pageDataStream"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, pageDataStream) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::seekDataStream"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, seekDataStream) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_2__bindgen_ty_3 { ++ pub aaudio: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1 { ++ pub reroute: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1 { ++ pub pDevice: *mut core::ffi::c_void, ++ pub deviceType: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1"][::core::mem::size_of::< ++ ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1, ++ >() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1::pDevice"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1, ++ pDevice ++ ) ++ - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1::deviceType"] ++ [::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1, ++ deviceType ++ ) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1::reroute"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1, ++ reroute ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_3"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_3::aaudio"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_3, aaudio) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_job__bindgen_ty_2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2::custom"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2, custom) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2::resourceManager"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2, resourceManager) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2::device"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2, device) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job"][::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_job"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job::toc"][::core::mem::offset_of!(ma_job, toc) - 0usize]; ++ ["Offset of field: ma_job::next"][::core::mem::offset_of!(ma_job, next) - 8usize]; ++ ["Offset of field: ma_job::order"][::core::mem::offset_of!(ma_job, order) - 16usize]; ++ ["Offset of field: ma_job::data"][::core::mem::offset_of!(ma_job, data) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_job_init(code: ma_uint16) -> ma_job; ++} ++unsafe extern "C" { ++ pub fn ma_job_process(pJob: *mut ma_job) -> ma_result; ++} ++pub const ma_job_queue_flags_MA_JOB_QUEUE_FLAG_NON_BLOCKING: ma_job_queue_flags = 1; ++pub type ma_job_queue_flags = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job_queue_config { ++ pub flags: ma_uint32, ++ pub capacity: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job_queue_config"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_job_queue_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_job_queue_config::flags"] ++ [::core::mem::offset_of!(ma_job_queue_config, flags) - 0usize]; ++ ["Offset of field: ma_job_queue_config::capacity"] ++ [::core::mem::offset_of!(ma_job_queue_config, capacity) - 4usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_job_queue_config_init(flags: ma_uint32, capacity: ma_uint32) -> ma_job_queue_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_job_queue { ++ pub flags: ma_uint32, ++ pub capacity: ma_uint32, ++ pub head: ma_uint64, ++ pub tail: ma_uint64, ++ pub sem: ma_semaphore, ++ pub allocator: ma_slot_allocator, ++ pub pJobs: *mut ma_job, ++ pub lock: ma_spinlock, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job_queue"][::core::mem::size_of::() - 200usize]; ++ ["Alignment of ma_job_queue"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job_queue::flags"][::core::mem::offset_of!(ma_job_queue, flags) - 0usize]; ++ ["Offset of field: ma_job_queue::capacity"] ++ [::core::mem::offset_of!(ma_job_queue, capacity) - 4usize]; ++ ["Offset of field: ma_job_queue::head"][::core::mem::offset_of!(ma_job_queue, head) - 8usize]; ++ ["Offset of field: ma_job_queue::tail"][::core::mem::offset_of!(ma_job_queue, tail) - 16usize]; ++ ["Offset of field: ma_job_queue::sem"][::core::mem::offset_of!(ma_job_queue, sem) - 24usize]; ++ ["Offset of field: ma_job_queue::allocator"] ++ [::core::mem::offset_of!(ma_job_queue, allocator) - 128usize]; ++ ["Offset of field: ma_job_queue::pJobs"] ++ [::core::mem::offset_of!(ma_job_queue, pJobs) - 168usize]; ++ ["Offset of field: ma_job_queue::lock"][::core::mem::offset_of!(ma_job_queue, lock) - 176usize]; ++ ["Offset of field: ma_job_queue::_pHeap"] ++ [::core::mem::offset_of!(ma_job_queue, _pHeap) - 184usize]; ++ ["Offset of field: ma_job_queue::_ownsHeap"] ++ [::core::mem::offset_of!(ma_job_queue, _ownsHeap) - 192usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_job_queue_get_heap_size( ++ pConfig: *const ma_job_queue_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_init_preallocated( ++ pConfig: *const ma_job_queue_config, ++ pHeap: *mut core::ffi::c_void, ++ pQueue: *mut ma_job_queue, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_init( ++ pConfig: *const ma_job_queue_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pQueue: *mut ma_job_queue, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_uninit( ++ pQueue: *mut ma_job_queue, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_post(pQueue: *mut ma_job_queue, pJob: *const ma_job) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_next(pQueue: *mut ma_job_queue, pJob: *mut ma_job) -> ma_result; ++} ++pub const ma_device_state_ma_device_state_uninitialized: ma_device_state = 0; ++pub const ma_device_state_ma_device_state_stopped: ma_device_state = 1; ++pub const ma_device_state_ma_device_state_started: ma_device_state = 2; ++pub const ma_device_state_ma_device_state_starting: ma_device_state = 3; ++pub const ma_device_state_ma_device_state_stopping: ma_device_state = 4; ++pub type ma_device_state = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_device_state { ++ pub value: ma_device_state, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_device_state"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_device_state"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_device_state::value"] ++ [::core::mem::offset_of!(ma_atomic_device_state, value) - 0usize]; ++}; ++pub const ma_backend_ma_backend_wasapi: ma_backend = 0; ++pub const ma_backend_ma_backend_dsound: ma_backend = 1; ++pub const ma_backend_ma_backend_winmm: ma_backend = 2; ++pub const ma_backend_ma_backend_coreaudio: ma_backend = 3; ++pub const ma_backend_ma_backend_sndio: ma_backend = 4; ++pub const ma_backend_ma_backend_audio4: ma_backend = 5; ++pub const ma_backend_ma_backend_oss: ma_backend = 6; ++pub const ma_backend_ma_backend_pulseaudio: ma_backend = 7; ++pub const ma_backend_ma_backend_alsa: ma_backend = 8; ++pub const ma_backend_ma_backend_jack: ma_backend = 9; ++pub const ma_backend_ma_backend_aaudio: ma_backend = 10; ++pub const ma_backend_ma_backend_opensl: ma_backend = 11; ++pub const ma_backend_ma_backend_webaudio: ma_backend = 12; ++pub const ma_backend_ma_backend_custom: ma_backend = 13; ++pub const ma_backend_ma_backend_null: ma_backend = 14; ++pub type ma_backend = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_job_thread_config { ++ pub noThread: ma_bool32, ++ pub jobQueueCapacity: ma_uint32, ++ pub jobQueueFlags: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_job_thread_config"] ++ [::core::mem::size_of::() - 12usize]; ++ ["Alignment of ma_device_job_thread_config"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_job_thread_config::noThread"] ++ [::core::mem::offset_of!(ma_device_job_thread_config, noThread) - 0usize]; ++ ["Offset of field: ma_device_job_thread_config::jobQueueCapacity"] ++ [::core::mem::offset_of!(ma_device_job_thread_config, jobQueueCapacity) - 4usize]; ++ ["Offset of field: ma_device_job_thread_config::jobQueueFlags"] ++ [::core::mem::offset_of!(ma_device_job_thread_config, jobQueueFlags) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_device_job_thread_config_init() -> ma_device_job_thread_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device_job_thread { ++ pub thread: ma_thread, ++ pub jobQueue: ma_job_queue, ++ pub _hasThread: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_job_thread"][::core::mem::size_of::() - 216usize]; ++ ["Alignment of ma_device_job_thread"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_job_thread::thread"] ++ [::core::mem::offset_of!(ma_device_job_thread, thread) - 0usize]; ++ ["Offset of field: ma_device_job_thread::jobQueue"] ++ [::core::mem::offset_of!(ma_device_job_thread, jobQueue) - 8usize]; ++ ["Offset of field: ma_device_job_thread::_hasThread"] ++ [::core::mem::offset_of!(ma_device_job_thread, _hasThread) - 208usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_device_job_thread_init( ++ pConfig: *const ma_device_job_thread_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pJobThread: *mut ma_device_job_thread, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_job_thread_uninit( ++ pJobThread: *mut ma_device_job_thread, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_device_job_thread_post( ++ pJobThread: *mut ma_device_job_thread, ++ pJob: *const ma_job, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_job_thread_next( ++ pJobThread: *mut ma_device_job_thread, ++ pJob: *mut ma_job, ++ ) -> ma_result; ++} ++pub const ma_device_notification_type_ma_device_notification_type_started: ++ ma_device_notification_type = 0; ++pub const ma_device_notification_type_ma_device_notification_type_stopped: ++ ma_device_notification_type = 1; ++pub const ma_device_notification_type_ma_device_notification_type_rerouted: ++ ma_device_notification_type = 2; ++pub const ma_device_notification_type_ma_device_notification_type_interruption_began: ++ ma_device_notification_type = 3; ++pub const ma_device_notification_type_ma_device_notification_type_interruption_ended: ++ ma_device_notification_type = 4; ++pub const ma_device_notification_type_ma_device_notification_type_unlocked: ++ ma_device_notification_type = 5; ++pub type ma_device_notification_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device_notification { ++ pub pDevice: *mut ma_device, ++ pub type_: ma_device_notification_type, ++ pub data: ma_device_notification__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_device_notification__bindgen_ty_1 { ++ pub started: ma_device_notification__bindgen_ty_1__bindgen_ty_1, ++ pub stopped: ma_device_notification__bindgen_ty_1__bindgen_ty_2, ++ pub rerouted: ma_device_notification__bindgen_ty_1__bindgen_ty_3, ++ pub interruption: ma_device_notification__bindgen_ty_1__bindgen_ty_4, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_notification__bindgen_ty_1__bindgen_ty_1 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1__bindgen_ty_1::_unused"][::core::mem::offset_of!( ++ ma_device_notification__bindgen_ty_1__bindgen_ty_1, ++ _unused ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_notification__bindgen_ty_1__bindgen_ty_2 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1__bindgen_ty_2::_unused"][::core::mem::offset_of!( ++ ma_device_notification__bindgen_ty_1__bindgen_ty_2, ++ _unused ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_notification__bindgen_ty_1__bindgen_ty_3 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1__bindgen_ty_3::_unused"][::core::mem::offset_of!( ++ ma_device_notification__bindgen_ty_1__bindgen_ty_3, ++ _unused ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_notification__bindgen_ty_1__bindgen_ty_4 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1__bindgen_ty_4"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1__bindgen_ty_4"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1__bindgen_ty_4::_unused"][::core::mem::offset_of!( ++ ma_device_notification__bindgen_ty_1__bindgen_ty_4, ++ _unused ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1::started"] ++ [::core::mem::offset_of!(ma_device_notification__bindgen_ty_1, started) - 0usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1::stopped"] ++ [::core::mem::offset_of!(ma_device_notification__bindgen_ty_1, stopped) - 0usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1::rerouted"] ++ [::core::mem::offset_of!(ma_device_notification__bindgen_ty_1, rerouted) - 0usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1::interruption"] ++ [::core::mem::offset_of!(ma_device_notification__bindgen_ty_1, interruption) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_device_notification"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_notification::pDevice"] ++ [::core::mem::offset_of!(ma_device_notification, pDevice) - 0usize]; ++ ["Offset of field: ma_device_notification::type_"] ++ [::core::mem::offset_of!(ma_device_notification, type_) - 8usize]; ++ ["Offset of field: ma_device_notification::data"] ++ [::core::mem::offset_of!(ma_device_notification, data) - 12usize]; ++}; ++pub type ma_device_notification_proc = ++ ::core::option::Option; ++pub type ma_device_data_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ pOutput: *mut core::ffi::c_void, ++ pInput: *const core::ffi::c_void, ++ frameCount: ma_uint32, ++ ), ++>; ++pub type ma_stop_proc = ::core::option::Option; ++pub const ma_device_type_ma_device_type_playback: ma_device_type = 1; ++pub const ma_device_type_ma_device_type_capture: ma_device_type = 2; ++pub const ma_device_type_ma_device_type_duplex: ma_device_type = 3; ++pub const ma_device_type_ma_device_type_loopback: ma_device_type = 4; ++pub type ma_device_type = core::ffi::c_uint; ++pub const ma_share_mode_ma_share_mode_shared: ma_share_mode = 0; ++pub const ma_share_mode_ma_share_mode_exclusive: ma_share_mode = 1; ++pub type ma_share_mode = core::ffi::c_uint; ++pub const ma_ios_session_category_ma_ios_session_category_default: ma_ios_session_category = 0; ++pub const ma_ios_session_category_ma_ios_session_category_none: ma_ios_session_category = 1; ++pub const ma_ios_session_category_ma_ios_session_category_ambient: ma_ios_session_category = 2; ++pub const ma_ios_session_category_ma_ios_session_category_solo_ambient: ma_ios_session_category = 3; ++pub const ma_ios_session_category_ma_ios_session_category_playback: ma_ios_session_category = 4; ++pub const ma_ios_session_category_ma_ios_session_category_record: ma_ios_session_category = 5; ++pub const ma_ios_session_category_ma_ios_session_category_play_and_record: ma_ios_session_category = ++ 6; ++pub const ma_ios_session_category_ma_ios_session_category_multi_route: ma_ios_session_category = 7; ++pub type ma_ios_session_category = core::ffi::c_uint; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_mix_with_others: ++ ma_ios_session_category_option = 1; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_duck_others: ++ ma_ios_session_category_option = 2; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_allow_bluetooth: ++ ma_ios_session_category_option = 4; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_default_to_speaker: ++ ma_ios_session_category_option = 8; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_interrupt_spoken_audio_and_mix_with_others : ma_ios_session_category_option = 17 ; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_allow_bluetooth_a2dp: ++ ma_ios_session_category_option = 32; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_allow_air_play: ++ ma_ios_session_category_option = 64; ++pub type ma_ios_session_category_option = core::ffi::c_uint; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_default: ma_opensl_stream_type = 0; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_voice: ma_opensl_stream_type = 1; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_system: ma_opensl_stream_type = 2; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_ring: ma_opensl_stream_type = 3; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_media: ma_opensl_stream_type = 4; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_alarm: ma_opensl_stream_type = 5; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_notification: ma_opensl_stream_type = 6; ++pub type ma_opensl_stream_type = core::ffi::c_uint; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_default: ++ ma_opensl_recording_preset = 0; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_generic: ++ ma_opensl_recording_preset = 1; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_camcorder: ++ ma_opensl_recording_preset = 2; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_voice_recognition: ++ ma_opensl_recording_preset = 3; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_voice_communication: ++ ma_opensl_recording_preset = 4; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_voice_unprocessed: ++ ma_opensl_recording_preset = 5; ++pub type ma_opensl_recording_preset = core::ffi::c_uint; ++pub const ma_wasapi_usage_ma_wasapi_usage_default: ma_wasapi_usage = 0; ++pub const ma_wasapi_usage_ma_wasapi_usage_games: ma_wasapi_usage = 1; ++pub const ma_wasapi_usage_ma_wasapi_usage_pro_audio: ma_wasapi_usage = 2; ++pub type ma_wasapi_usage = core::ffi::c_uint; ++pub const ma_aaudio_usage_ma_aaudio_usage_default: ma_aaudio_usage = 0; ++pub const ma_aaudio_usage_ma_aaudio_usage_media: ma_aaudio_usage = 1; ++pub const ma_aaudio_usage_ma_aaudio_usage_voice_communication: ma_aaudio_usage = 2; ++pub const ma_aaudio_usage_ma_aaudio_usage_voice_communication_signalling: ma_aaudio_usage = 3; ++pub const ma_aaudio_usage_ma_aaudio_usage_alarm: ma_aaudio_usage = 4; ++pub const ma_aaudio_usage_ma_aaudio_usage_notification: ma_aaudio_usage = 5; ++pub const ma_aaudio_usage_ma_aaudio_usage_notification_ringtone: ma_aaudio_usage = 6; ++pub const ma_aaudio_usage_ma_aaudio_usage_notification_event: ma_aaudio_usage = 7; ++pub const ma_aaudio_usage_ma_aaudio_usage_assistance_accessibility: ma_aaudio_usage = 8; ++pub const ma_aaudio_usage_ma_aaudio_usage_assistance_navigation_guidance: ma_aaudio_usage = 9; ++pub const ma_aaudio_usage_ma_aaudio_usage_assistance_sonification: ma_aaudio_usage = 10; ++pub const ma_aaudio_usage_ma_aaudio_usage_game: ma_aaudio_usage = 11; ++pub const ma_aaudio_usage_ma_aaudio_usage_assitant: ma_aaudio_usage = 12; ++pub const ma_aaudio_usage_ma_aaudio_usage_emergency: ma_aaudio_usage = 13; ++pub const ma_aaudio_usage_ma_aaudio_usage_safety: ma_aaudio_usage = 14; ++pub const ma_aaudio_usage_ma_aaudio_usage_vehicle_status: ma_aaudio_usage = 15; ++pub const ma_aaudio_usage_ma_aaudio_usage_announcement: ma_aaudio_usage = 16; ++pub type ma_aaudio_usage = core::ffi::c_uint; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_default: ma_aaudio_content_type = 0; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_speech: ma_aaudio_content_type = 1; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_music: ma_aaudio_content_type = 2; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_movie: ma_aaudio_content_type = 3; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_sonification: ma_aaudio_content_type = 4; ++pub type ma_aaudio_content_type = core::ffi::c_uint; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_default: ma_aaudio_input_preset = 0; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_generic: ma_aaudio_input_preset = 1; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_camcorder: ma_aaudio_input_preset = 2; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_voice_recognition: ma_aaudio_input_preset = ++ 3; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_voice_communication: ++ ma_aaudio_input_preset = 4; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_unprocessed: ma_aaudio_input_preset = 5; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_voice_performance: ma_aaudio_input_preset = ++ 6; ++pub type ma_aaudio_input_preset = core::ffi::c_uint; ++pub const ma_aaudio_allowed_capture_policy_ma_aaudio_allow_capture_default: ++ ma_aaudio_allowed_capture_policy = 0; ++pub const ma_aaudio_allowed_capture_policy_ma_aaudio_allow_capture_by_all: ++ ma_aaudio_allowed_capture_policy = 1; ++pub const ma_aaudio_allowed_capture_policy_ma_aaudio_allow_capture_by_system: ++ ma_aaudio_allowed_capture_policy = 2; ++pub const ma_aaudio_allowed_capture_policy_ma_aaudio_allow_capture_by_none: ++ ma_aaudio_allowed_capture_policy = 3; ++pub type ma_aaudio_allowed_capture_policy = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_timer { ++ pub counter: ma_int64, ++ pub counterD: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_timer"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_timer"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_timer::counter"][::core::mem::offset_of!(ma_timer, counter) - 0usize]; ++ ["Offset of field: ma_timer::counterD"][::core::mem::offset_of!(ma_timer, counterD) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_device_id { ++ pub wasapi: [ma_wchar_win32; 64usize], ++ pub dsound: [ma_uint8; 16usize], ++ pub winmm: ma_uint32, ++ pub alsa: [core::ffi::c_char; 256usize], ++ pub pulse: [core::ffi::c_char; 256usize], ++ pub jack: core::ffi::c_int, ++ pub coreaudio: [core::ffi::c_char; 256usize], ++ pub sndio: [core::ffi::c_char; 256usize], ++ pub audio4: [core::ffi::c_char; 256usize], ++ pub oss: [core::ffi::c_char; 64usize], ++ pub aaudio: ma_int32, ++ pub opensl: ma_uint32, ++ pub webaudio: [core::ffi::c_char; 32usize], ++ pub custom: ma_device_id__bindgen_ty_1, ++ pub nullbackend: core::ffi::c_int, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_device_id__bindgen_ty_1 { ++ pub i: core::ffi::c_int, ++ pub s: [core::ffi::c_char; 256usize], ++ pub p: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_id__bindgen_ty_1"] ++ [::core::mem::size_of::() - 256usize]; ++ ["Alignment of ma_device_id__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_id__bindgen_ty_1::i"] ++ [::core::mem::offset_of!(ma_device_id__bindgen_ty_1, i) - 0usize]; ++ ["Offset of field: ma_device_id__bindgen_ty_1::s"] ++ [::core::mem::offset_of!(ma_device_id__bindgen_ty_1, s) - 0usize]; ++ ["Offset of field: ma_device_id__bindgen_ty_1::p"] ++ [::core::mem::offset_of!(ma_device_id__bindgen_ty_1, p) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_id"][::core::mem::size_of::() - 256usize]; ++ ["Alignment of ma_device_id"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_id::wasapi"] ++ [::core::mem::offset_of!(ma_device_id, wasapi) - 0usize]; ++ ["Offset of field: ma_device_id::dsound"] ++ [::core::mem::offset_of!(ma_device_id, dsound) - 0usize]; ++ ["Offset of field: ma_device_id::winmm"][::core::mem::offset_of!(ma_device_id, winmm) - 0usize]; ++ ["Offset of field: ma_device_id::alsa"][::core::mem::offset_of!(ma_device_id, alsa) - 0usize]; ++ ["Offset of field: ma_device_id::pulse"][::core::mem::offset_of!(ma_device_id, pulse) - 0usize]; ++ ["Offset of field: ma_device_id::jack"][::core::mem::offset_of!(ma_device_id, jack) - 0usize]; ++ ["Offset of field: ma_device_id::coreaudio"] ++ [::core::mem::offset_of!(ma_device_id, coreaudio) - 0usize]; ++ ["Offset of field: ma_device_id::sndio"][::core::mem::offset_of!(ma_device_id, sndio) - 0usize]; ++ ["Offset of field: ma_device_id::audio4"] ++ [::core::mem::offset_of!(ma_device_id, audio4) - 0usize]; ++ ["Offset of field: ma_device_id::oss"][::core::mem::offset_of!(ma_device_id, oss) - 0usize]; ++ ["Offset of field: ma_device_id::aaudio"] ++ [::core::mem::offset_of!(ma_device_id, aaudio) - 0usize]; ++ ["Offset of field: ma_device_id::opensl"] ++ [::core::mem::offset_of!(ma_device_id, opensl) - 0usize]; ++ ["Offset of field: ma_device_id::webaudio"] ++ [::core::mem::offset_of!(ma_device_id, webaudio) - 0usize]; ++ ["Offset of field: ma_device_id::custom"] ++ [::core::mem::offset_of!(ma_device_id, custom) - 0usize]; ++ ["Offset of field: ma_device_id::nullbackend"] ++ [::core::mem::offset_of!(ma_device_id, nullbackend) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_device_id_equal(pA: *const ma_device_id, pB: *const ma_device_id) -> ma_bool32; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device_info { ++ pub id: ma_device_id, ++ pub name: [core::ffi::c_char; 256usize], ++ pub isDefault: ma_bool32, ++ pub nativeDataFormatCount: ma_uint32, ++ pub nativeDataFormats: [ma_device_info__bindgen_ty_1; 64usize], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_info__bindgen_ty_1 { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub flags: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_info__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_device_info__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_info__bindgen_ty_1::format"] ++ [::core::mem::offset_of!(ma_device_info__bindgen_ty_1, format) - 0usize]; ++ ["Offset of field: ma_device_info__bindgen_ty_1::channels"] ++ [::core::mem::offset_of!(ma_device_info__bindgen_ty_1, channels) - 4usize]; ++ ["Offset of field: ma_device_info__bindgen_ty_1::sampleRate"] ++ [::core::mem::offset_of!(ma_device_info__bindgen_ty_1, sampleRate) - 8usize]; ++ ["Offset of field: ma_device_info__bindgen_ty_1::flags"] ++ [::core::mem::offset_of!(ma_device_info__bindgen_ty_1, flags) - 12usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_info"][::core::mem::size_of::() - 1544usize]; ++ ["Alignment of ma_device_info"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_info::id"][::core::mem::offset_of!(ma_device_info, id) - 0usize]; ++ ["Offset of field: ma_device_info::name"] ++ [::core::mem::offset_of!(ma_device_info, name) - 256usize]; ++ ["Offset of field: ma_device_info::isDefault"] ++ [::core::mem::offset_of!(ma_device_info, isDefault) - 512usize]; ++ ["Offset of field: ma_device_info::nativeDataFormatCount"] ++ [::core::mem::offset_of!(ma_device_info, nativeDataFormatCount) - 516usize]; ++ ["Offset of field: ma_device_info::nativeDataFormats"] ++ [::core::mem::offset_of!(ma_device_info, nativeDataFormats) - 520usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config { ++ pub deviceType: ma_device_type, ++ pub sampleRate: ma_uint32, ++ pub periodSizeInFrames: ma_uint32, ++ pub periodSizeInMilliseconds: ma_uint32, ++ pub periods: ma_uint32, ++ pub performanceProfile: ma_performance_profile, ++ pub noPreSilencedOutputBuffer: ma_bool8, ++ pub noClip: ma_bool8, ++ pub noDisableDenormals: ma_bool8, ++ pub noFixedSizedCallback: ma_bool8, ++ pub dataCallback: ma_device_data_proc, ++ pub notificationCallback: ma_device_notification_proc, ++ pub stopCallback: ma_stop_proc, ++ pub pUserData: *mut core::ffi::c_void, ++ pub resampling: ma_resampler_config, ++ pub playback: ma_device_config__bindgen_ty_1, ++ pub capture: ma_device_config__bindgen_ty_2, ++ pub wasapi: ma_device_config__bindgen_ty_3, ++ pub alsa: ma_device_config__bindgen_ty_4, ++ pub pulse: ma_device_config__bindgen_ty_5, ++ pub coreaudio: ma_device_config__bindgen_ty_6, ++ pub opensl: ma_device_config__bindgen_ty_7, ++ pub aaudio: ma_device_config__bindgen_ty_8, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_1 { ++ pub pDeviceID: *const ma_device_id, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub pChannelMap: *mut ma_channel, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub shareMode: ma_share_mode, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_1"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_device_config__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::pDeviceID"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, pDeviceID) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::format"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, format) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::channels"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, channels) - 12usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::pChannelMap"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, pChannelMap) - 16usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::channelMixMode"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, channelMixMode) - 24usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_1, ++ calculateLFEFromSpatialChannels ++ ) ++ - 28usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::shareMode"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, shareMode) - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_2 { ++ pub pDeviceID: *const ma_device_id, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub pChannelMap: *mut ma_channel, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub shareMode: ma_share_mode, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_2"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_device_config__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::pDeviceID"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, pDeviceID) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::format"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, format) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::channels"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, channels) - 12usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::pChannelMap"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, pChannelMap) - 16usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::channelMixMode"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, channelMixMode) - 24usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_2, ++ calculateLFEFromSpatialChannels ++ ) ++ - 28usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::shareMode"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, shareMode) - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_3 { ++ pub usage: ma_wasapi_usage, ++ pub noAutoConvertSRC: ma_bool8, ++ pub noDefaultQualitySRC: ma_bool8, ++ pub noAutoStreamRouting: ma_bool8, ++ pub noHardwareOffloading: ma_bool8, ++ pub loopbackProcessID: ma_uint32, ++ pub loopbackProcessExclude: ma_bool8, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_3"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_device_config__bindgen_ty_3"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::usage"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, usage) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::noAutoConvertSRC"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, noAutoConvertSRC) - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::noDefaultQualitySRC"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, noDefaultQualitySRC) - 5usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::noAutoStreamRouting"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, noAutoStreamRouting) - 6usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::noHardwareOffloading"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, noHardwareOffloading) - 7usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::loopbackProcessID"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, loopbackProcessID) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::loopbackProcessExclude"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, loopbackProcessExclude) - 12usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_4 { ++ pub noMMap: ma_bool32, ++ pub noAutoFormat: ma_bool32, ++ pub noAutoChannels: ma_bool32, ++ pub noAutoResample: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_4"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_device_config__bindgen_ty_4"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_4::noMMap"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_4, noMMap) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_4::noAutoFormat"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_4, noAutoFormat) - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_4::noAutoChannels"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_4, noAutoChannels) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_4::noAutoResample"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_4, noAutoResample) - 12usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_5 { ++ pub pStreamNamePlayback: *const core::ffi::c_char, ++ pub pStreamNameCapture: *const core::ffi::c_char, ++ pub channelMap: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_5"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_device_config__bindgen_ty_5"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_5::pStreamNamePlayback"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_5, pStreamNamePlayback) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_5::pStreamNameCapture"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_5, pStreamNameCapture) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_5::channelMap"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_5, channelMap) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_6 { ++ pub allowNominalSampleRateChange: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_6"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_config__bindgen_ty_6"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_6::allowNominalSampleRateChange"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_6, ++ allowNominalSampleRateChange ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_7 { ++ pub streamType: ma_opensl_stream_type, ++ pub recordingPreset: ma_opensl_recording_preset, ++ pub enableCompatibilityWorkarounds: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_7"] ++ [::core::mem::size_of::() - 12usize]; ++ ["Alignment of ma_device_config__bindgen_ty_7"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_7::streamType"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_7, streamType) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_7::recordingPreset"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_7, recordingPreset) - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_7::enableCompatibilityWorkarounds"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_7, ++ enableCompatibilityWorkarounds ++ ) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_8 { ++ pub usage: ma_aaudio_usage, ++ pub contentType: ma_aaudio_content_type, ++ pub inputPreset: ma_aaudio_input_preset, ++ pub allowedCapturePolicy: ma_aaudio_allowed_capture_policy, ++ pub noAutoStartAfterReroute: ma_bool32, ++ pub enableCompatibilityWorkarounds: ma_bool32, ++ pub allowSetBufferCapacity: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_8"] ++ [::core::mem::size_of::() - 28usize]; ++ ["Alignment of ma_device_config__bindgen_ty_8"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::usage"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, usage) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::contentType"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, contentType) - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::inputPreset"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, inputPreset) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::allowedCapturePolicy"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, allowedCapturePolicy) - 12usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::noAutoStartAfterReroute"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_8, ++ noAutoStartAfterReroute ++ ) - 16usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::enableCompatibilityWorkarounds"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_8, ++ enableCompatibilityWorkarounds ++ ) ++ - 20usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::allowSetBufferCapacity"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, allowSetBufferCapacity) - 24usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config"][::core::mem::size_of::() - 296usize]; ++ ["Alignment of ma_device_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_config::deviceType"] ++ [::core::mem::offset_of!(ma_device_config, deviceType) - 0usize]; ++ ["Offset of field: ma_device_config::sampleRate"] ++ [::core::mem::offset_of!(ma_device_config, sampleRate) - 4usize]; ++ ["Offset of field: ma_device_config::periodSizeInFrames"] ++ [::core::mem::offset_of!(ma_device_config, periodSizeInFrames) - 8usize]; ++ ["Offset of field: ma_device_config::periodSizeInMilliseconds"] ++ [::core::mem::offset_of!(ma_device_config, periodSizeInMilliseconds) - 12usize]; ++ ["Offset of field: ma_device_config::periods"] ++ [::core::mem::offset_of!(ma_device_config, periods) - 16usize]; ++ ["Offset of field: ma_device_config::performanceProfile"] ++ [::core::mem::offset_of!(ma_device_config, performanceProfile) - 20usize]; ++ ["Offset of field: ma_device_config::noPreSilencedOutputBuffer"] ++ [::core::mem::offset_of!(ma_device_config, noPreSilencedOutputBuffer) - 24usize]; ++ ["Offset of field: ma_device_config::noClip"] ++ [::core::mem::offset_of!(ma_device_config, noClip) - 25usize]; ++ ["Offset of field: ma_device_config::noDisableDenormals"] ++ [::core::mem::offset_of!(ma_device_config, noDisableDenormals) - 26usize]; ++ ["Offset of field: ma_device_config::noFixedSizedCallback"] ++ [::core::mem::offset_of!(ma_device_config, noFixedSizedCallback) - 27usize]; ++ ["Offset of field: ma_device_config::dataCallback"] ++ [::core::mem::offset_of!(ma_device_config, dataCallback) - 32usize]; ++ ["Offset of field: ma_device_config::notificationCallback"] ++ [::core::mem::offset_of!(ma_device_config, notificationCallback) - 40usize]; ++ ["Offset of field: ma_device_config::stopCallback"] ++ [::core::mem::offset_of!(ma_device_config, stopCallback) - 48usize]; ++ ["Offset of field: ma_device_config::pUserData"] ++ [::core::mem::offset_of!(ma_device_config, pUserData) - 56usize]; ++ ["Offset of field: ma_device_config::resampling"] ++ [::core::mem::offset_of!(ma_device_config, resampling) - 64usize]; ++ ["Offset of field: ma_device_config::playback"] ++ [::core::mem::offset_of!(ma_device_config, playback) - 112usize]; ++ ["Offset of field: ma_device_config::capture"] ++ [::core::mem::offset_of!(ma_device_config, capture) - 152usize]; ++ ["Offset of field: ma_device_config::wasapi"] ++ [::core::mem::offset_of!(ma_device_config, wasapi) - 192usize]; ++ ["Offset of field: ma_device_config::alsa"] ++ [::core::mem::offset_of!(ma_device_config, alsa) - 208usize]; ++ ["Offset of field: ma_device_config::pulse"] ++ [::core::mem::offset_of!(ma_device_config, pulse) - 224usize]; ++ ["Offset of field: ma_device_config::coreaudio"] ++ [::core::mem::offset_of!(ma_device_config, coreaudio) - 248usize]; ++ ["Offset of field: ma_device_config::opensl"] ++ [::core::mem::offset_of!(ma_device_config, opensl) - 252usize]; ++ ["Offset of field: ma_device_config::aaudio"] ++ [::core::mem::offset_of!(ma_device_config, aaudio) - 264usize]; ++}; ++pub type ma_enum_devices_callback_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pContext: *mut ma_context, ++ deviceType: ma_device_type, ++ pInfo: *const ma_device_info, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_bool32, ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_descriptor { ++ pub pDeviceID: *const ma_device_id, ++ pub shareMode: ma_share_mode, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub channelMap: [ma_channel; 254usize], ++ pub periodSizeInFrames: ma_uint32, ++ pub periodSizeInMilliseconds: ma_uint32, ++ pub periodCount: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_descriptor"][::core::mem::size_of::() - 296usize]; ++ ["Alignment of ma_device_descriptor"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_descriptor::pDeviceID"] ++ [::core::mem::offset_of!(ma_device_descriptor, pDeviceID) - 0usize]; ++ ["Offset of field: ma_device_descriptor::shareMode"] ++ [::core::mem::offset_of!(ma_device_descriptor, shareMode) - 8usize]; ++ ["Offset of field: ma_device_descriptor::format"] ++ [::core::mem::offset_of!(ma_device_descriptor, format) - 12usize]; ++ ["Offset of field: ma_device_descriptor::channels"] ++ [::core::mem::offset_of!(ma_device_descriptor, channels) - 16usize]; ++ ["Offset of field: ma_device_descriptor::sampleRate"] ++ [::core::mem::offset_of!(ma_device_descriptor, sampleRate) - 20usize]; ++ ["Offset of field: ma_device_descriptor::channelMap"] ++ [::core::mem::offset_of!(ma_device_descriptor, channelMap) - 24usize]; ++ ["Offset of field: ma_device_descriptor::periodSizeInFrames"] ++ [::core::mem::offset_of!(ma_device_descriptor, periodSizeInFrames) - 280usize]; ++ ["Offset of field: ma_device_descriptor::periodSizeInMilliseconds"] ++ [::core::mem::offset_of!(ma_device_descriptor, periodSizeInMilliseconds) - 284usize]; ++ ["Offset of field: ma_device_descriptor::periodCount"] ++ [::core::mem::offset_of!(ma_device_descriptor, periodCount) - 288usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_backend_callbacks { ++ pub onContextInit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pContext: *mut ma_context, ++ pConfig: *const ma_context_config, ++ pCallbacks: *mut ma_backend_callbacks, ++ ) -> ma_result, ++ >, ++ pub onContextUninit: ++ ::core::option::Option ma_result>, ++ pub onContextEnumerateDevices: ::core::option::Option< ++ unsafe extern "C" fn( ++ pContext: *mut ma_context, ++ callback: ma_enum_devices_callback_proc, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_result, ++ >, ++ pub onContextGetDeviceInfo: ::core::option::Option< ++ unsafe extern "C" fn( ++ pContext: *mut ma_context, ++ deviceType: ma_device_type, ++ pDeviceID: *const ma_device_id, ++ pDeviceInfo: *mut ma_device_info, ++ ) -> ma_result, ++ >, ++ pub onDeviceInit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ pConfig: *const ma_device_config, ++ pDescriptorPlayback: *mut ma_device_descriptor, ++ pDescriptorCapture: *mut ma_device_descriptor, ++ ) -> ma_result, ++ >, ++ pub onDeviceUninit: ++ ::core::option::Option ma_result>, ++ pub onDeviceStart: ++ ::core::option::Option ma_result>, ++ pub onDeviceStop: ++ ::core::option::Option ma_result>, ++ pub onDeviceRead: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ pFrames: *mut core::ffi::c_void, ++ frameCount: ma_uint32, ++ pFramesRead: *mut ma_uint32, ++ ) -> ma_result, ++ >, ++ pub onDeviceWrite: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ pFrames: *const core::ffi::c_void, ++ frameCount: ma_uint32, ++ pFramesWritten: *mut ma_uint32, ++ ) -> ma_result, ++ >, ++ pub onDeviceDataLoop: ++ ::core::option::Option ma_result>, ++ pub onDeviceDataLoopWakeup: ++ ::core::option::Option ma_result>, ++ pub onDeviceGetInfo: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ type_: ma_device_type, ++ pDeviceInfo: *mut ma_device_info, ++ ) -> ma_result, ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_backend_callbacks"][::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_backend_callbacks"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_backend_callbacks::onContextInit"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onContextInit) - 0usize]; ++ ["Offset of field: ma_backend_callbacks::onContextUninit"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onContextUninit) - 8usize]; ++ ["Offset of field: ma_backend_callbacks::onContextEnumerateDevices"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onContextEnumerateDevices) - 16usize]; ++ ["Offset of field: ma_backend_callbacks::onContextGetDeviceInfo"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onContextGetDeviceInfo) - 24usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceInit"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceInit) - 32usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceUninit"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceUninit) - 40usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceStart"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceStart) - 48usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceStop"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceStop) - 56usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceRead"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceRead) - 64usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceWrite"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceWrite) - 72usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceDataLoop"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceDataLoop) - 80usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceDataLoopWakeup"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceDataLoopWakeup) - 88usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceGetInfo"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceGetInfo) - 96usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config { ++ pub pLog: *mut ma_log, ++ pub threadPriority: ma_thread_priority, ++ pub threadStackSize: usize, ++ pub pUserData: *mut core::ffi::c_void, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub dsound: ma_context_config__bindgen_ty_1, ++ pub alsa: ma_context_config__bindgen_ty_2, ++ pub pulse: ma_context_config__bindgen_ty_3, ++ pub coreaudio: ma_context_config__bindgen_ty_4, ++ pub jack: ma_context_config__bindgen_ty_5, ++ pub custom: ma_backend_callbacks, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_1 { ++ pub hWnd: ma_handle, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_1"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_context_config__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_1::hWnd"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_1, hWnd) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_2 { ++ pub useVerboseDeviceEnumeration: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_2"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context_config__bindgen_ty_2"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_2::useVerboseDeviceEnumeration"][::core::mem::offset_of!( ++ ma_context_config__bindgen_ty_2, ++ useVerboseDeviceEnumeration ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_3 { ++ pub pApplicationName: *const core::ffi::c_char, ++ pub pServerName: *const core::ffi::c_char, ++ pub tryAutoSpawn: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_3"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_context_config__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_3::pApplicationName"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_3, pApplicationName) - 0usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_3::pServerName"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_3, pServerName) - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_3::tryAutoSpawn"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_3, tryAutoSpawn) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_4 { ++ pub sessionCategory: ma_ios_session_category, ++ pub sessionCategoryOptions: ma_uint32, ++ pub noAudioSessionActivate: ma_bool32, ++ pub noAudioSessionDeactivate: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_4"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_context_config__bindgen_ty_4"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_4::sessionCategory"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_4, sessionCategory) - 0usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_4::sessionCategoryOptions"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_4, sessionCategoryOptions) - 4usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_4::noAudioSessionActivate"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_4, noAudioSessionActivate) - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_4::noAudioSessionDeactivate"][::core::mem::offset_of!( ++ ma_context_config__bindgen_ty_4, ++ noAudioSessionDeactivate ++ ) - 12usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_5 { ++ pub pClientName: *const core::ffi::c_char, ++ pub tryStartServer: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_5"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_context_config__bindgen_ty_5"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_5::pClientName"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_5, pClientName) - 0usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_5::tryStartServer"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_5, tryStartServer) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config"][::core::mem::size_of::() - 240usize]; ++ ["Alignment of ma_context_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_config::pLog"] ++ [::core::mem::offset_of!(ma_context_config, pLog) - 0usize]; ++ ["Offset of field: ma_context_config::threadPriority"] ++ [::core::mem::offset_of!(ma_context_config, threadPriority) - 8usize]; ++ ["Offset of field: ma_context_config::threadStackSize"] ++ [::core::mem::offset_of!(ma_context_config, threadStackSize) - 16usize]; ++ ["Offset of field: ma_context_config::pUserData"] ++ [::core::mem::offset_of!(ma_context_config, pUserData) - 24usize]; ++ ["Offset of field: ma_context_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_context_config, allocationCallbacks) - 32usize]; ++ ["Offset of field: ma_context_config::dsound"] ++ [::core::mem::offset_of!(ma_context_config, dsound) - 64usize]; ++ ["Offset of field: ma_context_config::alsa"] ++ [::core::mem::offset_of!(ma_context_config, alsa) - 72usize]; ++ ["Offset of field: ma_context_config::pulse"] ++ [::core::mem::offset_of!(ma_context_config, pulse) - 80usize]; ++ ["Offset of field: ma_context_config::coreaudio"] ++ [::core::mem::offset_of!(ma_context_config, coreaudio) - 104usize]; ++ ["Offset of field: ma_context_config::jack"] ++ [::core::mem::offset_of!(ma_context_config, jack) - 120usize]; ++ ["Offset of field: ma_context_config::custom"] ++ [::core::mem::offset_of!(ma_context_config, custom) - 136usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_context_command__wasapi { ++ pub code: core::ffi::c_int, ++ pub pEvent: *mut ma_event, ++ pub data: ma_context_command__wasapi__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_context_command__wasapi__bindgen_ty_1 { ++ pub quit: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1, ++ pub createAudioClient: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ pub releaseAudioClient: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1"][::core::mem::align_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1, ++ >() - 4usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1::_unused"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1, ++ _unused ++ ) ++ - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2 { ++ pub deviceType: ma_device_type, ++ pub pAudioClient: *mut core::ffi::c_void, ++ pub ppAudioClientService: *mut *mut core::ffi::c_void, ++ pub pResult: *mut ma_result, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2"][::core::mem::size_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ >() - 32usize]; ++ ["Alignment of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2"][::core::mem::align_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ >() - 8usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2::deviceType"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ deviceType ++ ) ++ - 0usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2::pAudioClient"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ pAudioClient ++ ) ++ - 8usize]; ++ [ ++ "Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2::ppAudioClientService", ++ ][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ ppAudioClientService ++ ) - 16usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2::pResult"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ pResult ++ ) ++ - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3 { ++ pub pDevice: *mut ma_device, ++ pub deviceType: ma_device_type, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3"][::core::mem::size_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++ >() - 16usize]; ++ ["Alignment of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3"][::core::mem::align_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++ >() - 8usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3::pDevice"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++ pDevice ++ ) ++ - 0usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3::deviceType"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++ deviceType ++ ) ++ - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi__bindgen_ty_1"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_context_command__wasapi__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1::quit"] ++ [::core::mem::offset_of!(ma_context_command__wasapi__bindgen_ty_1, quit) - 0usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1::createAudioClient"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1, ++ createAudioClient ++ ) - 0usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1::releaseAudioClient"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1, ++ releaseAudioClient ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_context_command__wasapi"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_command__wasapi::code"] ++ [::core::mem::offset_of!(ma_context_command__wasapi, code) - 0usize]; ++ ["Offset of field: ma_context_command__wasapi::pEvent"] ++ [::core::mem::offset_of!(ma_context_command__wasapi, pEvent) - 8usize]; ++ ["Offset of field: ma_context_command__wasapi::data"] ++ [::core::mem::offset_of!(ma_context_command__wasapi, data) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_context { ++ pub callbacks: ma_backend_callbacks, ++ pub backend: ma_backend, ++ pub pLog: *mut ma_log, ++ pub log: ma_log, ++ pub threadPriority: ma_thread_priority, ++ pub threadStackSize: usize, ++ pub pUserData: *mut core::ffi::c_void, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub deviceEnumLock: ma_mutex, ++ pub deviceInfoLock: ma_mutex, ++ pub deviceInfoCapacity: ma_uint32, ++ pub playbackDeviceInfoCount: ma_uint32, ++ pub captureDeviceInfoCount: ma_uint32, ++ pub pDeviceInfos: *mut ma_device_info, ++ pub __bindgen_anon_1: ma_context__bindgen_ty_1, ++ pub __bindgen_anon_2: ma_context__bindgen_ty_2, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_context__bindgen_ty_1 { ++ pub alsa: ma_context__bindgen_ty_1__bindgen_ty_1, ++ pub pulse: ma_context__bindgen_ty_1__bindgen_ty_2, ++ pub jack: ma_context__bindgen_ty_1__bindgen_ty_3, ++ pub null_backend: ma_context__bindgen_ty_1__bindgen_ty_4, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_context__bindgen_ty_1__bindgen_ty_1 { ++ pub asoundSO: ma_handle, ++ pub snd_pcm_open: ma_proc, ++ pub snd_pcm_close: ma_proc, ++ pub snd_pcm_hw_params_sizeof: ma_proc, ++ pub snd_pcm_hw_params_any: ma_proc, ++ pub snd_pcm_hw_params_set_format: ma_proc, ++ pub snd_pcm_hw_params_set_format_first: ma_proc, ++ pub snd_pcm_hw_params_get_format_mask: ma_proc, ++ pub snd_pcm_hw_params_set_channels: ma_proc, ++ pub snd_pcm_hw_params_set_channels_near: ma_proc, ++ pub snd_pcm_hw_params_set_channels_minmax: ma_proc, ++ pub snd_pcm_hw_params_set_rate_resample: ma_proc, ++ pub snd_pcm_hw_params_set_rate: ma_proc, ++ pub snd_pcm_hw_params_set_rate_near: ma_proc, ++ pub snd_pcm_hw_params_set_rate_minmax: ma_proc, ++ pub snd_pcm_hw_params_set_buffer_size_near: ma_proc, ++ pub snd_pcm_hw_params_set_periods_near: ma_proc, ++ pub snd_pcm_hw_params_set_access: ma_proc, ++ pub snd_pcm_hw_params_get_format: ma_proc, ++ pub snd_pcm_hw_params_get_channels: ma_proc, ++ pub snd_pcm_hw_params_get_channels_min: ma_proc, ++ pub snd_pcm_hw_params_get_channels_max: ma_proc, ++ pub snd_pcm_hw_params_get_rate: ma_proc, ++ pub snd_pcm_hw_params_get_rate_min: ma_proc, ++ pub snd_pcm_hw_params_get_rate_max: ma_proc, ++ pub snd_pcm_hw_params_get_buffer_size: ma_proc, ++ pub snd_pcm_hw_params_get_periods: ma_proc, ++ pub snd_pcm_hw_params_get_access: ma_proc, ++ pub snd_pcm_hw_params_test_format: ma_proc, ++ pub snd_pcm_hw_params_test_channels: ma_proc, ++ pub snd_pcm_hw_params_test_rate: ma_proc, ++ pub snd_pcm_hw_params: ma_proc, ++ pub snd_pcm_sw_params_sizeof: ma_proc, ++ pub snd_pcm_sw_params_current: ma_proc, ++ pub snd_pcm_sw_params_get_boundary: ma_proc, ++ pub snd_pcm_sw_params_set_avail_min: ma_proc, ++ pub snd_pcm_sw_params_set_start_threshold: ma_proc, ++ pub snd_pcm_sw_params_set_stop_threshold: ma_proc, ++ pub snd_pcm_sw_params: ma_proc, ++ pub snd_pcm_format_mask_sizeof: ma_proc, ++ pub snd_pcm_format_mask_test: ma_proc, ++ pub snd_pcm_get_chmap: ma_proc, ++ pub snd_pcm_state: ma_proc, ++ pub snd_pcm_prepare: ma_proc, ++ pub snd_pcm_start: ma_proc, ++ pub snd_pcm_drop: ma_proc, ++ pub snd_pcm_drain: ma_proc, ++ pub snd_pcm_reset: ma_proc, ++ pub snd_device_name_hint: ma_proc, ++ pub snd_device_name_get_hint: ma_proc, ++ pub snd_card_get_index: ma_proc, ++ pub snd_device_name_free_hint: ma_proc, ++ pub snd_pcm_mmap_begin: ma_proc, ++ pub snd_pcm_mmap_commit: ma_proc, ++ pub snd_pcm_recover: ma_proc, ++ pub snd_pcm_readi: ma_proc, ++ pub snd_pcm_writei: ma_proc, ++ pub snd_pcm_avail: ma_proc, ++ pub snd_pcm_avail_update: ma_proc, ++ pub snd_pcm_wait: ma_proc, ++ pub snd_pcm_nonblock: ma_proc, ++ pub snd_pcm_info: ma_proc, ++ pub snd_pcm_info_sizeof: ma_proc, ++ pub snd_pcm_info_get_name: ma_proc, ++ pub snd_pcm_poll_descriptors: ma_proc, ++ pub snd_pcm_poll_descriptors_count: ma_proc, ++ pub snd_pcm_poll_descriptors_revents: ma_proc, ++ pub snd_config_update_free_global: ma_proc, ++ pub internalDeviceEnumLock: ma_mutex, ++ pub useVerboseDeviceEnumeration: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 600usize]; ++ ["Alignment of ma_context__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::asoundSO"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, asoundSO) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_open"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_open) - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_close"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_close) - 16usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_sizeof"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_sizeof ++ ) ++ - 24usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_any"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_any ++ ) - 32usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_format"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_format ++ ) ++ - 40usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_format_first"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_format_first ++ ) - 48usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_format_mask"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_format_mask ++ ) - 56usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_channels"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_channels ++ ) ++ - 64usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_channels_near", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_channels_near ++ ) - 72usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_channels_minmax", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_channels_minmax ++ ) - 80usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_rate_resample", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_rate_resample ++ ) - 88usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_rate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_rate ++ ) ++ - 96usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_rate_near"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_rate_near ++ ) ++ - 104usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_rate_minmax"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_rate_minmax ++ ) - 112usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_buffer_size_near", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_buffer_size_near ++ ) - 120usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_periods_near"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_periods_near ++ ) - 128usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_access"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_access ++ ) ++ - 136usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_format"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_format ++ ) ++ - 144usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_channels"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_channels ++ ) ++ - 152usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_channels_min"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_channels_min ++ ) - 160usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_channels_max"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_channels_max ++ ) - 168usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_rate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_rate ++ ) ++ - 176usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_rate_min"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_rate_min ++ ) ++ - 184usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_rate_max"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_rate_max ++ ) ++ - 192usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_buffer_size"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_buffer_size ++ ) - 200usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_periods"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_periods ++ ) ++ - 208usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_access"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_access ++ ) ++ - 216usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_test_format"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_test_format ++ ) ++ - 224usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_test_channels"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_test_channels ++ ) ++ - 232usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_test_rate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_test_rate ++ ) ++ - 240usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params ++ ) - 248usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_sizeof"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_sizeof ++ ) ++ - 256usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_current"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_current ++ ) ++ - 264usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_get_boundary"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_get_boundary ++ ) ++ - 272usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_set_avail_min"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_set_avail_min ++ ) ++ - 280usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_set_start_threshold", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_set_start_threshold ++ ) - 288usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_set_stop_threshold", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_set_stop_threshold ++ ) - 296usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params ++ ) - 304usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_format_mask_sizeof"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_format_mask_sizeof ++ ) ++ - 312usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_format_mask_test"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_format_mask_test ++ ) ++ - 320usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_get_chmap"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_get_chmap ++ ) - 328usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_state"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_state) - 336usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_prepare"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_prepare ++ ) - 344usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_start"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_start) - 352usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_drop"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_drop) - 360usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_drain"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_drain) - 368usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_reset"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_reset) - 376usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_device_name_hint"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_device_name_hint ++ ) - 384usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_device_name_get_hint"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_device_name_get_hint ++ ) ++ - 392usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_card_get_index"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_card_get_index ++ ) - 400usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_device_name_free_hint"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_device_name_free_hint ++ ) ++ - 408usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_mmap_begin"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_mmap_begin ++ ) - 416usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_mmap_commit"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_mmap_commit ++ ) - 424usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_recover"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_recover ++ ) - 432usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_readi"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_readi) - 440usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_writei"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_writei ++ ) - 448usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_avail"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_avail) - 456usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_avail_update"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_avail_update ++ ) - 464usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_wait"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_wait) - 472usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_nonblock"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_nonblock ++ ) - 480usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_info"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_info) - 488usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_info_sizeof"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_info_sizeof ++ ) - 496usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_info_get_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_info_get_name ++ ) ++ - 504usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_poll_descriptors"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_poll_descriptors ++ ) ++ - 512usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_poll_descriptors_count"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_poll_descriptors_count ++ ) ++ - 520usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_poll_descriptors_revents"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_poll_descriptors_revents ++ ) ++ - 528usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_config_update_free_global"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_config_update_free_global ++ ) ++ - 536usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::internalDeviceEnumLock"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ internalDeviceEnumLock ++ ) ++ - 544usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::useVerboseDeviceEnumeration"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ useVerboseDeviceEnumeration ++ ) ++ - 592usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context__bindgen_ty_1__bindgen_ty_2 { ++ pub pulseSO: ma_handle, ++ pub pa_mainloop_new: ma_proc, ++ pub pa_mainloop_free: ma_proc, ++ pub pa_mainloop_quit: ma_proc, ++ pub pa_mainloop_get_api: ma_proc, ++ pub pa_mainloop_iterate: ma_proc, ++ pub pa_mainloop_wakeup: ma_proc, ++ pub pa_threaded_mainloop_new: ma_proc, ++ pub pa_threaded_mainloop_free: ma_proc, ++ pub pa_threaded_mainloop_start: ma_proc, ++ pub pa_threaded_mainloop_stop: ma_proc, ++ pub pa_threaded_mainloop_lock: ma_proc, ++ pub pa_threaded_mainloop_unlock: ma_proc, ++ pub pa_threaded_mainloop_wait: ma_proc, ++ pub pa_threaded_mainloop_signal: ma_proc, ++ pub pa_threaded_mainloop_accept: ma_proc, ++ pub pa_threaded_mainloop_get_retval: ma_proc, ++ pub pa_threaded_mainloop_get_api: ma_proc, ++ pub pa_threaded_mainloop_in_thread: ma_proc, ++ pub pa_threaded_mainloop_set_name: ma_proc, ++ pub pa_context_new: ma_proc, ++ pub pa_context_unref: ma_proc, ++ pub pa_context_connect: ma_proc, ++ pub pa_context_disconnect: ma_proc, ++ pub pa_context_set_state_callback: ma_proc, ++ pub pa_context_get_state: ma_proc, ++ pub pa_context_get_sink_info_list: ma_proc, ++ pub pa_context_get_source_info_list: ma_proc, ++ pub pa_context_get_sink_info_by_name: ma_proc, ++ pub pa_context_get_source_info_by_name: ma_proc, ++ pub pa_operation_unref: ma_proc, ++ pub pa_operation_get_state: ma_proc, ++ pub pa_channel_map_init_extend: ma_proc, ++ pub pa_channel_map_valid: ma_proc, ++ pub pa_channel_map_compatible: ma_proc, ++ pub pa_stream_new: ma_proc, ++ pub pa_stream_unref: ma_proc, ++ pub pa_stream_connect_playback: ma_proc, ++ pub pa_stream_connect_record: ma_proc, ++ pub pa_stream_disconnect: ma_proc, ++ pub pa_stream_get_state: ma_proc, ++ pub pa_stream_get_sample_spec: ma_proc, ++ pub pa_stream_get_channel_map: ma_proc, ++ pub pa_stream_get_buffer_attr: ma_proc, ++ pub pa_stream_set_buffer_attr: ma_proc, ++ pub pa_stream_get_device_name: ma_proc, ++ pub pa_stream_set_write_callback: ma_proc, ++ pub pa_stream_set_read_callback: ma_proc, ++ pub pa_stream_set_suspended_callback: ma_proc, ++ pub pa_stream_set_moved_callback: ma_proc, ++ pub pa_stream_is_suspended: ma_proc, ++ pub pa_stream_flush: ma_proc, ++ pub pa_stream_drain: ma_proc, ++ pub pa_stream_is_corked: ma_proc, ++ pub pa_stream_cork: ma_proc, ++ pub pa_stream_trigger: ma_proc, ++ pub pa_stream_begin_write: ma_proc, ++ pub pa_stream_write: ma_proc, ++ pub pa_stream_peek: ma_proc, ++ pub pa_stream_drop: ma_proc, ++ pub pa_stream_writable_size: ma_proc, ++ pub pa_stream_readable_size: ma_proc, ++ pub pMainLoop: ma_ptr, ++ pub pPulseContext: ma_ptr, ++ pub pApplicationName: *mut core::ffi::c_char, ++ pub pServerName: *mut core::ffi::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::size_of::() - 528usize]; ++ ["Alignment of ma_context__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pulseSO"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pulseSO) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_new"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pa_mainloop_new) - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_free"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_free ++ ) - 16usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_quit"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_quit ++ ) - 24usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_get_api"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_get_api ++ ) - 32usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_iterate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_iterate ++ ) - 40usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_wakeup"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_wakeup ++ ) - 48usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_new"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_new ++ ) ++ - 56usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_free"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_free ++ ) ++ - 64usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_start"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_start ++ ) ++ - 72usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_stop"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_stop ++ ) ++ - 80usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_lock"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_lock ++ ) ++ - 88usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_unlock"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_unlock ++ ) ++ - 96usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_wait"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_wait ++ ) ++ - 104usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_signal"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_signal ++ ) ++ - 112usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_accept"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_accept ++ ) ++ - 120usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_get_retval"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_get_retval ++ ) ++ - 128usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_get_api"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_get_api ++ ) ++ - 136usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_in_thread"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_in_thread ++ ) ++ - 144usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_set_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_set_name ++ ) ++ - 152usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_new"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_new ++ ) - 160usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_unref"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_unref ++ ) - 168usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_connect"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_connect ++ ) - 176usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_disconnect"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_disconnect ++ ) ++ - 184usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_set_state_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_set_state_callback ++ ) ++ - 192usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_state"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_state ++ ) - 200usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_sink_info_list"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_sink_info_list ++ ) ++ - 208usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_source_info_list"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_source_info_list ++ ) ++ - 216usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_sink_info_by_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_sink_info_by_name ++ ) ++ - 224usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_source_info_by_name"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_source_info_by_name ++ ) - 232usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_operation_unref"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_operation_unref ++ ) - 240usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_operation_get_state"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_operation_get_state ++ ) ++ - 248usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_channel_map_init_extend"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_channel_map_init_extend ++ ) ++ - 256usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_channel_map_valid"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_channel_map_valid ++ ) - 264usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_channel_map_compatible"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_channel_map_compatible ++ ) ++ - 272usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_new"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pa_stream_new) - 280usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_unref"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_unref ++ ) - 288usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_connect_playback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_connect_playback ++ ) ++ - 296usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_connect_record"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_connect_record ++ ) ++ - 304usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_disconnect"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_disconnect ++ ) - 312usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_state"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_state ++ ) - 320usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_sample_spec"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_sample_spec ++ ) ++ - 328usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_channel_map"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_channel_map ++ ) ++ - 336usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_buffer_attr"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_buffer_attr ++ ) ++ - 344usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_buffer_attr"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_buffer_attr ++ ) ++ - 352usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_device_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_device_name ++ ) ++ - 360usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_write_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_write_callback ++ ) ++ - 368usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_read_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_read_callback ++ ) ++ - 376usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_suspended_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_suspended_callback ++ ) ++ - 384usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_moved_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_moved_callback ++ ) ++ - 392usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_is_suspended"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_is_suspended ++ ) ++ - 400usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_flush"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_flush ++ ) - 408usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_drain"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_drain ++ ) - 416usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_is_corked"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_is_corked ++ ) - 424usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_cork"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_cork ++ ) - 432usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_trigger"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_trigger ++ ) - 440usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_begin_write"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_begin_write ++ ) ++ - 448usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_write"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_write ++ ) - 456usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_peek"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_peek ++ ) - 464usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_drop"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_drop ++ ) - 472usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_writable_size"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_writable_size ++ ) ++ - 480usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_readable_size"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_readable_size ++ ) ++ - 488usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pMainLoop"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pMainLoop) - 496usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pPulseContext"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pPulseContext) - 504usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pApplicationName"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pApplicationName ++ ) - 512usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pServerName"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pServerName) - 520usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context__bindgen_ty_1__bindgen_ty_3 { ++ pub jackSO: ma_handle, ++ pub jack_client_open: ma_proc, ++ pub jack_client_close: ma_proc, ++ pub jack_client_name_size: ma_proc, ++ pub jack_set_process_callback: ma_proc, ++ pub jack_set_buffer_size_callback: ma_proc, ++ pub jack_on_shutdown: ma_proc, ++ pub jack_get_sample_rate: ma_proc, ++ pub jack_get_buffer_size: ma_proc, ++ pub jack_get_ports: ma_proc, ++ pub jack_activate: ma_proc, ++ pub jack_deactivate: ma_proc, ++ pub jack_connect: ma_proc, ++ pub jack_port_register: ma_proc, ++ pub jack_port_name: ma_proc, ++ pub jack_port_get_buffer: ma_proc, ++ pub jack_free: ma_proc, ++ pub pClientName: *mut core::ffi::c_char, ++ pub tryStartServer: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_context__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jackSO"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jackSO) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_client_open"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_client_open ++ ) - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_client_close"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_client_close ++ ) - 16usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_client_name_size"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_client_name_size ++ ) - 24usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_set_process_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_set_process_callback ++ ) ++ - 32usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_set_buffer_size_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_set_buffer_size_callback ++ ) ++ - 40usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_on_shutdown"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_on_shutdown ++ ) - 48usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_get_sample_rate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_get_sample_rate ++ ) - 56usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_get_buffer_size"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_get_buffer_size ++ ) - 64usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_get_ports"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jack_get_ports) - 72usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_activate"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jack_activate) - 80usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_deactivate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_deactivate ++ ) - 88usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_connect"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jack_connect) - 96usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_port_register"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_port_register ++ ) - 104usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_port_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_port_name ++ ) - 112usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_port_get_buffer"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_port_get_buffer ++ ) - 120usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_free"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jack_free) - 128usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::pClientName"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, pClientName) - 136usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::tryStartServer"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ tryStartServer ++ ) - 144usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context__bindgen_ty_1__bindgen_ty_4 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1__bindgen_ty_4"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context__bindgen_ty_1__bindgen_ty_4"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_4::_unused"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_4, _unused) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1"] ++ [::core::mem::size_of::() - 600usize]; ++ ["Alignment of ma_context__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1::alsa"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1, alsa) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1::pulse"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1, pulse) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1::jack"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1, jack) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1::null_backend"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1, null_backend) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_context__bindgen_ty_2 { ++ pub posix: ma_context__bindgen_ty_2__bindgen_ty_1, ++ pub _unused: core::ffi::c_int, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context__bindgen_ty_2__bindgen_ty_1 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context__bindgen_ty_2__bindgen_ty_1::_unused"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_2__bindgen_ty_1, _unused) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_2"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context__bindgen_ty_2"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context__bindgen_ty_2::posix"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_2, posix) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_2::_unused"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_2, _unused) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context"][::core::mem::size_of::() - 1056usize]; ++ ["Alignment of ma_context"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context::callbacks"] ++ [::core::mem::offset_of!(ma_context, callbacks) - 0usize]; ++ ["Offset of field: ma_context::backend"] ++ [::core::mem::offset_of!(ma_context, backend) - 104usize]; ++ ["Offset of field: ma_context::pLog"][::core::mem::offset_of!(ma_context, pLog) - 112usize]; ++ ["Offset of field: ma_context::log"][::core::mem::offset_of!(ma_context, log) - 120usize]; ++ ["Offset of field: ma_context::threadPriority"] ++ [::core::mem::offset_of!(ma_context, threadPriority) - 272usize]; ++ ["Offset of field: ma_context::threadStackSize"] ++ [::core::mem::offset_of!(ma_context, threadStackSize) - 280usize]; ++ ["Offset of field: ma_context::pUserData"] ++ [::core::mem::offset_of!(ma_context, pUserData) - 288usize]; ++ ["Offset of field: ma_context::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_context, allocationCallbacks) - 296usize]; ++ ["Offset of field: ma_context::deviceEnumLock"] ++ [::core::mem::offset_of!(ma_context, deviceEnumLock) - 328usize]; ++ ["Offset of field: ma_context::deviceInfoLock"] ++ [::core::mem::offset_of!(ma_context, deviceInfoLock) - 376usize]; ++ ["Offset of field: ma_context::deviceInfoCapacity"] ++ [::core::mem::offset_of!(ma_context, deviceInfoCapacity) - 424usize]; ++ ["Offset of field: ma_context::playbackDeviceInfoCount"] ++ [::core::mem::offset_of!(ma_context, playbackDeviceInfoCount) - 428usize]; ++ ["Offset of field: ma_context::captureDeviceInfoCount"] ++ [::core::mem::offset_of!(ma_context, captureDeviceInfoCount) - 432usize]; ++ ["Offset of field: ma_context::pDeviceInfos"] ++ [::core::mem::offset_of!(ma_context, pDeviceInfos) - 440usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device { ++ pub pContext: *mut ma_context, ++ pub type_: ma_device_type, ++ pub sampleRate: ma_uint32, ++ pub state: ma_atomic_device_state, ++ pub onData: ma_device_data_proc, ++ pub onNotification: ma_device_notification_proc, ++ pub onStop: ma_stop_proc, ++ pub pUserData: *mut core::ffi::c_void, ++ pub startStopLock: ma_mutex, ++ pub wakeupEvent: ma_event, ++ pub startEvent: ma_event, ++ pub stopEvent: ma_event, ++ pub thread: ma_thread, ++ pub workResult: ma_result, ++ pub isOwnerOfContext: ma_bool8, ++ pub noPreSilencedOutputBuffer: ma_bool8, ++ pub noClip: ma_bool8, ++ pub noDisableDenormals: ma_bool8, ++ pub noFixedSizedCallback: ma_bool8, ++ pub masterVolumeFactor: ma_atomic_float, ++ pub duplexRB: ma_duplex_rb, ++ pub resampling: ma_device__bindgen_ty_1, ++ pub playback: ma_device__bindgen_ty_2, ++ pub capture: ma_device__bindgen_ty_3, ++ pub __bindgen_anon_1: ma_device__bindgen_ty_4, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_1 { ++ pub algorithm: ma_resample_algorithm, ++ pub pBackendVTable: *mut ma_resampling_backend_vtable, ++ pub pBackendUserData: *mut core::ffi::c_void, ++ pub linear: ma_device__bindgen_ty_1__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_1__bindgen_ty_1 { ++ pub lpfOrder: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device__bindgen_ty_1__bindgen_ty_1::lpfOrder"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1__bindgen_ty_1, lpfOrder) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_1"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_device__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_1::algorithm"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1, algorithm) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_1::pBackendVTable"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1, pBackendVTable) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_1::pBackendUserData"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1, pBackendUserData) - 16usize]; ++ ["Offset of field: ma_device__bindgen_ty_1::linear"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1, linear) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device__bindgen_ty_2 { ++ pub pID: *mut ma_device_id, ++ pub id: ma_device_id, ++ pub name: [core::ffi::c_char; 256usize], ++ pub shareMode: ma_share_mode, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub channelMap: [ma_channel; 254usize], ++ pub internalFormat: ma_format, ++ pub internalChannels: ma_uint32, ++ pub internalSampleRate: ma_uint32, ++ pub internalChannelMap: [ma_channel; 254usize], ++ pub internalPeriodSizeInFrames: ma_uint32, ++ pub internalPeriods: ma_uint32, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub converter: ma_data_converter, ++ pub pIntermediaryBuffer: *mut core::ffi::c_void, ++ pub intermediaryBufferCap: ma_uint32, ++ pub intermediaryBufferLen: ma_uint32, ++ pub pInputCache: *mut core::ffi::c_void, ++ pub inputCacheCap: ma_uint64, ++ pub inputCacheConsumed: ma_uint64, ++ pub inputCacheRemaining: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_2"] ++ [::core::mem::size_of::() - 1432usize]; ++ ["Alignment of ma_device__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::pID"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, pID) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::id"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, id) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::name"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, name) - 264usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::shareMode"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, shareMode) - 520usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::format"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, format) - 524usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::channels"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, channels) - 528usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::channelMap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, channelMap) - 532usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalFormat"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalFormat) - 788usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalChannels"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalChannels) - 792usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalSampleRate"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalSampleRate) - 796usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalChannelMap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalChannelMap) - 800usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalPeriodSizeInFrames"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalPeriodSizeInFrames) - 1056usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalPeriods"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalPeriods) - 1060usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::channelMixMode"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, channelMixMode) - 1064usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_2, ++ calculateLFEFromSpatialChannels ++ ) - 1068usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::converter"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, converter) - 1072usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::pIntermediaryBuffer"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, pIntermediaryBuffer) - 1384usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::intermediaryBufferCap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, intermediaryBufferCap) - 1392usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::intermediaryBufferLen"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, intermediaryBufferLen) - 1396usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::pInputCache"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, pInputCache) - 1400usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::inputCacheCap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, inputCacheCap) - 1408usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::inputCacheConsumed"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, inputCacheConsumed) - 1416usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::inputCacheRemaining"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, inputCacheRemaining) - 1424usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device__bindgen_ty_3 { ++ pub pID: *mut ma_device_id, ++ pub id: ma_device_id, ++ pub name: [core::ffi::c_char; 256usize], ++ pub shareMode: ma_share_mode, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub channelMap: [ma_channel; 254usize], ++ pub internalFormat: ma_format, ++ pub internalChannels: ma_uint32, ++ pub internalSampleRate: ma_uint32, ++ pub internalChannelMap: [ma_channel; 254usize], ++ pub internalPeriodSizeInFrames: ma_uint32, ++ pub internalPeriods: ma_uint32, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub converter: ma_data_converter, ++ pub pIntermediaryBuffer: *mut core::ffi::c_void, ++ pub intermediaryBufferCap: ma_uint32, ++ pub intermediaryBufferLen: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_3"] ++ [::core::mem::size_of::() - 1400usize]; ++ ["Alignment of ma_device__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::pID"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, pID) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::id"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, id) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::name"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, name) - 264usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::shareMode"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, shareMode) - 520usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::format"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, format) - 524usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::channels"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, channels) - 528usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::channelMap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, channelMap) - 532usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalFormat"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalFormat) - 788usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalChannels"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalChannels) - 792usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalSampleRate"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalSampleRate) - 796usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalChannelMap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalChannelMap) - 800usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalPeriodSizeInFrames"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalPeriodSizeInFrames) - 1056usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalPeriods"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalPeriods) - 1060usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::channelMixMode"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, channelMixMode) - 1064usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_3, ++ calculateLFEFromSpatialChannels ++ ) - 1068usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::converter"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, converter) - 1072usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::pIntermediaryBuffer"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, pIntermediaryBuffer) - 1384usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::intermediaryBufferCap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, intermediaryBufferCap) - 1392usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::intermediaryBufferLen"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, intermediaryBufferLen) - 1396usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_device__bindgen_ty_4 { ++ pub alsa: ma_device__bindgen_ty_4__bindgen_ty_1, ++ pub pulse: ma_device__bindgen_ty_4__bindgen_ty_2, ++ pub jack: ma_device__bindgen_ty_4__bindgen_ty_3, ++ pub null_device: ma_device__bindgen_ty_4__bindgen_ty_4, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_4__bindgen_ty_1 { ++ pub pPCMPlayback: ma_ptr, ++ pub pPCMCapture: ma_ptr, ++ pub pPollDescriptorsPlayback: *mut core::ffi::c_void, ++ pub pPollDescriptorsCapture: *mut core::ffi::c_void, ++ pub pollDescriptorCountPlayback: core::ffi::c_int, ++ pub pollDescriptorCountCapture: core::ffi::c_int, ++ pub wakeupfdPlayback: core::ffi::c_int, ++ pub wakeupfdCapture: core::ffi::c_int, ++ pub isUsingMMapPlayback: ma_bool8, ++ pub isUsingMMapCapture: ma_bool8, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4__bindgen_ty_1"] ++ [::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_device__bindgen_ty_4__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pPCMPlayback"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_1, pPCMPlayback) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pPCMCapture"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_1, pPCMCapture) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pPollDescriptorsPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ pPollDescriptorsPlayback ++ ) ++ - 16usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pPollDescriptorsCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ pPollDescriptorsCapture ++ ) ++ - 24usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pollDescriptorCountPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ pollDescriptorCountPlayback ++ ) ++ - 32usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pollDescriptorCountCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ pollDescriptorCountCapture ++ ) ++ - 36usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::wakeupfdPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ wakeupfdPlayback ++ ) - 40usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::wakeupfdCapture"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_1, wakeupfdCapture) - 44usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::isUsingMMapPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ isUsingMMapPlayback ++ ) - 48usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::isUsingMMapCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ isUsingMMapCapture ++ ) - 49usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_4__bindgen_ty_2 { ++ pub pMainLoop: ma_ptr, ++ pub pPulseContext: ma_ptr, ++ pub pStreamPlayback: ma_ptr, ++ pub pStreamCapture: ma_ptr, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4__bindgen_ty_2"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_device__bindgen_ty_4__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_2::pMainLoop"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_2, pMainLoop) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_2::pPulseContext"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_2, pPulseContext) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_2::pStreamPlayback"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_2, pStreamPlayback) - 16usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_2::pStreamCapture"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_2, pStreamCapture) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_4__bindgen_ty_3 { ++ pub pClient: ma_ptr, ++ pub ppPortsPlayback: *mut ma_ptr, ++ pub ppPortsCapture: *mut ma_ptr, ++ pub pIntermediaryBufferPlayback: *mut f32, ++ pub pIntermediaryBufferCapture: *mut f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4__bindgen_ty_3"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_device__bindgen_ty_4__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::pClient"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_3, pClient) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::ppPortsPlayback"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_3, ppPortsPlayback) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::ppPortsCapture"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_3, ppPortsCapture) - 16usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::pIntermediaryBufferPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_3, ++ pIntermediaryBufferPlayback ++ ) ++ - 24usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::pIntermediaryBufferCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_3, ++ pIntermediaryBufferCapture ++ ) ++ - 32usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device__bindgen_ty_4__bindgen_ty_4 { ++ pub deviceThread: ma_thread, ++ pub operationEvent: ma_event, ++ pub operationCompletionEvent: ma_event, ++ pub operationSemaphore: ma_semaphore, ++ pub operation: ma_uint32, ++ pub operationResult: ma_result, ++ pub timer: ma_timer, ++ pub priorRunTime: f64, ++ pub currentPeriodFramesRemainingPlayback: ma_uint32, ++ pub currentPeriodFramesRemainingCapture: ma_uint32, ++ pub lastProcessedFramePlayback: ma_uint64, ++ pub lastProcessedFrameCapture: ma_uint64, ++ pub isStarted: ma_atomic_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4__bindgen_ty_4"] ++ [::core::mem::size_of::() - 376usize]; ++ ["Alignment of ma_device__bindgen_ty_4__bindgen_ty_4"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::deviceThread"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, deviceThread) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operationEvent"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, operationEvent) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operationCompletionEvent"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ operationCompletionEvent ++ ) ++ - 112usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operationSemaphore"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ operationSemaphore ++ ) - 216usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operation"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, operation) - 320usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operationResult"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ operationResult ++ ) - 324usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::timer"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, timer) - 328usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::priorRunTime"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, priorRunTime) - 336usize]; ++ [ ++ "Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::currentPeriodFramesRemainingPlayback", ++ ][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ currentPeriodFramesRemainingPlayback ++ ) - 344usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::currentPeriodFramesRemainingCapture"] ++ [::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ currentPeriodFramesRemainingCapture ++ ) - 348usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::lastProcessedFramePlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ lastProcessedFramePlayback ++ ) ++ - 352usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::lastProcessedFrameCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ lastProcessedFrameCapture ++ ) ++ - 360usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::isStarted"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, isStarted) - 368usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4"] ++ [::core::mem::size_of::() - 376usize]; ++ ["Alignment of ma_device__bindgen_ty_4"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4::alsa"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4, alsa) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4::pulse"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4, pulse) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4::jack"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4, jack) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4::null_device"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4, null_device) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device"][::core::mem::size_of::() - 3832usize]; ++ ["Alignment of ma_device"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device::pContext"][::core::mem::offset_of!(ma_device, pContext) - 0usize]; ++ ["Offset of field: ma_device::type_"][::core::mem::offset_of!(ma_device, type_) - 8usize]; ++ ["Offset of field: ma_device::sampleRate"] ++ [::core::mem::offset_of!(ma_device, sampleRate) - 12usize]; ++ ["Offset of field: ma_device::state"][::core::mem::offset_of!(ma_device, state) - 16usize]; ++ ["Offset of field: ma_device::onData"][::core::mem::offset_of!(ma_device, onData) - 24usize]; ++ ["Offset of field: ma_device::onNotification"] ++ [::core::mem::offset_of!(ma_device, onNotification) - 32usize]; ++ ["Offset of field: ma_device::onStop"][::core::mem::offset_of!(ma_device, onStop) - 40usize]; ++ ["Offset of field: ma_device::pUserData"] ++ [::core::mem::offset_of!(ma_device, pUserData) - 48usize]; ++ ["Offset of field: ma_device::startStopLock"] ++ [::core::mem::offset_of!(ma_device, startStopLock) - 56usize]; ++ ["Offset of field: ma_device::wakeupEvent"] ++ [::core::mem::offset_of!(ma_device, wakeupEvent) - 104usize]; ++ ["Offset of field: ma_device::startEvent"] ++ [::core::mem::offset_of!(ma_device, startEvent) - 208usize]; ++ ["Offset of field: ma_device::stopEvent"] ++ [::core::mem::offset_of!(ma_device, stopEvent) - 312usize]; ++ ["Offset of field: ma_device::thread"][::core::mem::offset_of!(ma_device, thread) - 416usize]; ++ ["Offset of field: ma_device::workResult"] ++ [::core::mem::offset_of!(ma_device, workResult) - 424usize]; ++ ["Offset of field: ma_device::isOwnerOfContext"] ++ [::core::mem::offset_of!(ma_device, isOwnerOfContext) - 428usize]; ++ ["Offset of field: ma_device::noPreSilencedOutputBuffer"] ++ [::core::mem::offset_of!(ma_device, noPreSilencedOutputBuffer) - 429usize]; ++ ["Offset of field: ma_device::noClip"][::core::mem::offset_of!(ma_device, noClip) - 430usize]; ++ ["Offset of field: ma_device::noDisableDenormals"] ++ [::core::mem::offset_of!(ma_device, noDisableDenormals) - 431usize]; ++ ["Offset of field: ma_device::noFixedSizedCallback"] ++ [::core::mem::offset_of!(ma_device, noFixedSizedCallback) - 432usize]; ++ ["Offset of field: ma_device::masterVolumeFactor"] ++ [::core::mem::offset_of!(ma_device, masterVolumeFactor) - 436usize]; ++ ["Offset of field: ma_device::duplexRB"] ++ [::core::mem::offset_of!(ma_device, duplexRB) - 440usize]; ++ ["Offset of field: ma_device::resampling"] ++ [::core::mem::offset_of!(ma_device, resampling) - 592usize]; ++ ["Offset of field: ma_device::playback"] ++ [::core::mem::offset_of!(ma_device, playback) - 624usize]; ++ ["Offset of field: ma_device::capture"] ++ [::core::mem::offset_of!(ma_device, capture) - 2056usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_context_config_init() -> ma_context_config; ++} ++unsafe extern "C" { ++ pub fn ma_context_init( ++ backends: *const ma_backend, ++ backendCount: ma_uint32, ++ pConfig: *const ma_context_config, ++ pContext: *mut ma_context, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_uninit(pContext: *mut ma_context) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_sizeof() -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_context_get_log(pContext: *mut ma_context) -> *mut ma_log; ++} ++unsafe extern "C" { ++ pub fn ma_context_enumerate_devices( ++ pContext: *mut ma_context, ++ callback: ma_enum_devices_callback_proc, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_get_devices( ++ pContext: *mut ma_context, ++ ppPlaybackDeviceInfos: *mut *mut ma_device_info, ++ pPlaybackDeviceCount: *mut ma_uint32, ++ ppCaptureDeviceInfos: *mut *mut ma_device_info, ++ pCaptureDeviceCount: *mut ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_get_device_info( ++ pContext: *mut ma_context, ++ deviceType: ma_device_type, ++ pDeviceID: *const ma_device_id, ++ pDeviceInfo: *mut ma_device_info, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_is_loopback_supported(pContext: *mut ma_context) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_device_config_init(deviceType: ma_device_type) -> ma_device_config; ++} ++unsafe extern "C" { ++ pub fn ma_device_init( ++ pContext: *mut ma_context, ++ pConfig: *const ma_device_config, ++ pDevice: *mut ma_device, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_init_ex( ++ backends: *const ma_backend, ++ backendCount: ma_uint32, ++ pContextConfig: *const ma_context_config, ++ pConfig: *const ma_device_config, ++ pDevice: *mut ma_device, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_uninit(pDevice: *mut ma_device); ++} ++unsafe extern "C" { ++ pub fn ma_device_get_context(pDevice: *mut ma_device) -> *mut ma_context; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_log(pDevice: *mut ma_device) -> *mut ma_log; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_info( ++ pDevice: *mut ma_device, ++ type_: ma_device_type, ++ pDeviceInfo: *mut ma_device_info, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_name( ++ pDevice: *mut ma_device, ++ type_: ma_device_type, ++ pName: *mut core::ffi::c_char, ++ nameCap: usize, ++ pLengthNotIncludingNullTerminator: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_start(pDevice: *mut ma_device) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_stop(pDevice: *mut ma_device) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_is_started(pDevice: *const ma_device) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_state(pDevice: *const ma_device) -> ma_device_state; ++} ++unsafe extern "C" { ++ pub fn ma_device_post_init( ++ pDevice: *mut ma_device, ++ deviceType: ma_device_type, ++ pPlaybackDescriptor: *const ma_device_descriptor, ++ pCaptureDescriptor: *const ma_device_descriptor, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_set_master_volume(pDevice: *mut ma_device, volume: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_master_volume(pDevice: *mut ma_device, pVolume: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_set_master_volume_db(pDevice: *mut ma_device, gainDB: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_master_volume_db(pDevice: *mut ma_device, pGainDB: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_handle_backend_data_callback( ++ pDevice: *mut ma_device, ++ pOutput: *mut core::ffi::c_void, ++ pInput: *const core::ffi::c_void, ++ frameCount: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_calculate_buffer_size_in_frames_from_descriptor( ++ pDescriptor: *const ma_device_descriptor, ++ nativeSampleRate: ma_uint32, ++ performanceProfile: ma_performance_profile, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_get_backend_name(backend: ma_backend) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ma_get_backend_from_name( ++ pBackendName: *const core::ffi::c_char, ++ pBackend: *mut ma_backend, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_is_backend_enabled(backend: ma_backend) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_get_enabled_backends( ++ pBackends: *mut ma_backend, ++ backendCap: usize, ++ pBackendCount: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_is_loopback_supported(backend: ma_backend) -> ma_bool32; ++} ++unsafe extern "C" { ++ #[doc = "Utilities"] ++ pub fn ma_calculate_buffer_size_in_milliseconds_from_frames( ++ bufferSizeInFrames: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_calculate_buffer_size_in_frames_from_milliseconds( ++ bufferSizeInMilliseconds: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_copy_pcm_frames( ++ dst: *mut core::ffi::c_void, ++ src: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_silence_pcm_frames( ++ p: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_offset_pcm_frames_ptr( ++ p: *mut core::ffi::c_void, ++ offsetInFrames: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_offset_pcm_frames_const_ptr( ++ p: *const core::ffi::c_void, ++ offsetInFrames: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ) -> *const core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_u8(pDst: *mut ma_uint8, pSrc: *const ma_int16, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_s16(pDst: *mut ma_int16, pSrc: *const ma_int32, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_s24(pDst: *mut ma_uint8, pSrc: *const ma_int64, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_s32(pDst: *mut ma_int32, pSrc: *const ma_int64, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_f32(pDst: *mut f32, pSrc: *const f32, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_pcm_frames( ++ pDst: *mut core::ffi::c_void, ++ pSrc: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_u8( ++ pSamplesOut: *mut ma_uint8, ++ pSamplesIn: *const ma_uint8, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_s16( ++ pSamplesOut: *mut ma_int16, ++ pSamplesIn: *const ma_int16, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_s24( ++ pSamplesOut: *mut core::ffi::c_void, ++ pSamplesIn: *const core::ffi::c_void, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_s32( ++ pSamplesOut: *mut ma_int32, ++ pSamplesIn: *const ma_int32, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_f32( ++ pSamplesOut: *mut f32, ++ pSamplesIn: *const f32, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_u8(pSamples: *mut ma_uint8, sampleCount: ma_uint64, factor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_s16(pSamples: *mut ma_int16, sampleCount: ma_uint64, factor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_s24( ++ pSamples: *mut core::ffi::c_void, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_s32(pSamples: *mut ma_int32, sampleCount: ma_uint64, factor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_f32(pSamples: *mut f32, sampleCount: ma_uint64, factor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_u8( ++ pFramesOut: *mut ma_uint8, ++ pFramesIn: *const ma_uint8, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_s16( ++ pFramesOut: *mut ma_int16, ++ pFramesIn: *const ma_int16, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_s24( ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_s32( ++ pFramesOut: *mut ma_int32, ++ pFramesIn: *const ma_int32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_f32( ++ pFramesOut: *mut f32, ++ pFramesIn: *const f32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames( ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_u8( ++ pFrames: *mut ma_uint8, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_s16( ++ pFrames: *mut ma_int16, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_s24( ++ pFrames: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_s32( ++ pFrames: *mut ma_int32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_f32( ++ pFrames: *mut f32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames( ++ pFrames: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_per_channel_f32( ++ pFramesOut: *mut f32, ++ pFramesIn: *const f32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ pChannelGains: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_u8( ++ pDst: *mut ma_uint8, ++ pSrc: *const ma_int16, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_s16( ++ pDst: *mut ma_int16, ++ pSrc: *const ma_int32, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_s24( ++ pDst: *mut ma_uint8, ++ pSrc: *const ma_int64, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_s32( ++ pDst: *mut ma_int32, ++ pSrc: *const ma_int64, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_f32( ++ pDst: *mut f32, ++ pSrc: *const f32, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_pcm_frames( ++ pDst: *mut core::ffi::c_void, ++ pSrc: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_volume_linear_to_db(factor: f32) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_volume_db_to_linear(gain: f32) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_mix_pcm_frames_f32( ++ pDst: *mut f32, ++ pSrc: *const f32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ volume: f32, ++ ) -> ma_result; ++} ++#[doc = "VFS\n===\n\nThe VFS object (virtual file system) is what's used to customize file access. This is useful in cases where stdio FILE* based APIs may not be entirely\nappropriate for a given situation."] ++pub type ma_vfs = core::ffi::c_void; ++pub type ma_vfs_file = ma_handle; ++pub const ma_open_mode_flags_MA_OPEN_MODE_READ: ma_open_mode_flags = 1; ++pub const ma_open_mode_flags_MA_OPEN_MODE_WRITE: ma_open_mode_flags = 2; ++pub type ma_open_mode_flags = core::ffi::c_uint; ++pub const ma_seek_origin_ma_seek_origin_start: ma_seek_origin = 0; ++pub const ma_seek_origin_ma_seek_origin_current: ma_seek_origin = 1; ++pub const ma_seek_origin_ma_seek_origin_end: ma_seek_origin = 2; ++pub type ma_seek_origin = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_file_info { ++ pub sizeInBytes: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_file_info"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_file_info"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_file_info::sizeInBytes"] ++ [::core::mem::offset_of!(ma_file_info, sizeInBytes) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_vfs_callbacks { ++ pub onOpen: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ openMode: ma_uint32, ++ pFile: *mut ma_vfs_file, ++ ) -> ma_result, ++ >, ++ pub onOpenW: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const wchar_t, ++ openMode: ma_uint32, ++ pFile: *mut ma_vfs_file, ++ ) -> ma_result, ++ >, ++ pub onClose: ::core::option::Option< ++ unsafe extern "C" fn(pVFS: *mut ma_vfs, file: ma_vfs_file) -> ma_result, ++ >, ++ pub onRead: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pDst: *mut core::ffi::c_void, ++ sizeInBytes: usize, ++ pBytesRead: *mut usize, ++ ) -> ma_result, ++ >, ++ pub onWrite: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pSrc: *const core::ffi::c_void, ++ sizeInBytes: usize, ++ pBytesWritten: *mut usize, ++ ) -> ma_result, ++ >, ++ pub onSeek: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ offset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result, ++ >, ++ pub onTell: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pCursor: *mut ma_int64, ++ ) -> ma_result, ++ >, ++ pub onInfo: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pInfo: *mut ma_file_info, ++ ) -> ma_result, ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_vfs_callbacks"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_vfs_callbacks"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_vfs_callbacks::onOpen"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onOpen) - 0usize]; ++ ["Offset of field: ma_vfs_callbacks::onOpenW"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onOpenW) - 8usize]; ++ ["Offset of field: ma_vfs_callbacks::onClose"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onClose) - 16usize]; ++ ["Offset of field: ma_vfs_callbacks::onRead"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onRead) - 24usize]; ++ ["Offset of field: ma_vfs_callbacks::onWrite"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onWrite) - 32usize]; ++ ["Offset of field: ma_vfs_callbacks::onSeek"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onSeek) - 40usize]; ++ ["Offset of field: ma_vfs_callbacks::onTell"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onTell) - 48usize]; ++ ["Offset of field: ma_vfs_callbacks::onInfo"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onInfo) - 56usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_vfs_open( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ openMode: ma_uint32, ++ pFile: *mut ma_vfs_file, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_open_w( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const wchar_t, ++ openMode: ma_uint32, ++ pFile: *mut ma_vfs_file, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_close(pVFS: *mut ma_vfs, file: ma_vfs_file) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_read( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pDst: *mut core::ffi::c_void, ++ sizeInBytes: usize, ++ pBytesRead: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_write( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pSrc: *const core::ffi::c_void, ++ sizeInBytes: usize, ++ pBytesWritten: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_seek( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ offset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_tell(pVFS: *mut ma_vfs, file: ma_vfs_file, pCursor: *mut ma_int64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_info(pVFS: *mut ma_vfs, file: ma_vfs_file, pInfo: *mut ma_file_info) ++ -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_open_and_read_file( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ ppData: *mut *mut core::ffi::c_void, ++ pSize: *mut usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_default_vfs { ++ pub cb: ma_vfs_callbacks, ++ pub allocationCallbacks: ma_allocation_callbacks, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_default_vfs"][::core::mem::size_of::() - 96usize]; ++ ["Alignment of ma_default_vfs"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_default_vfs::cb"][::core::mem::offset_of!(ma_default_vfs, cb) - 0usize]; ++ ["Offset of field: ma_default_vfs::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_default_vfs, allocationCallbacks) - 64usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_default_vfs_init( ++ pVFS: *mut ma_default_vfs, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_result; ++} ++pub type ma_read_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBufferOut: *mut core::ffi::c_void, ++ bytesToRead: usize, ++ pBytesRead: *mut usize, ++ ) -> ma_result, ++>; ++pub type ma_seek_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ offset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result, ++>; ++pub type ma_tell_proc = ::core::option::Option< ++ unsafe extern "C" fn(pUserData: *mut core::ffi::c_void, pCursor: *mut ma_int64) -> ma_result, ++>; ++pub const ma_encoding_format_ma_encoding_format_unknown: ma_encoding_format = 0; ++pub const ma_encoding_format_ma_encoding_format_wav: ma_encoding_format = 1; ++pub const ma_encoding_format_ma_encoding_format_flac: ma_encoding_format = 2; ++pub const ma_encoding_format_ma_encoding_format_mp3: ma_encoding_format = 3; ++pub const ma_encoding_format_ma_encoding_format_vorbis: ma_encoding_format = 4; ++pub type ma_encoding_format = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoding_backend_config { ++ pub preferredFormat: ma_format, ++ pub seekPointCount: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoding_backend_config"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_decoding_backend_config"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_decoding_backend_config::preferredFormat"] ++ [::core::mem::offset_of!(ma_decoding_backend_config, preferredFormat) - 0usize]; ++ ["Offset of field: ma_decoding_backend_config::seekPointCount"] ++ [::core::mem::offset_of!(ma_decoding_backend_config, seekPointCount) - 4usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_decoding_backend_config_init( ++ preferredFormat: ma_format, ++ seekPointCount: ma_uint32, ++ ) -> ma_decoding_backend_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoding_backend_vtable { ++ pub onInit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ onRead: ma_read_proc, ++ onSeek: ma_seek_proc, ++ onTell: ma_tell_proc, ++ pReadSeekTellUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_decoding_backend_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppBackend: *mut *mut ma_data_source, ++ ) -> ma_result, ++ >, ++ pub onInitFile: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_decoding_backend_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppBackend: *mut *mut ma_data_source, ++ ) -> ma_result, ++ >, ++ pub onInitFileW: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_decoding_backend_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppBackend: *mut *mut ma_data_source, ++ ) -> ma_result, ++ >, ++ pub onInitMemory: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pData: *const core::ffi::c_void, ++ dataSize: usize, ++ pConfig: *const ma_decoding_backend_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppBackend: *mut *mut ma_data_source, ++ ) -> ma_result, ++ >, ++ pub onUninit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_data_source, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ), ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoding_backend_vtable"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_decoding_backend_vtable"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onInit"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onInit) - 0usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onInitFile"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onInitFile) - 8usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onInitFileW"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onInitFileW) - 16usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onInitMemory"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onInitMemory) - 24usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onUninit"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onUninit) - 32usize]; ++}; ++pub type ma_decoder_read_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pDecoder: *mut ma_decoder, ++ pBufferOut: *mut core::ffi::c_void, ++ bytesToRead: usize, ++ pBytesRead: *mut usize, ++ ) -> ma_result, ++>; ++pub type ma_decoder_seek_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pDecoder: *mut ma_decoder, ++ byteOffset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result, ++>; ++pub type ma_decoder_tell_proc = ::core::option::Option< ++ unsafe extern "C" fn(pDecoder: *mut ma_decoder, pCursor: *mut ma_int64) -> ma_result, ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoder_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub pChannelMap: *mut ma_channel, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub ditherMode: ma_dither_mode, ++ pub resampling: ma_resampler_config, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub encodingFormat: ma_encoding_format, ++ pub seekPointCount: ma_uint32, ++ pub ppCustomBackendVTables: *mut *mut ma_decoding_backend_vtable, ++ pub customBackendCount: ma_uint32, ++ pub pCustomBackendUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder_config"][::core::mem::size_of::() - 144usize]; ++ ["Alignment of ma_decoder_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder_config::format"] ++ [::core::mem::offset_of!(ma_decoder_config, format) - 0usize]; ++ ["Offset of field: ma_decoder_config::channels"] ++ [::core::mem::offset_of!(ma_decoder_config, channels) - 4usize]; ++ ["Offset of field: ma_decoder_config::sampleRate"] ++ [::core::mem::offset_of!(ma_decoder_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_decoder_config::pChannelMap"] ++ [::core::mem::offset_of!(ma_decoder_config, pChannelMap) - 16usize]; ++ ["Offset of field: ma_decoder_config::channelMixMode"] ++ [::core::mem::offset_of!(ma_decoder_config, channelMixMode) - 24usize]; ++ ["Offset of field: ma_decoder_config::ditherMode"] ++ [::core::mem::offset_of!(ma_decoder_config, ditherMode) - 28usize]; ++ ["Offset of field: ma_decoder_config::resampling"] ++ [::core::mem::offset_of!(ma_decoder_config, resampling) - 32usize]; ++ ["Offset of field: ma_decoder_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_decoder_config, allocationCallbacks) - 80usize]; ++ ["Offset of field: ma_decoder_config::encodingFormat"] ++ [::core::mem::offset_of!(ma_decoder_config, encodingFormat) - 112usize]; ++ ["Offset of field: ma_decoder_config::seekPointCount"] ++ [::core::mem::offset_of!(ma_decoder_config, seekPointCount) - 116usize]; ++ ["Offset of field: ma_decoder_config::ppCustomBackendVTables"] ++ [::core::mem::offset_of!(ma_decoder_config, ppCustomBackendVTables) - 120usize]; ++ ["Offset of field: ma_decoder_config::customBackendCount"] ++ [::core::mem::offset_of!(ma_decoder_config, customBackendCount) - 128usize]; ++ ["Offset of field: ma_decoder_config::pCustomBackendUserData"] ++ [::core::mem::offset_of!(ma_decoder_config, pCustomBackendUserData) - 136usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_decoder { ++ pub ds: ma_data_source_base, ++ pub pBackend: *mut ma_data_source, ++ pub pBackendVTable: *const ma_decoding_backend_vtable, ++ pub pBackendUserData: *mut core::ffi::c_void, ++ pub onRead: ma_decoder_read_proc, ++ pub onSeek: ma_decoder_seek_proc, ++ pub onTell: ma_decoder_tell_proc, ++ pub pUserData: *mut core::ffi::c_void, ++ pub readPointerInPCMFrames: ma_uint64, ++ pub outputFormat: ma_format, ++ pub outputChannels: ma_uint32, ++ pub outputSampleRate: ma_uint32, ++ pub converter: ma_data_converter, ++ pub pInputCache: *mut core::ffi::c_void, ++ pub inputCacheCap: ma_uint64, ++ pub inputCacheConsumed: ma_uint64, ++ pub inputCacheRemaining: ma_uint64, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub data: ma_decoder__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_decoder__bindgen_ty_1 { ++ pub vfs: ma_decoder__bindgen_ty_1__bindgen_ty_1, ++ pub memory: ma_decoder__bindgen_ty_1__bindgen_ty_2, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoder__bindgen_ty_1__bindgen_ty_1 { ++ pub pVFS: *mut ma_vfs, ++ pub file: ma_vfs_file, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_decoder__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_1::pVFS"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_1, pVFS) - 0usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_1::file"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_1, file) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoder__bindgen_ty_1__bindgen_ty_2 { ++ pub pData: *const ma_uint8, ++ pub dataSize: usize, ++ pub currentReadPos: usize, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_decoder__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_2::pData"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_2, pData) - 0usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_2::dataSize"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_2, dataSize) - 8usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_2::currentReadPos"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_2, currentReadPos) - 16usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder__bindgen_ty_1"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_decoder__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1::vfs"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1, vfs) - 0usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1::memory"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1, memory) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder"][::core::mem::size_of::() - 552usize]; ++ ["Alignment of ma_decoder"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder::ds"][::core::mem::offset_of!(ma_decoder, ds) - 0usize]; ++ ["Offset of field: ma_decoder::pBackend"] ++ [::core::mem::offset_of!(ma_decoder, pBackend) - 72usize]; ++ ["Offset of field: ma_decoder::pBackendVTable"] ++ [::core::mem::offset_of!(ma_decoder, pBackendVTable) - 80usize]; ++ ["Offset of field: ma_decoder::pBackendUserData"] ++ [::core::mem::offset_of!(ma_decoder, pBackendUserData) - 88usize]; ++ ["Offset of field: ma_decoder::onRead"][::core::mem::offset_of!(ma_decoder, onRead) - 96usize]; ++ ["Offset of field: ma_decoder::onSeek"][::core::mem::offset_of!(ma_decoder, onSeek) - 104usize]; ++ ["Offset of field: ma_decoder::onTell"][::core::mem::offset_of!(ma_decoder, onTell) - 112usize]; ++ ["Offset of field: ma_decoder::pUserData"] ++ [::core::mem::offset_of!(ma_decoder, pUserData) - 120usize]; ++ ["Offset of field: ma_decoder::readPointerInPCMFrames"] ++ [::core::mem::offset_of!(ma_decoder, readPointerInPCMFrames) - 128usize]; ++ ["Offset of field: ma_decoder::outputFormat"] ++ [::core::mem::offset_of!(ma_decoder, outputFormat) - 136usize]; ++ ["Offset of field: ma_decoder::outputChannels"] ++ [::core::mem::offset_of!(ma_decoder, outputChannels) - 140usize]; ++ ["Offset of field: ma_decoder::outputSampleRate"] ++ [::core::mem::offset_of!(ma_decoder, outputSampleRate) - 144usize]; ++ ["Offset of field: ma_decoder::converter"] ++ [::core::mem::offset_of!(ma_decoder, converter) - 152usize]; ++ ["Offset of field: ma_decoder::pInputCache"] ++ [::core::mem::offset_of!(ma_decoder, pInputCache) - 464usize]; ++ ["Offset of field: ma_decoder::inputCacheCap"] ++ [::core::mem::offset_of!(ma_decoder, inputCacheCap) - 472usize]; ++ ["Offset of field: ma_decoder::inputCacheConsumed"] ++ [::core::mem::offset_of!(ma_decoder, inputCacheConsumed) - 480usize]; ++ ["Offset of field: ma_decoder::inputCacheRemaining"] ++ [::core::mem::offset_of!(ma_decoder, inputCacheRemaining) - 488usize]; ++ ["Offset of field: ma_decoder::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_decoder, allocationCallbacks) - 496usize]; ++ ["Offset of field: ma_decoder::data"][::core::mem::offset_of!(ma_decoder, data) - 528usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_decoder_config_init( ++ outputFormat: ma_format, ++ outputChannels: ma_uint32, ++ outputSampleRate: ma_uint32, ++ ) -> ma_decoder_config; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_config_init_default() -> ma_decoder_config; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init( ++ onRead: ma_decoder_read_proc, ++ onSeek: ma_decoder_seek_proc, ++ pUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_memory( ++ pData: *const core::ffi::c_void, ++ dataSize: usize, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_vfs( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_vfs_w( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_file( ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_file_w( ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_uninit(pDecoder: *mut ma_decoder) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_read_pcm_frames( ++ pDecoder: *mut ma_decoder, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_seek_to_pcm_frame( ++ pDecoder: *mut ma_decoder, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_get_data_format( ++ pDecoder: *mut ma_decoder, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_get_cursor_in_pcm_frames( ++ pDecoder: *mut ma_decoder, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_get_length_in_pcm_frames( ++ pDecoder: *mut ma_decoder, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_get_available_frames( ++ pDecoder: *mut ma_decoder, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decode_from_vfs( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *mut ma_decoder_config, ++ pFrameCountOut: *mut ma_uint64, ++ ppPCMFramesOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decode_file( ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *mut ma_decoder_config, ++ pFrameCountOut: *mut ma_uint64, ++ ppPCMFramesOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decode_memory( ++ pData: *const core::ffi::c_void, ++ dataSize: usize, ++ pConfig: *mut ma_decoder_config, ++ pFrameCountOut: *mut ma_uint64, ++ ppPCMFramesOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++pub type ma_encoder_write_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pEncoder: *mut ma_encoder, ++ pBufferIn: *const core::ffi::c_void, ++ bytesToWrite: usize, ++ pBytesWritten: *mut usize, ++ ) -> ma_result, ++>; ++pub type ma_encoder_seek_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pEncoder: *mut ma_encoder, ++ offset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result, ++>; ++pub type ma_encoder_init_proc = ++ ::core::option::Option ma_result>; ++pub type ma_encoder_uninit_proc = ++ ::core::option::Option; ++pub type ma_encoder_write_pcm_frames_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pEncoder: *mut ma_encoder, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesWritten: *mut ma_uint64, ++ ) -> ma_result, ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_encoder_config { ++ pub encodingFormat: ma_encoding_format, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub allocationCallbacks: ma_allocation_callbacks, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_encoder_config"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_encoder_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_encoder_config::encodingFormat"] ++ [::core::mem::offset_of!(ma_encoder_config, encodingFormat) - 0usize]; ++ ["Offset of field: ma_encoder_config::format"] ++ [::core::mem::offset_of!(ma_encoder_config, format) - 4usize]; ++ ["Offset of field: ma_encoder_config::channels"] ++ [::core::mem::offset_of!(ma_encoder_config, channels) - 8usize]; ++ ["Offset of field: ma_encoder_config::sampleRate"] ++ [::core::mem::offset_of!(ma_encoder_config, sampleRate) - 12usize]; ++ ["Offset of field: ma_encoder_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_encoder_config, allocationCallbacks) - 16usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_encoder_config_init( ++ encodingFormat: ma_encoding_format, ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_encoder_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_encoder { ++ pub config: ma_encoder_config, ++ pub onWrite: ma_encoder_write_proc, ++ pub onSeek: ma_encoder_seek_proc, ++ pub onInit: ma_encoder_init_proc, ++ pub onUninit: ma_encoder_uninit_proc, ++ pub onWritePCMFrames: ma_encoder_write_pcm_frames_proc, ++ pub pUserData: *mut core::ffi::c_void, ++ pub pInternalEncoder: *mut core::ffi::c_void, ++ pub data: ma_encoder__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_encoder__bindgen_ty_1 { ++ pub vfs: ma_encoder__bindgen_ty_1__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_encoder__bindgen_ty_1__bindgen_ty_1 { ++ pub pVFS: *mut ma_vfs, ++ pub file: ma_vfs_file, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_encoder__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_encoder__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_encoder__bindgen_ty_1__bindgen_ty_1::pVFS"] ++ [::core::mem::offset_of!(ma_encoder__bindgen_ty_1__bindgen_ty_1, pVFS) - 0usize]; ++ ["Offset of field: ma_encoder__bindgen_ty_1__bindgen_ty_1::file"] ++ [::core::mem::offset_of!(ma_encoder__bindgen_ty_1__bindgen_ty_1, file) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_encoder__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_encoder__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_encoder__bindgen_ty_1::vfs"] ++ [::core::mem::offset_of!(ma_encoder__bindgen_ty_1, vfs) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_encoder"][::core::mem::size_of::() - 120usize]; ++ ["Alignment of ma_encoder"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_encoder::config"][::core::mem::offset_of!(ma_encoder, config) - 0usize]; ++ ["Offset of field: ma_encoder::onWrite"] ++ [::core::mem::offset_of!(ma_encoder, onWrite) - 48usize]; ++ ["Offset of field: ma_encoder::onSeek"][::core::mem::offset_of!(ma_encoder, onSeek) - 56usize]; ++ ["Offset of field: ma_encoder::onInit"][::core::mem::offset_of!(ma_encoder, onInit) - 64usize]; ++ ["Offset of field: ma_encoder::onUninit"] ++ [::core::mem::offset_of!(ma_encoder, onUninit) - 72usize]; ++ ["Offset of field: ma_encoder::onWritePCMFrames"] ++ [::core::mem::offset_of!(ma_encoder, onWritePCMFrames) - 80usize]; ++ ["Offset of field: ma_encoder::pUserData"] ++ [::core::mem::offset_of!(ma_encoder, pUserData) - 88usize]; ++ ["Offset of field: ma_encoder::pInternalEncoder"] ++ [::core::mem::offset_of!(ma_encoder, pInternalEncoder) - 96usize]; ++ ["Offset of field: ma_encoder::data"][::core::mem::offset_of!(ma_encoder, data) - 104usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_encoder_init( ++ onWrite: ma_encoder_write_proc, ++ onSeek: ma_encoder_seek_proc, ++ pUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_init_vfs( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_init_vfs_w( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_init_file( ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_init_file_w( ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_uninit(pEncoder: *mut ma_encoder); ++} ++unsafe extern "C" { ++ pub fn ma_encoder_write_pcm_frames( ++ pEncoder: *mut ma_encoder, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesWritten: *mut ma_uint64, ++ ) -> ma_result; ++} ++pub const ma_waveform_type_ma_waveform_type_sine: ma_waveform_type = 0; ++pub const ma_waveform_type_ma_waveform_type_square: ma_waveform_type = 1; ++pub const ma_waveform_type_ma_waveform_type_triangle: ma_waveform_type = 2; ++pub const ma_waveform_type_ma_waveform_type_sawtooth: ma_waveform_type = 3; ++pub type ma_waveform_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_waveform_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub type_: ma_waveform_type, ++ pub amplitude: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_waveform_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_waveform_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_waveform_config::format"] ++ [::core::mem::offset_of!(ma_waveform_config, format) - 0usize]; ++ ["Offset of field: ma_waveform_config::channels"] ++ [::core::mem::offset_of!(ma_waveform_config, channels) - 4usize]; ++ ["Offset of field: ma_waveform_config::sampleRate"] ++ [::core::mem::offset_of!(ma_waveform_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_waveform_config::type_"] ++ [::core::mem::offset_of!(ma_waveform_config, type_) - 12usize]; ++ ["Offset of field: ma_waveform_config::amplitude"] ++ [::core::mem::offset_of!(ma_waveform_config, amplitude) - 16usize]; ++ ["Offset of field: ma_waveform_config::frequency"] ++ [::core::mem::offset_of!(ma_waveform_config, frequency) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_waveform_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ type_: ma_waveform_type, ++ amplitude: f64, ++ frequency: f64, ++ ) -> ma_waveform_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_waveform { ++ pub ds: ma_data_source_base, ++ pub config: ma_waveform_config, ++ pub advance: f64, ++ pub time: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_waveform"][::core::mem::size_of::() - 120usize]; ++ ["Alignment of ma_waveform"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_waveform::ds"][::core::mem::offset_of!(ma_waveform, ds) - 0usize]; ++ ["Offset of field: ma_waveform::config"] ++ [::core::mem::offset_of!(ma_waveform, config) - 72usize]; ++ ["Offset of field: ma_waveform::advance"] ++ [::core::mem::offset_of!(ma_waveform, advance) - 104usize]; ++ ["Offset of field: ma_waveform::time"][::core::mem::offset_of!(ma_waveform, time) - 112usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_waveform_init( ++ pConfig: *const ma_waveform_config, ++ pWaveform: *mut ma_waveform, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_uninit(pWaveform: *mut ma_waveform); ++} ++unsafe extern "C" { ++ pub fn ma_waveform_read_pcm_frames( ++ pWaveform: *mut ma_waveform, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_seek_to_pcm_frame( ++ pWaveform: *mut ma_waveform, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_set_amplitude(pWaveform: *mut ma_waveform, amplitude: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_set_frequency(pWaveform: *mut ma_waveform, frequency: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_set_type(pWaveform: *mut ma_waveform, type_: ma_waveform_type) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_set_sample_rate( ++ pWaveform: *mut ma_waveform, ++ sampleRate: ma_uint32, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_pulsewave_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub dutyCycle: f64, ++ pub amplitude: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_pulsewave_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_pulsewave_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_pulsewave_config::format"] ++ [::core::mem::offset_of!(ma_pulsewave_config, format) - 0usize]; ++ ["Offset of field: ma_pulsewave_config::channels"] ++ [::core::mem::offset_of!(ma_pulsewave_config, channels) - 4usize]; ++ ["Offset of field: ma_pulsewave_config::sampleRate"] ++ [::core::mem::offset_of!(ma_pulsewave_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_pulsewave_config::dutyCycle"] ++ [::core::mem::offset_of!(ma_pulsewave_config, dutyCycle) - 16usize]; ++ ["Offset of field: ma_pulsewave_config::amplitude"] ++ [::core::mem::offset_of!(ma_pulsewave_config, amplitude) - 24usize]; ++ ["Offset of field: ma_pulsewave_config::frequency"] ++ [::core::mem::offset_of!(ma_pulsewave_config, frequency) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_pulsewave_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ dutyCycle: f64, ++ amplitude: f64, ++ frequency: f64, ++ ) -> ma_pulsewave_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_pulsewave { ++ pub waveform: ma_waveform, ++ pub config: ma_pulsewave_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_pulsewave"][::core::mem::size_of::() - 160usize]; ++ ["Alignment of ma_pulsewave"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_pulsewave::waveform"] ++ [::core::mem::offset_of!(ma_pulsewave, waveform) - 0usize]; ++ ["Offset of field: ma_pulsewave::config"] ++ [::core::mem::offset_of!(ma_pulsewave, config) - 120usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_pulsewave_init( ++ pConfig: *const ma_pulsewave_config, ++ pWaveform: *mut ma_pulsewave, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_uninit(pWaveform: *mut ma_pulsewave); ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_read_pcm_frames( ++ pWaveform: *mut ma_pulsewave, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_seek_to_pcm_frame( ++ pWaveform: *mut ma_pulsewave, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_set_amplitude(pWaveform: *mut ma_pulsewave, amplitude: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_set_frequency(pWaveform: *mut ma_pulsewave, frequency: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_set_sample_rate( ++ pWaveform: *mut ma_pulsewave, ++ sampleRate: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_set_duty_cycle(pWaveform: *mut ma_pulsewave, dutyCycle: f64) -> ma_result; ++} ++pub const ma_noise_type_ma_noise_type_white: ma_noise_type = 0; ++pub const ma_noise_type_ma_noise_type_pink: ma_noise_type = 1; ++pub const ma_noise_type_ma_noise_type_brownian: ma_noise_type = 2; ++pub type ma_noise_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_noise_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub type_: ma_noise_type, ++ pub seed: ma_int32, ++ pub amplitude: f64, ++ pub duplicateChannels: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_noise_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise_config::format"] ++ [::core::mem::offset_of!(ma_noise_config, format) - 0usize]; ++ ["Offset of field: ma_noise_config::channels"] ++ [::core::mem::offset_of!(ma_noise_config, channels) - 4usize]; ++ ["Offset of field: ma_noise_config::type_"] ++ [::core::mem::offset_of!(ma_noise_config, type_) - 8usize]; ++ ["Offset of field: ma_noise_config::seed"] ++ [::core::mem::offset_of!(ma_noise_config, seed) - 12usize]; ++ ["Offset of field: ma_noise_config::amplitude"] ++ [::core::mem::offset_of!(ma_noise_config, amplitude) - 16usize]; ++ ["Offset of field: ma_noise_config::duplicateChannels"] ++ [::core::mem::offset_of!(ma_noise_config, duplicateChannels) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_noise_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ type_: ma_noise_type, ++ seed: ma_int32, ++ amplitude: f64, ++ ) -> ma_noise_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_noise { ++ pub ds: ma_data_source_base, ++ pub config: ma_noise_config, ++ pub lcg: ma_lcg, ++ pub state: ma_noise__bindgen_ty_1, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_noise__bindgen_ty_1 { ++ pub pink: ma_noise__bindgen_ty_1__bindgen_ty_1, ++ pub brownian: ma_noise__bindgen_ty_1__bindgen_ty_2, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_noise__bindgen_ty_1__bindgen_ty_1 { ++ pub bin: *mut *mut f64, ++ pub accumulation: *mut f64, ++ pub counter: *mut ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_noise__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1__bindgen_ty_1::bin"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1__bindgen_ty_1, bin) - 0usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1__bindgen_ty_1::accumulation"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1__bindgen_ty_1, accumulation) - 8usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1__bindgen_ty_1::counter"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1__bindgen_ty_1, counter) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_noise__bindgen_ty_1__bindgen_ty_2 { ++ pub accumulation: *mut f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_noise__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1__bindgen_ty_2::accumulation"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1__bindgen_ty_2, accumulation) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise__bindgen_ty_1"][::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_noise__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1::pink"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1, pink) - 0usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1::brownian"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1, brownian) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise"][::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_noise"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise::ds"][::core::mem::offset_of!(ma_noise, ds) - 0usize]; ++ ["Offset of field: ma_noise::config"][::core::mem::offset_of!(ma_noise, config) - 72usize]; ++ ["Offset of field: ma_noise::lcg"][::core::mem::offset_of!(ma_noise, lcg) - 104usize]; ++ ["Offset of field: ma_noise::state"][::core::mem::offset_of!(ma_noise, state) - 112usize]; ++ ["Offset of field: ma_noise::_pHeap"][::core::mem::offset_of!(ma_noise, _pHeap) - 136usize]; ++ ["Offset of field: ma_noise::_ownsHeap"] ++ [::core::mem::offset_of!(ma_noise, _ownsHeap) - 144usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_noise_get_heap_size( ++ pConfig: *const ma_noise_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_init_preallocated( ++ pConfig: *const ma_noise_config, ++ pHeap: *mut core::ffi::c_void, ++ pNoise: *mut ma_noise, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_init( ++ pConfig: *const ma_noise_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNoise: *mut ma_noise, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_uninit( ++ pNoise: *mut ma_noise, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_noise_read_pcm_frames( ++ pNoise: *mut ma_noise, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_set_amplitude(pNoise: *mut ma_noise, amplitude: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_set_seed(pNoise: *mut ma_noise, seed: ma_int32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_set_type(pNoise: *mut ma_noise, type_: ma_noise_type) -> ma_result; ++} ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM: ++ ma_resource_manager_data_source_flags = 1; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE: ++ ma_resource_manager_data_source_flags = 2; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC: ++ ma_resource_manager_data_source_flags = 4; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT: ++ ma_resource_manager_data_source_flags = 8; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH : ma_resource_manager_data_source_flags = 16 ; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING: ++ ma_resource_manager_data_source_flags = 32; ++pub type ma_resource_manager_data_source_flags = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_pipeline_stage_notification { ++ pub pNotification: *mut ma_async_notification, ++ pub pFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_pipeline_stage_notification"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_resource_manager_pipeline_stage_notification"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_pipeline_stage_notification::pNotification"][::core::mem::offset_of!( ++ ma_resource_manager_pipeline_stage_notification, ++ pNotification ++ ) - 0usize]; ++ ["Offset of field: ma_resource_manager_pipeline_stage_notification::pFence"] ++ [::core::mem::offset_of!(ma_resource_manager_pipeline_stage_notification, pFence) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_pipeline_notifications { ++ pub init: ma_resource_manager_pipeline_stage_notification, ++ pub done: ma_resource_manager_pipeline_stage_notification, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_pipeline_notifications"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_resource_manager_pipeline_notifications"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_pipeline_notifications::init"] ++ [::core::mem::offset_of!(ma_resource_manager_pipeline_notifications, init) - 0usize]; ++ ["Offset of field: ma_resource_manager_pipeline_notifications::done"] ++ [::core::mem::offset_of!(ma_resource_manager_pipeline_notifications, done) - 16usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resource_manager_pipeline_notifications_init() ++ -> ma_resource_manager_pipeline_notifications; ++} ++pub const ma_resource_manager_flags_MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING: ++ ma_resource_manager_flags = 1; ++pub const ma_resource_manager_flags_MA_RESOURCE_MANAGER_FLAG_NO_THREADING: ++ ma_resource_manager_flags = 2; ++pub type ma_resource_manager_flags = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_data_source_config { ++ pub pFilePath: *const core::ffi::c_char, ++ pub pFilePathW: *const wchar_t, ++ pub pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pub initialSeekPointInPCMFrames: ma_uint64, ++ pub rangeBegInPCMFrames: ma_uint64, ++ pub rangeEndInPCMFrames: ma_uint64, ++ pub loopPointBegInPCMFrames: ma_uint64, ++ pub loopPointEndInPCMFrames: ma_uint64, ++ pub flags: ma_uint32, ++ pub isLooping: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_source_config"] ++ [::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_resource_manager_data_source_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::pFilePath"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, pFilePath) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::pFilePathW"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, pFilePathW) - 8usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::pNotifications"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, pNotifications) - 16usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::initialSeekPointInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ initialSeekPointInPCMFrames ++ ) ++ - 24usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::rangeBegInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ rangeBegInPCMFrames ++ ) - 32usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::rangeEndInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ rangeEndInPCMFrames ++ ) - 40usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::loopPointBegInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ loopPointBegInPCMFrames ++ ) ++ - 48usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::loopPointEndInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ loopPointEndInPCMFrames ++ ) ++ - 56usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, flags) - 64usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::isLooping"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, isLooping) - 68usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_config_init() -> ma_resource_manager_data_source_config; ++} ++pub const ma_resource_manager_data_supply_type_ma_resource_manager_data_supply_type_unknown: ++ ma_resource_manager_data_supply_type = 0; ++pub const ma_resource_manager_data_supply_type_ma_resource_manager_data_supply_type_encoded: ++ ma_resource_manager_data_supply_type = 1; ++pub const ma_resource_manager_data_supply_type_ma_resource_manager_data_supply_type_decoded: ++ ma_resource_manager_data_supply_type = 2; ++pub const ma_resource_manager_data_supply_type_ma_resource_manager_data_supply_type_decoded_paged : ma_resource_manager_data_supply_type = 3 ; ++pub type ma_resource_manager_data_supply_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_supply { ++ pub type_: ma_resource_manager_data_supply_type, ++ pub backend: ma_resource_manager_data_supply__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_resource_manager_data_supply__bindgen_ty_1 { ++ pub encoded: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1, ++ pub decoded: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ pub decodedPaged: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1 { ++ pub pData: *const core::ffi::c_void, ++ pub sizeInBytes: usize, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1"][::core::mem::size_of::< ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1, ++ >() - 16usize]; ++ ["Alignment of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() ++ - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1::pData"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1, ++ pData ++ ) ++ - 0usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1::sizeInBytes"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1, ++ sizeInBytes ++ ) ++ - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2 { ++ pub pData: *const core::ffi::c_void, ++ pub totalFrameCount: ma_uint64, ++ pub decodedFrameCount: ma_uint64, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2"][::core::mem::size_of::< ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ >() - 40usize]; ++ ["Alignment of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() ++ - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::pData"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ pData ++ ) ++ - 0usize]; ++ [ ++ "Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::totalFrameCount", ++ ][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ totalFrameCount ++ ) - 8usize]; ++ [ ++ "Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::decodedFrameCount", ++ ][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ decodedFrameCount ++ ) - 16usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::format"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ format ++ ) ++ - 24usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::channels"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ channels ++ ) ++ - 28usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::sampleRate"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ sampleRate ++ ) ++ - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3 { ++ pub data: ma_paged_audio_buffer_data, ++ pub decodedFrameCount: ma_uint64, ++ pub sampleRate: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3"][::core::mem::size_of::< ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++ >() - 56usize]; ++ ["Alignment of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::align_of::() ++ - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3::data"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++ data ++ ) ++ - 0usize]; ++ [ ++ "Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3::decodedFrameCount", ++ ][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++ decodedFrameCount ++ ) - 40usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3::sampleRate"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++ sampleRate ++ ) ++ - 48usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply__bindgen_ty_1"] ++ [::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_resource_manager_data_supply__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1::encoded"] ++ [::core::mem::offset_of!(ma_resource_manager_data_supply__bindgen_ty_1, encoded) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1::decoded"] ++ [::core::mem::offset_of!(ma_resource_manager_data_supply__bindgen_ty_1, decoded) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1::decodedPaged"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1, ++ decodedPaged ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply"] ++ [::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_resource_manager_data_supply"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply::type_"] ++ [::core::mem::offset_of!(ma_resource_manager_data_supply, type_) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_supply::backend"] ++ [::core::mem::offset_of!(ma_resource_manager_data_supply, backend) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_buffer_node { ++ pub hashedName32: ma_uint32, ++ pub refCount: ma_uint32, ++ pub result: ma_result, ++ pub executionCounter: ma_uint32, ++ pub executionPointer: ma_uint32, ++ pub isDataOwnedByResourceManager: ma_bool32, ++ pub data: ma_resource_manager_data_supply, ++ pub pParent: *mut ma_resource_manager_data_buffer_node, ++ pub pChildLo: *mut ma_resource_manager_data_buffer_node, ++ pub pChildHi: *mut ma_resource_manager_data_buffer_node, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_buffer_node"] ++ [::core::mem::size_of::() - 112usize]; ++ ["Alignment of ma_resource_manager_data_buffer_node"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::hashedName32"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, hashedName32) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::refCount"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, refCount) - 4usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::result"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, result) - 8usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::executionCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, executionCounter) - 12usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::executionPointer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, executionPointer) - 16usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::isDataOwnedByResourceManager"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer_node, ++ isDataOwnedByResourceManager ++ ) ++ - 20usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::data"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, data) - 24usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::pParent"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, pParent) - 88usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::pChildLo"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, pChildLo) - 96usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::pChildHi"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, pChildHi) - 104usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_buffer { ++ pub ds: ma_data_source_base, ++ pub pResourceManager: *mut ma_resource_manager, ++ pub pNode: *mut ma_resource_manager_data_buffer_node, ++ pub flags: ma_uint32, ++ pub executionCounter: ma_uint32, ++ pub executionPointer: ma_uint32, ++ pub seekTargetInPCMFrames: ma_uint64, ++ pub seekToCursorOnNextRead: ma_bool32, ++ pub result: ma_result, ++ pub isLooping: ma_bool32, ++ pub isConnectorInitialized: ma_atomic_bool32, ++ pub connector: ma_resource_manager_data_buffer__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_resource_manager_data_buffer__bindgen_ty_1 { ++ pub decoder: ma_decoder, ++ pub buffer: ma_audio_buffer, ++ pub pagedBuffer: ma_paged_audio_buffer, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_buffer__bindgen_ty_1"] ++ [::core::mem::size_of::() - 552usize]; ++ ["Alignment of ma_resource_manager_data_buffer__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_buffer__bindgen_ty_1::decoder"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer__bindgen_ty_1, decoder) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_buffer__bindgen_ty_1::buffer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer__bindgen_ty_1, buffer) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_buffer__bindgen_ty_1::pagedBuffer"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer__bindgen_ty_1, ++ pagedBuffer ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_buffer"] ++ [::core::mem::size_of::() - 680usize]; ++ ["Alignment of ma_resource_manager_data_buffer"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::ds"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, ds) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::pResourceManager"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, pResourceManager) - 72usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::pNode"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, pNode) - 80usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, flags) - 88usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::executionCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, executionCounter) - 92usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::executionPointer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, executionPointer) - 96usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::seekTargetInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer, ++ seekTargetInPCMFrames ++ ) - 104usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::seekToCursorOnNextRead"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer, ++ seekToCursorOnNextRead ++ ) - 112usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::result"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, result) - 116usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::isLooping"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, isLooping) - 120usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::isConnectorInitialized"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer, ++ isConnectorInitialized ++ ) - 124usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::connector"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, connector) - 128usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_stream { ++ pub ds: ma_data_source_base, ++ pub pResourceManager: *mut ma_resource_manager, ++ pub flags: ma_uint32, ++ pub decoder: ma_decoder, ++ pub isDecoderInitialized: ma_bool32, ++ pub totalLengthInPCMFrames: ma_uint64, ++ pub relativeCursor: ma_uint32, ++ pub absoluteCursor: ma_uint64, ++ pub currentPageIndex: ma_uint32, ++ pub executionCounter: ma_uint32, ++ pub executionPointer: ma_uint32, ++ pub isLooping: ma_bool32, ++ pub pPageData: *mut core::ffi::c_void, ++ pub pageFrameCount: [ma_uint32; 2usize], ++ pub result: ma_result, ++ pub isDecoderAtEnd: ma_bool32, ++ pub isPageValid: [ma_bool32; 2usize], ++ pub seekCounter: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_stream"] ++ [::core::mem::size_of::() - 728usize]; ++ ["Alignment of ma_resource_manager_data_stream"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_stream::ds"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, ds) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_stream::pResourceManager"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, pResourceManager) - 72usize]; ++ ["Offset of field: ma_resource_manager_data_stream::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, flags) - 80usize]; ++ ["Offset of field: ma_resource_manager_data_stream::decoder"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, decoder) - 88usize]; ++ ["Offset of field: ma_resource_manager_data_stream::isDecoderInitialized"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, isDecoderInitialized) - 640usize]; ++ ["Offset of field: ma_resource_manager_data_stream::totalLengthInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_stream, ++ totalLengthInPCMFrames ++ ) - 648usize]; ++ ["Offset of field: ma_resource_manager_data_stream::relativeCursor"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, relativeCursor) - 656usize]; ++ ["Offset of field: ma_resource_manager_data_stream::absoluteCursor"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, absoluteCursor) - 664usize]; ++ ["Offset of field: ma_resource_manager_data_stream::currentPageIndex"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, currentPageIndex) - 672usize]; ++ ["Offset of field: ma_resource_manager_data_stream::executionCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, executionCounter) - 676usize]; ++ ["Offset of field: ma_resource_manager_data_stream::executionPointer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, executionPointer) - 680usize]; ++ ["Offset of field: ma_resource_manager_data_stream::isLooping"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, isLooping) - 684usize]; ++ ["Offset of field: ma_resource_manager_data_stream::pPageData"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, pPageData) - 688usize]; ++ ["Offset of field: ma_resource_manager_data_stream::pageFrameCount"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, pageFrameCount) - 696usize]; ++ ["Offset of field: ma_resource_manager_data_stream::result"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, result) - 704usize]; ++ ["Offset of field: ma_resource_manager_data_stream::isDecoderAtEnd"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, isDecoderAtEnd) - 708usize]; ++ ["Offset of field: ma_resource_manager_data_stream::isPageValid"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, isPageValid) - 712usize]; ++ ["Offset of field: ma_resource_manager_data_stream::seekCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, seekCounter) - 720usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_source { ++ pub backend: ma_resource_manager_data_source__bindgen_ty_1, ++ pub flags: ma_uint32, ++ pub executionCounter: ma_uint32, ++ pub executionPointer: ma_uint32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_resource_manager_data_source__bindgen_ty_1 { ++ pub buffer: ma_resource_manager_data_buffer, ++ pub stream: ma_resource_manager_data_stream, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_source__bindgen_ty_1"] ++ [::core::mem::size_of::() - 728usize]; ++ ["Alignment of ma_resource_manager_data_source__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_source__bindgen_ty_1::buffer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source__bindgen_ty_1, buffer) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_source__bindgen_ty_1::stream"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source__bindgen_ty_1, stream) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_source"] ++ [::core::mem::size_of::() - 744usize]; ++ ["Alignment of ma_resource_manager_data_source"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_source::backend"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source, backend) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_source::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source, flags) - 728usize]; ++ ["Offset of field: ma_resource_manager_data_source::executionCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source, executionCounter) - 732usize]; ++ ["Offset of field: ma_resource_manager_data_source::executionPointer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source, executionPointer) - 736usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_config { ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub pLog: *mut ma_log, ++ pub decodedFormat: ma_format, ++ pub decodedChannels: ma_uint32, ++ pub decodedSampleRate: ma_uint32, ++ pub jobThreadCount: ma_uint32, ++ pub jobThreadStackSize: usize, ++ pub jobQueueCapacity: ma_uint32, ++ pub flags: ma_uint32, ++ pub pVFS: *mut ma_vfs, ++ pub ppCustomDecodingBackendVTables: *mut *mut ma_decoding_backend_vtable, ++ pub customDecodingBackendCount: ma_uint32, ++ pub pCustomDecodingBackendUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_config"] ++ [::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_resource_manager_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_resource_manager_config, allocationCallbacks) - 0usize]; ++ ["Offset of field: ma_resource_manager_config::pLog"] ++ [::core::mem::offset_of!(ma_resource_manager_config, pLog) - 32usize]; ++ ["Offset of field: ma_resource_manager_config::decodedFormat"] ++ [::core::mem::offset_of!(ma_resource_manager_config, decodedFormat) - 40usize]; ++ ["Offset of field: ma_resource_manager_config::decodedChannels"] ++ [::core::mem::offset_of!(ma_resource_manager_config, decodedChannels) - 44usize]; ++ ["Offset of field: ma_resource_manager_config::decodedSampleRate"] ++ [::core::mem::offset_of!(ma_resource_manager_config, decodedSampleRate) - 48usize]; ++ ["Offset of field: ma_resource_manager_config::jobThreadCount"] ++ [::core::mem::offset_of!(ma_resource_manager_config, jobThreadCount) - 52usize]; ++ ["Offset of field: ma_resource_manager_config::jobThreadStackSize"] ++ [::core::mem::offset_of!(ma_resource_manager_config, jobThreadStackSize) - 56usize]; ++ ["Offset of field: ma_resource_manager_config::jobQueueCapacity"] ++ [::core::mem::offset_of!(ma_resource_manager_config, jobQueueCapacity) - 64usize]; ++ ["Offset of field: ma_resource_manager_config::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_config, flags) - 68usize]; ++ ["Offset of field: ma_resource_manager_config::pVFS"] ++ [::core::mem::offset_of!(ma_resource_manager_config, pVFS) - 72usize]; ++ ["Offset of field: ma_resource_manager_config::ppCustomDecodingBackendVTables"][::core::mem::offset_of!( ++ ma_resource_manager_config, ++ ppCustomDecodingBackendVTables ++ ) - 80usize]; ++ ["Offset of field: ma_resource_manager_config::customDecodingBackendCount"] ++ [::core::mem::offset_of!(ma_resource_manager_config, customDecodingBackendCount) - 88usize]; ++ ["Offset of field: ma_resource_manager_config::pCustomDecodingBackendUserData"][::core::mem::offset_of!( ++ ma_resource_manager_config, ++ pCustomDecodingBackendUserData ++ ) - 96usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resource_manager_config_init() -> ma_resource_manager_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager { ++ pub config: ma_resource_manager_config, ++ pub pRootDataBufferNode: *mut ma_resource_manager_data_buffer_node, ++ pub dataBufferBSTLock: ma_mutex, ++ pub jobThreads: [ma_thread; 64usize], ++ pub jobQueue: ma_job_queue, ++ pub defaultVFS: ma_default_vfs, ++ pub log: ma_log, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager"][::core::mem::size_of::() - 1120usize]; ++ ["Alignment of ma_resource_manager"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager::config"] ++ [::core::mem::offset_of!(ma_resource_manager, config) - 0usize]; ++ ["Offset of field: ma_resource_manager::pRootDataBufferNode"] ++ [::core::mem::offset_of!(ma_resource_manager, pRootDataBufferNode) - 104usize]; ++ ["Offset of field: ma_resource_manager::dataBufferBSTLock"] ++ [::core::mem::offset_of!(ma_resource_manager, dataBufferBSTLock) - 112usize]; ++ ["Offset of field: ma_resource_manager::jobThreads"] ++ [::core::mem::offset_of!(ma_resource_manager, jobThreads) - 160usize]; ++ ["Offset of field: ma_resource_manager::jobQueue"] ++ [::core::mem::offset_of!(ma_resource_manager, jobQueue) - 672usize]; ++ ["Offset of field: ma_resource_manager::defaultVFS"] ++ [::core::mem::offset_of!(ma_resource_manager, defaultVFS) - 872usize]; ++ ["Offset of field: ma_resource_manager::log"] ++ [::core::mem::offset_of!(ma_resource_manager, log) - 968usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resource_manager_init( ++ pConfig: *const ma_resource_manager_config, ++ pResourceManager: *mut ma_resource_manager, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_uninit(pResourceManager: *mut ma_resource_manager); ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_get_log(pResourceManager: *mut ma_resource_manager) -> *mut ma_log; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_file( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const core::ffi::c_char, ++ flags: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_file_w( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const wchar_t, ++ flags: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_decoded_data( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const core::ffi::c_char, ++ pData: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_decoded_data_w( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const wchar_t, ++ pData: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_encoded_data( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const core::ffi::c_char, ++ pData: *const core::ffi::c_void, ++ sizeInBytes: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_encoded_data_w( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const wchar_t, ++ pData: *const core::ffi::c_void, ++ sizeInBytes: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_unregister_file( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const core::ffi::c_char, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_unregister_file_w( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const wchar_t, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_unregister_data( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const core::ffi::c_char, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_unregister_data_w( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const wchar_t, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_init_ex( ++ pResourceManager: *mut ma_resource_manager, ++ pConfig: *const ma_resource_manager_data_source_config, ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_init( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const core::ffi::c_char, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_init_w( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const wchar_t, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_init_copy( ++ pResourceManager: *mut ma_resource_manager, ++ pExistingDataBuffer: *const ma_resource_manager_data_buffer, ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_uninit( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_read_pcm_frames( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_seek_to_pcm_frame( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_get_data_format( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_get_cursor_in_pcm_frames( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_get_length_in_pcm_frames( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_result( ++ pDataBuffer: *const ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_set_looping( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_is_looping( ++ pDataBuffer: *const ma_resource_manager_data_buffer, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_get_available_frames( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_init_ex( ++ pResourceManager: *mut ma_resource_manager, ++ pConfig: *const ma_resource_manager_data_source_config, ++ pDataStream: *mut ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_init( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const core::ffi::c_char, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataStream: *mut ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_init_w( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const wchar_t, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataStream: *mut ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_uninit( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_read_pcm_frames( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_seek_to_pcm_frame( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_get_data_format( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_get_cursor_in_pcm_frames( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_get_length_in_pcm_frames( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_result( ++ pDataStream: *const ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_set_looping( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_is_looping( ++ pDataStream: *const ma_resource_manager_data_stream, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_get_available_frames( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_init_ex( ++ pResourceManager: *mut ma_resource_manager, ++ pConfig: *const ma_resource_manager_data_source_config, ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_init( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const core::ffi::c_char, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_init_w( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const wchar_t, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_init_copy( ++ pResourceManager: *mut ma_resource_manager, ++ pExistingDataSource: *const ma_resource_manager_data_source, ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_uninit( ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_read_pcm_frames( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_seek_to_pcm_frame( ++ pDataSource: *mut ma_resource_manager_data_source, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_get_data_format( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_get_cursor_in_pcm_frames( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_get_length_in_pcm_frames( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_result( ++ pDataSource: *const ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_set_looping( ++ pDataSource: *mut ma_resource_manager_data_source, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_is_looping( ++ pDataSource: *const ma_resource_manager_data_source, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_get_available_frames( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_post_job( ++ pResourceManager: *mut ma_resource_manager, ++ pJob: *const ma_job, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_post_job_quit( ++ pResourceManager: *mut ma_resource_manager, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_next_job( ++ pResourceManager: *mut ma_resource_manager, ++ pJob: *mut ma_job, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_process_job( ++ pResourceManager: *mut ma_resource_manager, ++ pJob: *mut ma_job, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_process_next_job( ++ pResourceManager: *mut ma_resource_manager, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_stack { ++ pub offset: usize, ++ pub sizeInBytes: usize, ++ pub _data: [core::ffi::c_uchar; 1usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_stack"][::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_stack"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_stack::offset"][::core::mem::offset_of!(ma_stack, offset) - 0usize]; ++ ["Offset of field: ma_stack::sizeInBytes"] ++ [::core::mem::offset_of!(ma_stack, sizeInBytes) - 8usize]; ++ ["Offset of field: ma_stack::_data"][::core::mem::offset_of!(ma_stack, _data) - 16usize]; ++}; ++pub type ma_node = core::ffi::c_void; ++pub const ma_node_flags_MA_NODE_FLAG_PASSTHROUGH: ma_node_flags = 1; ++pub const ma_node_flags_MA_NODE_FLAG_CONTINUOUS_PROCESSING: ma_node_flags = 2; ++pub const ma_node_flags_MA_NODE_FLAG_ALLOW_NULL_INPUT: ma_node_flags = 4; ++pub const ma_node_flags_MA_NODE_FLAG_DIFFERENT_PROCESSING_RATES: ma_node_flags = 8; ++pub const ma_node_flags_MA_NODE_FLAG_SILENT_OUTPUT: ma_node_flags = 16; ++pub type ma_node_flags = core::ffi::c_uint; ++pub const ma_node_state_ma_node_state_started: ma_node_state = 0; ++pub const ma_node_state_ma_node_state_stopped: ma_node_state = 1; ++pub type ma_node_state = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_vtable { ++ pub onProcess: ::core::option::Option< ++ unsafe extern "C" fn( ++ pNode: *mut ma_node, ++ ppFramesIn: *mut *const f32, ++ pFrameCountIn: *mut ma_uint32, ++ ppFramesOut: *mut *mut f32, ++ pFrameCountOut: *mut ma_uint32, ++ ), ++ >, ++ pub onGetRequiredInputFrameCount: ::core::option::Option< ++ unsafe extern "C" fn( ++ pNode: *mut ma_node, ++ outputFrameCount: ma_uint32, ++ pInputFrameCount: *mut ma_uint32, ++ ) -> ma_result, ++ >, ++ pub inputBusCount: ma_uint8, ++ pub outputBusCount: ma_uint8, ++ pub flags: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_vtable"][::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_node_vtable"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_vtable::onProcess"] ++ [::core::mem::offset_of!(ma_node_vtable, onProcess) - 0usize]; ++ ["Offset of field: ma_node_vtable::onGetRequiredInputFrameCount"] ++ [::core::mem::offset_of!(ma_node_vtable, onGetRequiredInputFrameCount) - 8usize]; ++ ["Offset of field: ma_node_vtable::inputBusCount"] ++ [::core::mem::offset_of!(ma_node_vtable, inputBusCount) - 16usize]; ++ ["Offset of field: ma_node_vtable::outputBusCount"] ++ [::core::mem::offset_of!(ma_node_vtable, outputBusCount) - 17usize]; ++ ["Offset of field: ma_node_vtable::flags"] ++ [::core::mem::offset_of!(ma_node_vtable, flags) - 20usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_config { ++ pub vtable: *const ma_node_vtable, ++ pub initialState: ma_node_state, ++ pub inputBusCount: ma_uint32, ++ pub outputBusCount: ma_uint32, ++ pub pInputChannels: *const ma_uint32, ++ pub pOutputChannels: *const ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_config::vtable"] ++ [::core::mem::offset_of!(ma_node_config, vtable) - 0usize]; ++ ["Offset of field: ma_node_config::initialState"] ++ [::core::mem::offset_of!(ma_node_config, initialState) - 8usize]; ++ ["Offset of field: ma_node_config::inputBusCount"] ++ [::core::mem::offset_of!(ma_node_config, inputBusCount) - 12usize]; ++ ["Offset of field: ma_node_config::outputBusCount"] ++ [::core::mem::offset_of!(ma_node_config, outputBusCount) - 16usize]; ++ ["Offset of field: ma_node_config::pInputChannels"] ++ [::core::mem::offset_of!(ma_node_config, pInputChannels) - 24usize]; ++ ["Offset of field: ma_node_config::pOutputChannels"] ++ [::core::mem::offset_of!(ma_node_config, pOutputChannels) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_node_config_init() -> ma_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_output_bus { ++ pub pNode: *mut ma_node, ++ pub outputBusIndex: ma_uint8, ++ pub channels: ma_uint8, ++ pub inputNodeInputBusIndex: ma_uint8, ++ pub flags: ma_uint32, ++ pub refCount: ma_uint32, ++ pub isAttached: ma_bool32, ++ pub lock: ma_spinlock, ++ pub volume: f32, ++ pub pNext: *mut ma_node_output_bus, ++ pub pPrev: *mut ma_node_output_bus, ++ pub pInputNode: *mut ma_node, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_output_bus"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_node_output_bus"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_output_bus::pNode"] ++ [::core::mem::offset_of!(ma_node_output_bus, pNode) - 0usize]; ++ ["Offset of field: ma_node_output_bus::outputBusIndex"] ++ [::core::mem::offset_of!(ma_node_output_bus, outputBusIndex) - 8usize]; ++ ["Offset of field: ma_node_output_bus::channels"] ++ [::core::mem::offset_of!(ma_node_output_bus, channels) - 9usize]; ++ ["Offset of field: ma_node_output_bus::inputNodeInputBusIndex"] ++ [::core::mem::offset_of!(ma_node_output_bus, inputNodeInputBusIndex) - 10usize]; ++ ["Offset of field: ma_node_output_bus::flags"] ++ [::core::mem::offset_of!(ma_node_output_bus, flags) - 12usize]; ++ ["Offset of field: ma_node_output_bus::refCount"] ++ [::core::mem::offset_of!(ma_node_output_bus, refCount) - 16usize]; ++ ["Offset of field: ma_node_output_bus::isAttached"] ++ [::core::mem::offset_of!(ma_node_output_bus, isAttached) - 20usize]; ++ ["Offset of field: ma_node_output_bus::lock"] ++ [::core::mem::offset_of!(ma_node_output_bus, lock) - 24usize]; ++ ["Offset of field: ma_node_output_bus::volume"] ++ [::core::mem::offset_of!(ma_node_output_bus, volume) - 28usize]; ++ ["Offset of field: ma_node_output_bus::pNext"] ++ [::core::mem::offset_of!(ma_node_output_bus, pNext) - 32usize]; ++ ["Offset of field: ma_node_output_bus::pPrev"] ++ [::core::mem::offset_of!(ma_node_output_bus, pPrev) - 40usize]; ++ ["Offset of field: ma_node_output_bus::pInputNode"] ++ [::core::mem::offset_of!(ma_node_output_bus, pInputNode) - 48usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_input_bus { ++ pub head: ma_node_output_bus, ++ pub nextCounter: ma_uint32, ++ pub lock: ma_spinlock, ++ pub channels: ma_uint8, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_input_bus"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_node_input_bus"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_input_bus::head"] ++ [::core::mem::offset_of!(ma_node_input_bus, head) - 0usize]; ++ ["Offset of field: ma_node_input_bus::nextCounter"] ++ [::core::mem::offset_of!(ma_node_input_bus, nextCounter) - 56usize]; ++ ["Offset of field: ma_node_input_bus::lock"] ++ [::core::mem::offset_of!(ma_node_input_bus, lock) - 60usize]; ++ ["Offset of field: ma_node_input_bus::channels"] ++ [::core::mem::offset_of!(ma_node_input_bus, channels) - 64usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_base { ++ pub pNodeGraph: *mut ma_node_graph, ++ pub vtable: *const ma_node_vtable, ++ pub inputBusCount: ma_uint32, ++ pub outputBusCount: ma_uint32, ++ pub pInputBuses: *mut ma_node_input_bus, ++ pub pOutputBuses: *mut ma_node_output_bus, ++ pub pCachedData: *mut f32, ++ pub cachedDataCapInFramesPerBus: ma_uint16, ++ pub cachedFrameCountOut: ma_uint16, ++ pub cachedFrameCountIn: ma_uint16, ++ pub consumedFrameCountIn: ma_uint16, ++ pub state: ma_node_state, ++ pub stateTimes: [ma_uint64; 2usize], ++ pub localTime: ma_uint64, ++ pub _inputBuses: [ma_node_input_bus; 2usize], ++ pub _outputBuses: [ma_node_output_bus; 2usize], ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_base"][::core::mem::size_of::() - 360usize]; ++ ["Alignment of ma_node_base"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_base::pNodeGraph"] ++ [::core::mem::offset_of!(ma_node_base, pNodeGraph) - 0usize]; ++ ["Offset of field: ma_node_base::vtable"] ++ [::core::mem::offset_of!(ma_node_base, vtable) - 8usize]; ++ ["Offset of field: ma_node_base::inputBusCount"] ++ [::core::mem::offset_of!(ma_node_base, inputBusCount) - 16usize]; ++ ["Offset of field: ma_node_base::outputBusCount"] ++ [::core::mem::offset_of!(ma_node_base, outputBusCount) - 20usize]; ++ ["Offset of field: ma_node_base::pInputBuses"] ++ [::core::mem::offset_of!(ma_node_base, pInputBuses) - 24usize]; ++ ["Offset of field: ma_node_base::pOutputBuses"] ++ [::core::mem::offset_of!(ma_node_base, pOutputBuses) - 32usize]; ++ ["Offset of field: ma_node_base::pCachedData"] ++ [::core::mem::offset_of!(ma_node_base, pCachedData) - 40usize]; ++ ["Offset of field: ma_node_base::cachedDataCapInFramesPerBus"] ++ [::core::mem::offset_of!(ma_node_base, cachedDataCapInFramesPerBus) - 48usize]; ++ ["Offset of field: ma_node_base::cachedFrameCountOut"] ++ [::core::mem::offset_of!(ma_node_base, cachedFrameCountOut) - 50usize]; ++ ["Offset of field: ma_node_base::cachedFrameCountIn"] ++ [::core::mem::offset_of!(ma_node_base, cachedFrameCountIn) - 52usize]; ++ ["Offset of field: ma_node_base::consumedFrameCountIn"] ++ [::core::mem::offset_of!(ma_node_base, consumedFrameCountIn) - 54usize]; ++ ["Offset of field: ma_node_base::state"] ++ [::core::mem::offset_of!(ma_node_base, state) - 56usize]; ++ ["Offset of field: ma_node_base::stateTimes"] ++ [::core::mem::offset_of!(ma_node_base, stateTimes) - 64usize]; ++ ["Offset of field: ma_node_base::localTime"] ++ [::core::mem::offset_of!(ma_node_base, localTime) - 80usize]; ++ ["Offset of field: ma_node_base::_inputBuses"] ++ [::core::mem::offset_of!(ma_node_base, _inputBuses) - 88usize]; ++ ["Offset of field: ma_node_base::_outputBuses"] ++ [::core::mem::offset_of!(ma_node_base, _outputBuses) - 232usize]; ++ ["Offset of field: ma_node_base::_pHeap"] ++ [::core::mem::offset_of!(ma_node_base, _pHeap) - 344usize]; ++ ["Offset of field: ma_node_base::_ownsHeap"] ++ [::core::mem::offset_of!(ma_node_base, _ownsHeap) - 352usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_node_get_heap_size( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_node_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_init_preallocated( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_node_config, ++ pHeap: *mut core::ffi::c_void, ++ pNode: *mut ma_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_uninit( ++ pNode: *mut ma_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_node_get_node_graph(pNode: *const ma_node) -> *mut ma_node_graph; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_input_bus_count(pNode: *const ma_node) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_output_bus_count(pNode: *const ma_node) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_input_channels(pNode: *const ma_node, inputBusIndex: ma_uint32) ++ -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_output_channels( ++ pNode: *const ma_node, ++ outputBusIndex: ma_uint32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_attach_output_bus( ++ pNode: *mut ma_node, ++ outputBusIndex: ma_uint32, ++ pOtherNode: *mut ma_node, ++ otherNodeInputBusIndex: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_detach_output_bus(pNode: *mut ma_node, outputBusIndex: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_detach_all_output_buses(pNode: *mut ma_node) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_set_output_bus_volume( ++ pNode: *mut ma_node, ++ outputBusIndex: ma_uint32, ++ volume: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_output_bus_volume(pNode: *const ma_node, outputBusIndex: ma_uint32) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_node_set_state(pNode: *mut ma_node, state: ma_node_state) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_state(pNode: *const ma_node) -> ma_node_state; ++} ++unsafe extern "C" { ++ pub fn ma_node_set_state_time( ++ pNode: *mut ma_node, ++ state: ma_node_state, ++ globalTime: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_state_time(pNode: *const ma_node, state: ma_node_state) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_state_by_time(pNode: *const ma_node, globalTime: ma_uint64) ++ -> ma_node_state; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_state_by_time_range( ++ pNode: *const ma_node, ++ globalTimeBeg: ma_uint64, ++ globalTimeEnd: ma_uint64, ++ ) -> ma_node_state; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_time(pNode: *const ma_node) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_node_set_time(pNode: *mut ma_node, localTime: ma_uint64) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_graph_config { ++ pub channels: ma_uint32, ++ pub processingSizeInFrames: ma_uint32, ++ pub preMixStackSizeInBytes: usize, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_graph_config"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_node_graph_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_graph_config::channels"] ++ [::core::mem::offset_of!(ma_node_graph_config, channels) - 0usize]; ++ ["Offset of field: ma_node_graph_config::processingSizeInFrames"] ++ [::core::mem::offset_of!(ma_node_graph_config, processingSizeInFrames) - 4usize]; ++ ["Offset of field: ma_node_graph_config::preMixStackSizeInBytes"] ++ [::core::mem::offset_of!(ma_node_graph_config, preMixStackSizeInBytes) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_node_graph_config_init(channels: ma_uint32) -> ma_node_graph_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_graph { ++ pub base: ma_node_base, ++ pub endpoint: ma_node_base, ++ pub pProcessingCache: *mut f32, ++ pub processingCacheFramesRemaining: ma_uint32, ++ pub processingSizeInFrames: ma_uint32, ++ pub isReading: ma_bool32, ++ pub pPreMixStack: *mut ma_stack, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_graph"][::core::mem::size_of::() - 752usize]; ++ ["Alignment of ma_node_graph"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_graph::base"][::core::mem::offset_of!(ma_node_graph, base) - 0usize]; ++ ["Offset of field: ma_node_graph::endpoint"] ++ [::core::mem::offset_of!(ma_node_graph, endpoint) - 360usize]; ++ ["Offset of field: ma_node_graph::pProcessingCache"] ++ [::core::mem::offset_of!(ma_node_graph, pProcessingCache) - 720usize]; ++ ["Offset of field: ma_node_graph::processingCacheFramesRemaining"] ++ [::core::mem::offset_of!(ma_node_graph, processingCacheFramesRemaining) - 728usize]; ++ ["Offset of field: ma_node_graph::processingSizeInFrames"] ++ [::core::mem::offset_of!(ma_node_graph, processingSizeInFrames) - 732usize]; ++ ["Offset of field: ma_node_graph::isReading"] ++ [::core::mem::offset_of!(ma_node_graph, isReading) - 736usize]; ++ ["Offset of field: ma_node_graph::pPreMixStack"] ++ [::core::mem::offset_of!(ma_node_graph, pPreMixStack) - 744usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_node_graph_init( ++ pConfig: *const ma_node_graph_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNodeGraph: *mut ma_node_graph, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_uninit( ++ pNodeGraph: *mut ma_node_graph, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_get_endpoint(pNodeGraph: *mut ma_node_graph) -> *mut ma_node; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_read_pcm_frames( ++ pNodeGraph: *mut ma_node_graph, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_get_channels(pNodeGraph: *const ma_node_graph) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_get_time(pNodeGraph: *const ma_node_graph) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_set_time( ++ pNodeGraph: *mut ma_node_graph, ++ globalTime: ma_uint64, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_node_config { ++ pub nodeConfig: ma_node_config, ++ pub pDataSource: *mut ma_data_source, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_node_config"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_data_source_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_data_source_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_data_source_node_config::pDataSource"] ++ [::core::mem::offset_of!(ma_data_source_node_config, pDataSource) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_source_node_config_init( ++ pDataSource: *mut ma_data_source, ++ ) -> ma_data_source_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_node { ++ pub base: ma_node_base, ++ pub pDataSource: *mut ma_data_source, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_node"][::core::mem::size_of::() - 368usize]; ++ ["Alignment of ma_data_source_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_node::base"] ++ [::core::mem::offset_of!(ma_data_source_node, base) - 0usize]; ++ ["Offset of field: ma_data_source_node::pDataSource"] ++ [::core::mem::offset_of!(ma_data_source_node, pDataSource) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_source_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_data_source_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pDataSourceNode: *mut ma_data_source_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_node_uninit( ++ pDataSourceNode: *mut ma_data_source_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_data_source_node_set_looping( ++ pDataSourceNode: *mut ma_data_source_node, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_node_is_looping(pDataSourceNode: *mut ma_data_source_node) -> ma_bool32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_splitter_node_config { ++ pub nodeConfig: ma_node_config, ++ pub channels: ma_uint32, ++ pub outputBusCount: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_splitter_node_config"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_splitter_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_splitter_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_splitter_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_splitter_node_config::channels"] ++ [::core::mem::offset_of!(ma_splitter_node_config, channels) - 40usize]; ++ ["Offset of field: ma_splitter_node_config::outputBusCount"] ++ [::core::mem::offset_of!(ma_splitter_node_config, outputBusCount) - 44usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_splitter_node_config_init(channels: ma_uint32) -> ma_splitter_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_splitter_node { ++ pub base: ma_node_base, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_splitter_node"][::core::mem::size_of::() - 360usize]; ++ ["Alignment of ma_splitter_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_splitter_node::base"] ++ [::core::mem::offset_of!(ma_splitter_node, base) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_splitter_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_splitter_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pSplitterNode: *mut ma_splitter_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_splitter_node_uninit( ++ pSplitterNode: *mut ma_splitter_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_biquad_node_config { ++ pub nodeConfig: ma_node_config, ++ pub biquad: ma_biquad_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad_node_config"][::core::mem::size_of::() - 96usize]; ++ ["Alignment of ma_biquad_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_biquad_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_biquad_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_biquad_node_config::biquad"] ++ [::core::mem::offset_of!(ma_biquad_node_config, biquad) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_biquad_node_config_init( ++ channels: ma_uint32, ++ b0: f32, ++ b1: f32, ++ b2: f32, ++ a0: f32, ++ a1: f32, ++ a2: f32, ++ ) -> ma_biquad_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_biquad_node { ++ pub baseNode: ma_node_base, ++ pub biquad: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_biquad_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_biquad_node::baseNode"] ++ [::core::mem::offset_of!(ma_biquad_node, baseNode) - 0usize]; ++ ["Offset of field: ma_biquad_node::biquad"] ++ [::core::mem::offset_of!(ma_biquad_node, biquad) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_biquad_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_biquad_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_biquad_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_node_reinit( ++ pConfig: *const ma_biquad_config, ++ pNode: *mut ma_biquad_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_node_uninit( ++ pNode: *mut ma_biquad_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub lpf: ma_lpf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_lpf_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_lpf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_lpf_node_config::lpf"] ++ [::core::mem::offset_of!(ma_lpf_node_config, lpf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_lpf_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf_node { ++ pub baseNode: ma_node_base, ++ pub lpf: ma_lpf, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf_node"][::core::mem::size_of::() - 416usize]; ++ ["Alignment of ma_lpf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf_node::baseNode"] ++ [::core::mem::offset_of!(ma_lpf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_lpf_node::lpf"][::core::mem::offset_of!(ma_lpf_node, lpf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_lpf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_lpf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_node_reinit(pConfig: *const ma_lpf_config, pNode: *mut ma_lpf_node) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_node_uninit( ++ pNode: *mut ma_lpf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub hpf: ma_hpf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_hpf_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_hpf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_hpf_node_config::hpf"] ++ [::core::mem::offset_of!(ma_hpf_node_config, hpf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_hpf_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf_node { ++ pub baseNode: ma_node_base, ++ pub hpf: ma_hpf, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf_node"][::core::mem::size_of::() - 416usize]; ++ ["Alignment of ma_hpf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf_node::baseNode"] ++ [::core::mem::offset_of!(ma_hpf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_hpf_node::hpf"][::core::mem::offset_of!(ma_hpf_node, hpf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_hpf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_hpf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_node_reinit(pConfig: *const ma_hpf_config, pNode: *mut ma_hpf_node) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_node_uninit( ++ pNode: *mut ma_hpf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub bpf: ma_bpf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_bpf_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_bpf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_bpf_node_config::bpf"] ++ [::core::mem::offset_of!(ma_bpf_node_config, bpf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_bpf_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf_node { ++ pub baseNode: ma_node_base, ++ pub bpf: ma_bpf, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf_node"][::core::mem::size_of::() - 400usize]; ++ ["Alignment of ma_bpf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf_node::baseNode"] ++ [::core::mem::offset_of!(ma_bpf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_bpf_node::bpf"][::core::mem::offset_of!(ma_bpf_node, bpf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_bpf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_bpf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_node_reinit(pConfig: *const ma_bpf_config, pNode: *mut ma_bpf_node) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_node_uninit( ++ pNode: *mut ma_bpf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_notch_node_config { ++ pub nodeConfig: ma_node_config, ++ pub notch: ma_notch_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_notch_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_notch_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_notch_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_notch_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_notch_node_config::notch"] ++ [::core::mem::offset_of!(ma_notch_node_config, notch) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_notch_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ q: f64, ++ frequency: f64, ++ ) -> ma_notch_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_notch_node { ++ pub baseNode: ma_node_base, ++ pub notch: ma_notch2, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_notch_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_notch_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_notch_node::baseNode"] ++ [::core::mem::offset_of!(ma_notch_node, baseNode) - 0usize]; ++ ["Offset of field: ma_notch_node::notch"] ++ [::core::mem::offset_of!(ma_notch_node, notch) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_notch_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_notch_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_notch_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch_node_reinit( ++ pConfig: *const ma_notch_config, ++ pNode: *mut ma_notch_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch_node_uninit( ++ pNode: *mut ma_notch_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_peak_node_config { ++ pub nodeConfig: ma_node_config, ++ pub peak: ma_peak_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_peak_node_config"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_peak_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_peak_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_peak_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_peak_node_config::peak"] ++ [::core::mem::offset_of!(ma_peak_node_config, peak) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_peak_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ q: f64, ++ frequency: f64, ++ ) -> ma_peak_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_peak_node { ++ pub baseNode: ma_node_base, ++ pub peak: ma_peak2, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_peak_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_peak_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_peak_node::baseNode"] ++ [::core::mem::offset_of!(ma_peak_node, baseNode) - 0usize]; ++ ["Offset of field: ma_peak_node::peak"][::core::mem::offset_of!(ma_peak_node, peak) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_peak_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_peak_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_peak_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak_node_reinit( ++ pConfig: *const ma_peak_config, ++ pNode: *mut ma_peak_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak_node_uninit( ++ pNode: *mut ma_peak_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_loshelf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub loshelf: ma_loshelf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_loshelf_node_config"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_loshelf_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_loshelf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_loshelf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_loshelf_node_config::loshelf"] ++ [::core::mem::offset_of!(ma_loshelf_node_config, loshelf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_loshelf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ q: f64, ++ frequency: f64, ++ ) -> ma_loshelf_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_loshelf_node { ++ pub baseNode: ma_node_base, ++ pub loshelf: ma_loshelf2, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_loshelf_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_loshelf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_loshelf_node::baseNode"] ++ [::core::mem::offset_of!(ma_loshelf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_loshelf_node::loshelf"] ++ [::core::mem::offset_of!(ma_loshelf_node, loshelf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_loshelf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_loshelf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_loshelf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf_node_reinit( ++ pConfig: *const ma_loshelf_config, ++ pNode: *mut ma_loshelf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf_node_uninit( ++ pNode: *mut ma_loshelf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hishelf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub hishelf: ma_hishelf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hishelf_node_config"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_hishelf_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hishelf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_hishelf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_hishelf_node_config::hishelf"] ++ [::core::mem::offset_of!(ma_hishelf_node_config, hishelf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hishelf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ q: f64, ++ frequency: f64, ++ ) -> ma_hishelf_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_hishelf_node { ++ pub baseNode: ma_node_base, ++ pub hishelf: ma_hishelf2, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hishelf_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_hishelf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hishelf_node::baseNode"] ++ [::core::mem::offset_of!(ma_hishelf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_hishelf_node::hishelf"] ++ [::core::mem::offset_of!(ma_hishelf_node, hishelf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hishelf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_hishelf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_hishelf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf_node_reinit( ++ pConfig: *const ma_hishelf_config, ++ pNode: *mut ma_hishelf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf_node_uninit( ++ pNode: *mut ma_hishelf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_delay_node_config { ++ pub nodeConfig: ma_node_config, ++ pub delay: ma_delay_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_delay_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_delay_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_delay_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_delay_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_delay_node_config::delay"] ++ [::core::mem::offset_of!(ma_delay_node_config, delay) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_delay_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ delayInFrames: ma_uint32, ++ decay: f32, ++ ) -> ma_delay_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_delay_node { ++ pub baseNode: ma_node_base, ++ pub delay: ma_delay, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_delay_node"][::core::mem::size_of::() - 408usize]; ++ ["Alignment of ma_delay_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_delay_node::baseNode"] ++ [::core::mem::offset_of!(ma_delay_node, baseNode) - 0usize]; ++ ["Offset of field: ma_delay_node::delay"] ++ [::core::mem::offset_of!(ma_delay_node, delay) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_delay_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_delay_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pDelayNode: *mut ma_delay_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_uninit( ++ pDelayNode: *mut ma_delay_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_set_wet(pDelayNode: *mut ma_delay_node, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_get_wet(pDelayNode: *const ma_delay_node) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_set_dry(pDelayNode: *mut ma_delay_node, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_get_dry(pDelayNode: *const ma_delay_node) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_set_decay(pDelayNode: *mut ma_delay_node, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_get_decay(pDelayNode: *const ma_delay_node) -> f32; ++} ++pub const ma_sound_flags_MA_SOUND_FLAG_STREAM: ma_sound_flags = 1; ++pub const ma_sound_flags_MA_SOUND_FLAG_DECODE: ma_sound_flags = 2; ++pub const ma_sound_flags_MA_SOUND_FLAG_ASYNC: ma_sound_flags = 4; ++pub const ma_sound_flags_MA_SOUND_FLAG_WAIT_INIT: ma_sound_flags = 8; ++pub const ma_sound_flags_MA_SOUND_FLAG_UNKNOWN_LENGTH: ma_sound_flags = 16; ++pub const ma_sound_flags_MA_SOUND_FLAG_LOOPING: ma_sound_flags = 32; ++pub const ma_sound_flags_MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT: ma_sound_flags = 4096; ++pub const ma_sound_flags_MA_SOUND_FLAG_NO_PITCH: ma_sound_flags = 8192; ++pub const ma_sound_flags_MA_SOUND_FLAG_NO_SPATIALIZATION: ma_sound_flags = 16384; ++pub type ma_sound_flags = core::ffi::c_uint; ++pub const ma_engine_node_type_ma_engine_node_type_sound: ma_engine_node_type = 0; ++pub const ma_engine_node_type_ma_engine_node_type_group: ma_engine_node_type = 1; ++pub type ma_engine_node_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_engine_node_config { ++ pub pEngine: *mut ma_engine, ++ pub type_: ma_engine_node_type, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub volumeSmoothTimeInPCMFrames: ma_uint32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub isPitchDisabled: ma_bool8, ++ pub isSpatializationDisabled: ma_bool8, ++ pub pinnedListenerIndex: ma_uint8, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine_node_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_engine_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine_node_config::pEngine"] ++ [::core::mem::offset_of!(ma_engine_node_config, pEngine) - 0usize]; ++ ["Offset of field: ma_engine_node_config::type_"] ++ [::core::mem::offset_of!(ma_engine_node_config, type_) - 8usize]; ++ ["Offset of field: ma_engine_node_config::channelsIn"] ++ [::core::mem::offset_of!(ma_engine_node_config, channelsIn) - 12usize]; ++ ["Offset of field: ma_engine_node_config::channelsOut"] ++ [::core::mem::offset_of!(ma_engine_node_config, channelsOut) - 16usize]; ++ ["Offset of field: ma_engine_node_config::sampleRate"] ++ [::core::mem::offset_of!(ma_engine_node_config, sampleRate) - 20usize]; ++ ["Offset of field: ma_engine_node_config::volumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_engine_node_config, volumeSmoothTimeInPCMFrames) - 24usize]; ++ ["Offset of field: ma_engine_node_config::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_engine_node_config, monoExpansionMode) - 28usize]; ++ ["Offset of field: ma_engine_node_config::isPitchDisabled"] ++ [::core::mem::offset_of!(ma_engine_node_config, isPitchDisabled) - 32usize]; ++ ["Offset of field: ma_engine_node_config::isSpatializationDisabled"] ++ [::core::mem::offset_of!(ma_engine_node_config, isSpatializationDisabled) - 33usize]; ++ ["Offset of field: ma_engine_node_config::pinnedListenerIndex"] ++ [::core::mem::offset_of!(ma_engine_node_config, pinnedListenerIndex) - 34usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_engine_node_config_init( ++ pEngine: *mut ma_engine, ++ type_: ma_engine_node_type, ++ flags: ma_uint32, ++ ) -> ma_engine_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_engine_node { ++ pub baseNode: ma_node_base, ++ pub pEngine: *mut ma_engine, ++ pub sampleRate: ma_uint32, ++ pub volumeSmoothTimeInPCMFrames: ma_uint32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub fader: ma_fader, ++ pub resampler: ma_linear_resampler, ++ pub spatializer: ma_spatializer, ++ pub panner: ma_panner, ++ pub volumeGainer: ma_gainer, ++ pub volume: ma_atomic_float, ++ pub pitch: f32, ++ pub oldPitch: f32, ++ pub oldDopplerPitch: f32, ++ pub isPitchDisabled: ma_bool32, ++ pub isSpatializationDisabled: ma_bool32, ++ pub pinnedListenerIndex: ma_uint32, ++ pub fadeSettings: ma_engine_node__bindgen_ty_1, ++ pub _ownsHeap: ma_bool8, ++ pub _pHeap: *mut core::ffi::c_void, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_engine_node__bindgen_ty_1 { ++ pub volumeBeg: ma_atomic_float, ++ pub volumeEnd: ma_atomic_float, ++ pub fadeLengthInFrames: ma_atomic_uint64, ++ pub absoluteGlobalTimeInFrames: ma_atomic_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine_node__bindgen_ty_1"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_engine_node__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine_node__bindgen_ty_1::volumeBeg"] ++ [::core::mem::offset_of!(ma_engine_node__bindgen_ty_1, volumeBeg) - 0usize]; ++ ["Offset of field: ma_engine_node__bindgen_ty_1::volumeEnd"] ++ [::core::mem::offset_of!(ma_engine_node__bindgen_ty_1, volumeEnd) - 4usize]; ++ ["Offset of field: ma_engine_node__bindgen_ty_1::fadeLengthInFrames"] ++ [::core::mem::offset_of!(ma_engine_node__bindgen_ty_1, fadeLengthInFrames) - 8usize]; ++ ["Offset of field: ma_engine_node__bindgen_ty_1::absoluteGlobalTimeInFrames"][::core::mem::offset_of!( ++ ma_engine_node__bindgen_ty_1, ++ absoluteGlobalTimeInFrames ++ ) - 16usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine_node"][::core::mem::size_of::() - 896usize]; ++ ["Alignment of ma_engine_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine_node::baseNode"] ++ [::core::mem::offset_of!(ma_engine_node, baseNode) - 0usize]; ++ ["Offset of field: ma_engine_node::pEngine"] ++ [::core::mem::offset_of!(ma_engine_node, pEngine) - 360usize]; ++ ["Offset of field: ma_engine_node::sampleRate"] ++ [::core::mem::offset_of!(ma_engine_node, sampleRate) - 368usize]; ++ ["Offset of field: ma_engine_node::volumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_engine_node, volumeSmoothTimeInPCMFrames) - 372usize]; ++ ["Offset of field: ma_engine_node::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_engine_node, monoExpansionMode) - 376usize]; ++ ["Offset of field: ma_engine_node::fader"] ++ [::core::mem::offset_of!(ma_engine_node, fader) - 384usize]; ++ ["Offset of field: ma_engine_node::resampler"] ++ [::core::mem::offset_of!(ma_engine_node, resampler) - 424usize]; ++ ["Offset of field: ma_engine_node::spatializer"] ++ [::core::mem::offset_of!(ma_engine_node, spatializer) - 560usize]; ++ ["Offset of field: ma_engine_node::panner"] ++ [::core::mem::offset_of!(ma_engine_node, panner) - 760usize]; ++ ["Offset of field: ma_engine_node::volumeGainer"] ++ [::core::mem::offset_of!(ma_engine_node, volumeGainer) - 776usize]; ++ ["Offset of field: ma_engine_node::volume"] ++ [::core::mem::offset_of!(ma_engine_node, volume) - 824usize]; ++ ["Offset of field: ma_engine_node::pitch"] ++ [::core::mem::offset_of!(ma_engine_node, pitch) - 828usize]; ++ ["Offset of field: ma_engine_node::oldPitch"] ++ [::core::mem::offset_of!(ma_engine_node, oldPitch) - 832usize]; ++ ["Offset of field: ma_engine_node::oldDopplerPitch"] ++ [::core::mem::offset_of!(ma_engine_node, oldDopplerPitch) - 836usize]; ++ ["Offset of field: ma_engine_node::isPitchDisabled"] ++ [::core::mem::offset_of!(ma_engine_node, isPitchDisabled) - 840usize]; ++ ["Offset of field: ma_engine_node::isSpatializationDisabled"] ++ [::core::mem::offset_of!(ma_engine_node, isSpatializationDisabled) - 844usize]; ++ ["Offset of field: ma_engine_node::pinnedListenerIndex"] ++ [::core::mem::offset_of!(ma_engine_node, pinnedListenerIndex) - 848usize]; ++ ["Offset of field: ma_engine_node::fadeSettings"] ++ [::core::mem::offset_of!(ma_engine_node, fadeSettings) - 856usize]; ++ ["Offset of field: ma_engine_node::_ownsHeap"] ++ [::core::mem::offset_of!(ma_engine_node, _ownsHeap) - 880usize]; ++ ["Offset of field: ma_engine_node::_pHeap"] ++ [::core::mem::offset_of!(ma_engine_node, _pHeap) - 888usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_engine_node_get_heap_size( ++ pConfig: *const ma_engine_node_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_node_init_preallocated( ++ pConfig: *const ma_engine_node_config, ++ pHeap: *mut core::ffi::c_void, ++ pEngineNode: *mut ma_engine_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_node_init( ++ pConfig: *const ma_engine_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pEngineNode: *mut ma_engine_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_node_uninit( ++ pEngineNode: *mut ma_engine_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++pub type ma_sound_end_proc = ::core::option::Option< ++ unsafe extern "C" fn(pUserData: *mut core::ffi::c_void, pSound: *mut ma_sound), ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_sound_config { ++ pub pFilePath: *const core::ffi::c_char, ++ pub pFilePathW: *const wchar_t, ++ pub pDataSource: *mut ma_data_source, ++ pub pInitialAttachment: *mut ma_node, ++ pub initialAttachmentInputBusIndex: ma_uint32, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub flags: ma_uint32, ++ pub volumeSmoothTimeInPCMFrames: ma_uint32, ++ pub initialSeekPointInPCMFrames: ma_uint64, ++ pub rangeBegInPCMFrames: ma_uint64, ++ pub rangeEndInPCMFrames: ma_uint64, ++ pub loopPointBegInPCMFrames: ma_uint64, ++ pub loopPointEndInPCMFrames: ma_uint64, ++ pub endCallback: ma_sound_end_proc, ++ pub pEndCallbackUserData: *mut core::ffi::c_void, ++ pub initNotifications: ma_resource_manager_pipeline_notifications, ++ pub pDoneFence: *mut ma_fence, ++ pub isLooping: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_sound_config"][::core::mem::size_of::() - 160usize]; ++ ["Alignment of ma_sound_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_sound_config::pFilePath"] ++ [::core::mem::offset_of!(ma_sound_config, pFilePath) - 0usize]; ++ ["Offset of field: ma_sound_config::pFilePathW"] ++ [::core::mem::offset_of!(ma_sound_config, pFilePathW) - 8usize]; ++ ["Offset of field: ma_sound_config::pDataSource"] ++ [::core::mem::offset_of!(ma_sound_config, pDataSource) - 16usize]; ++ ["Offset of field: ma_sound_config::pInitialAttachment"] ++ [::core::mem::offset_of!(ma_sound_config, pInitialAttachment) - 24usize]; ++ ["Offset of field: ma_sound_config::initialAttachmentInputBusIndex"] ++ [::core::mem::offset_of!(ma_sound_config, initialAttachmentInputBusIndex) - 32usize]; ++ ["Offset of field: ma_sound_config::channelsIn"] ++ [::core::mem::offset_of!(ma_sound_config, channelsIn) - 36usize]; ++ ["Offset of field: ma_sound_config::channelsOut"] ++ [::core::mem::offset_of!(ma_sound_config, channelsOut) - 40usize]; ++ ["Offset of field: ma_sound_config::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_sound_config, monoExpansionMode) - 44usize]; ++ ["Offset of field: ma_sound_config::flags"] ++ [::core::mem::offset_of!(ma_sound_config, flags) - 48usize]; ++ ["Offset of field: ma_sound_config::volumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, volumeSmoothTimeInPCMFrames) - 52usize]; ++ ["Offset of field: ma_sound_config::initialSeekPointInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, initialSeekPointInPCMFrames) - 56usize]; ++ ["Offset of field: ma_sound_config::rangeBegInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, rangeBegInPCMFrames) - 64usize]; ++ ["Offset of field: ma_sound_config::rangeEndInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, rangeEndInPCMFrames) - 72usize]; ++ ["Offset of field: ma_sound_config::loopPointBegInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, loopPointBegInPCMFrames) - 80usize]; ++ ["Offset of field: ma_sound_config::loopPointEndInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, loopPointEndInPCMFrames) - 88usize]; ++ ["Offset of field: ma_sound_config::endCallback"] ++ [::core::mem::offset_of!(ma_sound_config, endCallback) - 96usize]; ++ ["Offset of field: ma_sound_config::pEndCallbackUserData"] ++ [::core::mem::offset_of!(ma_sound_config, pEndCallbackUserData) - 104usize]; ++ ["Offset of field: ma_sound_config::initNotifications"] ++ [::core::mem::offset_of!(ma_sound_config, initNotifications) - 112usize]; ++ ["Offset of field: ma_sound_config::pDoneFence"] ++ [::core::mem::offset_of!(ma_sound_config, pDoneFence) - 144usize]; ++ ["Offset of field: ma_sound_config::isLooping"] ++ [::core::mem::offset_of!(ma_sound_config, isLooping) - 152usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_sound_config_init() -> ma_sound_config; ++} ++unsafe extern "C" { ++ pub fn ma_sound_config_init_2(pEngine: *mut ma_engine) -> ma_sound_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_sound { ++ pub engineNode: ma_engine_node, ++ pub pDataSource: *mut ma_data_source, ++ pub seekTarget: ma_uint64, ++ pub atEnd: ma_bool32, ++ pub endCallback: ma_sound_end_proc, ++ pub pEndCallbackUserData: *mut core::ffi::c_void, ++ pub ownsDataSource: ma_bool8, ++ pub pResourceManagerDataSource: *mut ma_resource_manager_data_source, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_sound"][::core::mem::size_of::() - 952usize]; ++ ["Alignment of ma_sound"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_sound::engineNode"] ++ [::core::mem::offset_of!(ma_sound, engineNode) - 0usize]; ++ ["Offset of field: ma_sound::pDataSource"] ++ [::core::mem::offset_of!(ma_sound, pDataSource) - 896usize]; ++ ["Offset of field: ma_sound::seekTarget"] ++ [::core::mem::offset_of!(ma_sound, seekTarget) - 904usize]; ++ ["Offset of field: ma_sound::atEnd"][::core::mem::offset_of!(ma_sound, atEnd) - 912usize]; ++ ["Offset of field: ma_sound::endCallback"] ++ [::core::mem::offset_of!(ma_sound, endCallback) - 920usize]; ++ ["Offset of field: ma_sound::pEndCallbackUserData"] ++ [::core::mem::offset_of!(ma_sound, pEndCallbackUserData) - 928usize]; ++ ["Offset of field: ma_sound::ownsDataSource"] ++ [::core::mem::offset_of!(ma_sound, ownsDataSource) - 936usize]; ++ ["Offset of field: ma_sound::pResourceManagerDataSource"] ++ [::core::mem::offset_of!(ma_sound, pResourceManagerDataSource) - 944usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_sound_inlined { ++ pub sound: ma_sound, ++ pub pNext: *mut ma_sound_inlined, ++ pub pPrev: *mut ma_sound_inlined, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_sound_inlined"][::core::mem::size_of::() - 968usize]; ++ ["Alignment of ma_sound_inlined"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_sound_inlined::sound"] ++ [::core::mem::offset_of!(ma_sound_inlined, sound) - 0usize]; ++ ["Offset of field: ma_sound_inlined::pNext"] ++ [::core::mem::offset_of!(ma_sound_inlined, pNext) - 952usize]; ++ ["Offset of field: ma_sound_inlined::pPrev"] ++ [::core::mem::offset_of!(ma_sound_inlined, pPrev) - 960usize]; ++}; ++pub type ma_sound_group_config = ma_sound_config; ++pub type ma_sound_group = ma_sound; ++unsafe extern "C" { ++ pub fn ma_sound_group_config_init() -> ma_sound_group_config; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_config_init_2(pEngine: *mut ma_engine) -> ma_sound_group_config; ++} ++pub type ma_engine_process_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pFramesOut: *mut f32, ++ frameCount: ma_uint64, ++ ), ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_engine_config { ++ pub pResourceManager: *mut ma_resource_manager, ++ pub pContext: *mut ma_context, ++ pub pDevice: *mut ma_device, ++ pub pPlaybackDeviceID: *mut ma_device_id, ++ pub dataCallback: ma_device_data_proc, ++ pub notificationCallback: ma_device_notification_proc, ++ pub pLog: *mut ma_log, ++ pub listenerCount: ma_uint32, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub periodSizeInFrames: ma_uint32, ++ pub periodSizeInMilliseconds: ma_uint32, ++ pub gainSmoothTimeInFrames: ma_uint32, ++ pub gainSmoothTimeInMilliseconds: ma_uint32, ++ pub defaultVolumeSmoothTimeInPCMFrames: ma_uint32, ++ pub preMixStackSizeInBytes: ma_uint32, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub noAutoStart: ma_bool32, ++ pub noDevice: ma_bool32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub pResourceManagerVFS: *mut ma_vfs, ++ pub onProcess: ma_engine_process_proc, ++ pub pProcessUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine_config"][::core::mem::size_of::() - 168usize]; ++ ["Alignment of ma_engine_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine_config::pResourceManager"] ++ [::core::mem::offset_of!(ma_engine_config, pResourceManager) - 0usize]; ++ ["Offset of field: ma_engine_config::pContext"] ++ [::core::mem::offset_of!(ma_engine_config, pContext) - 8usize]; ++ ["Offset of field: ma_engine_config::pDevice"] ++ [::core::mem::offset_of!(ma_engine_config, pDevice) - 16usize]; ++ ["Offset of field: ma_engine_config::pPlaybackDeviceID"] ++ [::core::mem::offset_of!(ma_engine_config, pPlaybackDeviceID) - 24usize]; ++ ["Offset of field: ma_engine_config::dataCallback"] ++ [::core::mem::offset_of!(ma_engine_config, dataCallback) - 32usize]; ++ ["Offset of field: ma_engine_config::notificationCallback"] ++ [::core::mem::offset_of!(ma_engine_config, notificationCallback) - 40usize]; ++ ["Offset of field: ma_engine_config::pLog"] ++ [::core::mem::offset_of!(ma_engine_config, pLog) - 48usize]; ++ ["Offset of field: ma_engine_config::listenerCount"] ++ [::core::mem::offset_of!(ma_engine_config, listenerCount) - 56usize]; ++ ["Offset of field: ma_engine_config::channels"] ++ [::core::mem::offset_of!(ma_engine_config, channels) - 60usize]; ++ ["Offset of field: ma_engine_config::sampleRate"] ++ [::core::mem::offset_of!(ma_engine_config, sampleRate) - 64usize]; ++ ["Offset of field: ma_engine_config::periodSizeInFrames"] ++ [::core::mem::offset_of!(ma_engine_config, periodSizeInFrames) - 68usize]; ++ ["Offset of field: ma_engine_config::periodSizeInMilliseconds"] ++ [::core::mem::offset_of!(ma_engine_config, periodSizeInMilliseconds) - 72usize]; ++ ["Offset of field: ma_engine_config::gainSmoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_engine_config, gainSmoothTimeInFrames) - 76usize]; ++ ["Offset of field: ma_engine_config::gainSmoothTimeInMilliseconds"] ++ [::core::mem::offset_of!(ma_engine_config, gainSmoothTimeInMilliseconds) - 80usize]; ++ ["Offset of field: ma_engine_config::defaultVolumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_engine_config, defaultVolumeSmoothTimeInPCMFrames) - 84usize]; ++ ["Offset of field: ma_engine_config::preMixStackSizeInBytes"] ++ [::core::mem::offset_of!(ma_engine_config, preMixStackSizeInBytes) - 88usize]; ++ ["Offset of field: ma_engine_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_engine_config, allocationCallbacks) - 96usize]; ++ ["Offset of field: ma_engine_config::noAutoStart"] ++ [::core::mem::offset_of!(ma_engine_config, noAutoStart) - 128usize]; ++ ["Offset of field: ma_engine_config::noDevice"] ++ [::core::mem::offset_of!(ma_engine_config, noDevice) - 132usize]; ++ ["Offset of field: ma_engine_config::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_engine_config, monoExpansionMode) - 136usize]; ++ ["Offset of field: ma_engine_config::pResourceManagerVFS"] ++ [::core::mem::offset_of!(ma_engine_config, pResourceManagerVFS) - 144usize]; ++ ["Offset of field: ma_engine_config::onProcess"] ++ [::core::mem::offset_of!(ma_engine_config, onProcess) - 152usize]; ++ ["Offset of field: ma_engine_config::pProcessUserData"] ++ [::core::mem::offset_of!(ma_engine_config, pProcessUserData) - 160usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_engine_config_init() -> ma_engine_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_engine { ++ pub nodeGraph: ma_node_graph, ++ pub pResourceManager: *mut ma_resource_manager, ++ pub pDevice: *mut ma_device, ++ pub pLog: *mut ma_log, ++ pub sampleRate: ma_uint32, ++ pub listenerCount: ma_uint32, ++ pub listeners: [ma_spatializer_listener; 4usize], ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub ownsResourceManager: ma_bool8, ++ pub ownsDevice: ma_bool8, ++ pub inlinedSoundLock: ma_spinlock, ++ pub pInlinedSoundHead: *mut ma_sound_inlined, ++ pub inlinedSoundCount: ma_uint32, ++ pub gainSmoothTimeInFrames: ma_uint32, ++ pub defaultVolumeSmoothTimeInPCMFrames: ma_uint32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub onProcess: ma_engine_process_proc, ++ pub pProcessUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine"][::core::mem::size_of::() - 1312usize]; ++ ["Alignment of ma_engine"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine::nodeGraph"] ++ [::core::mem::offset_of!(ma_engine, nodeGraph) - 0usize]; ++ ["Offset of field: ma_engine::pResourceManager"] ++ [::core::mem::offset_of!(ma_engine, pResourceManager) - 752usize]; ++ ["Offset of field: ma_engine::pDevice"][::core::mem::offset_of!(ma_engine, pDevice) - 760usize]; ++ ["Offset of field: ma_engine::pLog"][::core::mem::offset_of!(ma_engine, pLog) - 768usize]; ++ ["Offset of field: ma_engine::sampleRate"] ++ [::core::mem::offset_of!(ma_engine, sampleRate) - 776usize]; ++ ["Offset of field: ma_engine::listenerCount"] ++ [::core::mem::offset_of!(ma_engine, listenerCount) - 780usize]; ++ ["Offset of field: ma_engine::listeners"] ++ [::core::mem::offset_of!(ma_engine, listeners) - 784usize]; ++ ["Offset of field: ma_engine::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_engine, allocationCallbacks) - 1232usize]; ++ ["Offset of field: ma_engine::ownsResourceManager"] ++ [::core::mem::offset_of!(ma_engine, ownsResourceManager) - 1264usize]; ++ ["Offset of field: ma_engine::ownsDevice"] ++ [::core::mem::offset_of!(ma_engine, ownsDevice) - 1265usize]; ++ ["Offset of field: ma_engine::inlinedSoundLock"] ++ [::core::mem::offset_of!(ma_engine, inlinedSoundLock) - 1268usize]; ++ ["Offset of field: ma_engine::pInlinedSoundHead"] ++ [::core::mem::offset_of!(ma_engine, pInlinedSoundHead) - 1272usize]; ++ ["Offset of field: ma_engine::inlinedSoundCount"] ++ [::core::mem::offset_of!(ma_engine, inlinedSoundCount) - 1280usize]; ++ ["Offset of field: ma_engine::gainSmoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_engine, gainSmoothTimeInFrames) - 1284usize]; ++ ["Offset of field: ma_engine::defaultVolumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_engine, defaultVolumeSmoothTimeInPCMFrames) - 1288usize]; ++ ["Offset of field: ma_engine::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_engine, monoExpansionMode) - 1292usize]; ++ ["Offset of field: ma_engine::onProcess"] ++ [::core::mem::offset_of!(ma_engine, onProcess) - 1296usize]; ++ ["Offset of field: ma_engine::pProcessUserData"] ++ [::core::mem::offset_of!(ma_engine, pProcessUserData) - 1304usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_engine_init(pConfig: *const ma_engine_config, pEngine: *mut ma_engine) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_uninit(pEngine: *mut ma_engine); ++} ++unsafe extern "C" { ++ pub fn ma_engine_read_pcm_frames( ++ pEngine: *mut ma_engine, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_node_graph(pEngine: *mut ma_engine) -> *mut ma_node_graph; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_resource_manager(pEngine: *mut ma_engine) -> *mut ma_resource_manager; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_device(pEngine: *mut ma_engine) -> *mut ma_device; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_log(pEngine: *mut ma_engine) -> *mut ma_log; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_endpoint(pEngine: *mut ma_engine) -> *mut ma_node; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_time_in_pcm_frames(pEngine: *const ma_engine) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_time_in_milliseconds(pEngine: *const ma_engine) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_time_in_pcm_frames( ++ pEngine: *mut ma_engine, ++ globalTime: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_time_in_milliseconds( ++ pEngine: *mut ma_engine, ++ globalTime: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_time(pEngine: *const ma_engine) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_time(pEngine: *mut ma_engine, globalTime: ma_uint64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_channels(pEngine: *const ma_engine) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_sample_rate(pEngine: *const ma_engine) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_start(pEngine: *mut ma_engine) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_stop(pEngine: *mut ma_engine) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_volume(pEngine: *mut ma_engine, volume: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_volume(pEngine: *mut ma_engine) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_gain_db(pEngine: *mut ma_engine, gainDB: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_gain_db(pEngine: *mut ma_engine) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_listener_count(pEngine: *const ma_engine) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_find_closest_listener( ++ pEngine: *const ma_engine, ++ absolutePosX: f32, ++ absolutePosY: f32, ++ absolutePosZ: f32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_position( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_position( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_direction( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_direction( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_velocity( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_velocity( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_cone( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_cone( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_world_up( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_world_up( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_enabled( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ isEnabled: ma_bool32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_is_enabled( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_play_sound_ex( ++ pEngine: *mut ma_engine, ++ pFilePath: *const core::ffi::c_char, ++ pNode: *mut ma_node, ++ nodeInputBusIndex: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_play_sound( ++ pEngine: *mut ma_engine, ++ pFilePath: *const core::ffi::c_char, ++ pGroup: *mut ma_sound_group, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_from_file( ++ pEngine: *mut ma_engine, ++ pFilePath: *const core::ffi::c_char, ++ flags: ma_uint32, ++ pGroup: *mut ma_sound_group, ++ pDoneFence: *mut ma_fence, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_from_file_w( ++ pEngine: *mut ma_engine, ++ pFilePath: *const wchar_t, ++ flags: ma_uint32, ++ pGroup: *mut ma_sound_group, ++ pDoneFence: *mut ma_fence, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_copy( ++ pEngine: *mut ma_engine, ++ pExistingSound: *const ma_sound, ++ flags: ma_uint32, ++ pGroup: *mut ma_sound_group, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_from_data_source( ++ pEngine: *mut ma_engine, ++ pDataSource: *mut ma_data_source, ++ flags: ma_uint32, ++ pGroup: *mut ma_sound_group, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_ex( ++ pEngine: *mut ma_engine, ++ pConfig: *const ma_sound_config, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_uninit(pSound: *mut ma_sound); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_engine(pSound: *const ma_sound) -> *mut ma_engine; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_data_source(pSound: *const ma_sound) -> *mut ma_data_source; ++} ++unsafe extern "C" { ++ pub fn ma_sound_start(pSound: *mut ma_sound) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_stop(pSound: *mut ma_sound) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_stop_with_fade_in_pcm_frames( ++ pSound: *mut ma_sound, ++ fadeLengthInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_stop_with_fade_in_milliseconds( ++ pSound: *mut ma_sound, ++ fadeLengthInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_volume(pSound: *mut ma_sound, volume: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_volume(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_pan(pSound: *mut ma_sound, pan: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_pan(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_pan_mode(pSound: *mut ma_sound, panMode: ma_pan_mode); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_pan_mode(pSound: *const ma_sound) -> ma_pan_mode; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_pitch(pSound: *mut ma_sound, pitch: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_pitch(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_spatialization_enabled(pSound: *mut ma_sound, enabled: ma_bool32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_is_spatialization_enabled(pSound: *const ma_sound) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_pinned_listener_index(pSound: *mut ma_sound, listenerIndex: ma_uint32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_pinned_listener_index(pSound: *const ma_sound) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_listener_index(pSound: *const ma_sound) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_direction_to_listener(pSound: *const ma_sound) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_position(pSound: *mut ma_sound, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_position(pSound: *const ma_sound) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_direction(pSound: *mut ma_sound, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_direction(pSound: *const ma_sound) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_velocity(pSound: *mut ma_sound, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_velocity(pSound: *const ma_sound) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_attenuation_model( ++ pSound: *mut ma_sound, ++ attenuationModel: ma_attenuation_model, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_attenuation_model(pSound: *const ma_sound) -> ma_attenuation_model; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_positioning(pSound: *mut ma_sound, positioning: ma_positioning); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_positioning(pSound: *const ma_sound) -> ma_positioning; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_rolloff(pSound: *mut ma_sound, rolloff: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_rolloff(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_min_gain(pSound: *mut ma_sound, minGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_min_gain(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_max_gain(pSound: *mut ma_sound, maxGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_max_gain(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_min_distance(pSound: *mut ma_sound, minDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_min_distance(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_max_distance(pSound: *mut ma_sound, maxDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_max_distance(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_cone( ++ pSound: *mut ma_sound, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_cone( ++ pSound: *const ma_sound, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_doppler_factor(pSound: *mut ma_sound, dopplerFactor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_doppler_factor(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_directional_attenuation_factor( ++ pSound: *mut ma_sound, ++ directionalAttenuationFactor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_directional_attenuation_factor(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_fade_in_pcm_frames( ++ pSound: *mut ma_sound, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_fade_in_milliseconds( ++ pSound: *mut ma_sound, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_fade_start_in_pcm_frames( ++ pSound: *mut ma_sound, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInFrames: ma_uint64, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_fade_start_in_milliseconds( ++ pSound: *mut ma_sound, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInMilliseconds: ma_uint64, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_current_fade_volume(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_start_time_in_pcm_frames( ++ pSound: *mut ma_sound, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_start_time_in_milliseconds( ++ pSound: *mut ma_sound, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_stop_time_in_pcm_frames( ++ pSound: *mut ma_sound, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_stop_time_in_milliseconds( ++ pSound: *mut ma_sound, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_stop_time_with_fade_in_pcm_frames( ++ pSound: *mut ma_sound, ++ stopAbsoluteGlobalTimeInFrames: ma_uint64, ++ fadeLengthInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_stop_time_with_fade_in_milliseconds( ++ pSound: *mut ma_sound, ++ stopAbsoluteGlobalTimeInMilliseconds: ma_uint64, ++ fadeLengthInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_is_playing(pSound: *const ma_sound) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_time_in_pcm_frames(pSound: *const ma_sound) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_time_in_milliseconds(pSound: *const ma_sound) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_looping(pSound: *mut ma_sound, isLooping: ma_bool32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_is_looping(pSound: *const ma_sound) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_at_end(pSound: *const ma_sound) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_seek_to_pcm_frame(pSound: *mut ma_sound, frameIndex: ma_uint64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_seek_to_second(pSound: *mut ma_sound, seekPointInSeconds: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_data_format( ++ pSound: *const ma_sound, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_cursor_in_pcm_frames( ++ pSound: *const ma_sound, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_length_in_pcm_frames( ++ pSound: *const ma_sound, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_cursor_in_seconds(pSound: *const ma_sound, pCursor: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_length_in_seconds(pSound: *const ma_sound, pLength: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_end_callback( ++ pSound: *mut ma_sound, ++ callback: ma_sound_end_proc, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_init( ++ pEngine: *mut ma_engine, ++ flags: ma_uint32, ++ pParentGroup: *mut ma_sound_group, ++ pGroup: *mut ma_sound_group, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_init_ex( ++ pEngine: *mut ma_engine, ++ pConfig: *const ma_sound_group_config, ++ pGroup: *mut ma_sound_group, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_uninit(pGroup: *mut ma_sound_group); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_engine(pGroup: *const ma_sound_group) -> *mut ma_engine; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_start(pGroup: *mut ma_sound_group) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_stop(pGroup: *mut ma_sound_group) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_volume(pGroup: *mut ma_sound_group, volume: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_volume(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_pan(pGroup: *mut ma_sound_group, pan: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_pan(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_pan_mode(pGroup: *mut ma_sound_group, panMode: ma_pan_mode); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_pan_mode(pGroup: *const ma_sound_group) -> ma_pan_mode; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_pitch(pGroup: *mut ma_sound_group, pitch: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_pitch(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_spatialization_enabled( ++ pGroup: *mut ma_sound_group, ++ enabled: ma_bool32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_is_spatialization_enabled(pGroup: *const ma_sound_group) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_pinned_listener_index( ++ pGroup: *mut ma_sound_group, ++ listenerIndex: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_pinned_listener_index(pGroup: *const ma_sound_group) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_listener_index(pGroup: *const ma_sound_group) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_direction_to_listener(pGroup: *const ma_sound_group) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_position(pGroup: *mut ma_sound_group, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_position(pGroup: *const ma_sound_group) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_direction(pGroup: *mut ma_sound_group, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_direction(pGroup: *const ma_sound_group) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_velocity(pGroup: *mut ma_sound_group, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_velocity(pGroup: *const ma_sound_group) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_attenuation_model( ++ pGroup: *mut ma_sound_group, ++ attenuationModel: ma_attenuation_model, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_attenuation_model( ++ pGroup: *const ma_sound_group, ++ ) -> ma_attenuation_model; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_positioning(pGroup: *mut ma_sound_group, positioning: ma_positioning); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_positioning(pGroup: *const ma_sound_group) -> ma_positioning; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_rolloff(pGroup: *mut ma_sound_group, rolloff: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_rolloff(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_min_gain(pGroup: *mut ma_sound_group, minGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_min_gain(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_max_gain(pGroup: *mut ma_sound_group, maxGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_max_gain(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_min_distance(pGroup: *mut ma_sound_group, minDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_min_distance(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_max_distance(pGroup: *mut ma_sound_group, maxDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_max_distance(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_cone( ++ pGroup: *mut ma_sound_group, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_cone( ++ pGroup: *const ma_sound_group, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_doppler_factor(pGroup: *mut ma_sound_group, dopplerFactor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_doppler_factor(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_directional_attenuation_factor( ++ pGroup: *mut ma_sound_group, ++ directionalAttenuationFactor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_directional_attenuation_factor(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_fade_in_pcm_frames( ++ pGroup: *mut ma_sound_group, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_fade_in_milliseconds( ++ pGroup: *mut ma_sound_group, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_current_fade_volume(pGroup: *mut ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_start_time_in_pcm_frames( ++ pGroup: *mut ma_sound_group, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_start_time_in_milliseconds( ++ pGroup: *mut ma_sound_group, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_stop_time_in_pcm_frames( ++ pGroup: *mut ma_sound_group, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_stop_time_in_milliseconds( ++ pGroup: *mut ma_sound_group, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_is_playing(pGroup: *const ma_sound_group) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_time_in_pcm_frames(pGroup: *const ma_sound_group) -> ma_uint64; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __locale_data { ++ pub _address: u8, ++} +diff --git a/src/pregen_bindings/linux-aarch64-musl.rs b/src/pregen_bindings/linux-aarch64-musl.rs +new file mode 100644 +index 0000000000000000000000000000000000000000..b8b2aa19e3374448ff9e9d45ec04d49372cec7df +--- /dev/null ++++ b/src/pregen_bindings/linux-aarch64-musl.rs +@@ -0,0 +1,14103 @@ ++/* automatically generated by rust-bindgen 0.72.1 */ ++ ++#[doc = r" If Bindgen could only determine the size and alignment of a"] ++#[doc = r" type, it is represented like this."] ++#[derive(PartialEq, Copy, Clone, Debug, Hash)] ++#[repr(C)] ++pub struct __BindgenOpaqueArray(pub [T; N]); ++impl Default for __BindgenOpaqueArray { ++ fn default() -> Self { ++ Self([::default(); N]) ++ } ++} ++pub const MA_VERSION_MAJOR: u32 = 0; ++pub const MA_VERSION_MINOR: u32 = 11; ++pub const MA_VERSION_REVISION: u32 = 23; ++pub const MA_SIZEOF_PTR: u32 = 8; ++pub const MA_TRUE: u32 = 1; ++pub const MA_FALSE: u32 = 0; ++pub const MA_SIZE_MAX: u32 = 4294967295; ++pub const _BSD_SOURCE: u32 = 1; ++pub const _XOPEN_SOURCE: u32 = 700; ++pub const __BYTE_ORDER: u32 = 1234; ++pub const __LONG_MAX: u64 = 9223372036854775807; ++pub const __LITTLE_ENDIAN: u32 = 1234; ++pub const __BIG_ENDIAN: u32 = 4321; ++pub const __USE_TIME_BITS64: u32 = 1; ++pub const SCHED_OTHER: u32 = 0; ++pub const SCHED_FIFO: u32 = 1; ++pub const SCHED_RR: u32 = 2; ++pub const SCHED_BATCH: u32 = 3; ++pub const SCHED_IDLE: u32 = 5; ++pub const SCHED_DEADLINE: u32 = 6; ++pub const SCHED_RESET_ON_FORK: u32 = 1073741824; ++pub const CLOCKS_PER_SEC: u32 = 1000000; ++pub const TIME_UTC: u32 = 1; ++pub const CLOCK_REALTIME: u32 = 0; ++pub const CLOCK_MONOTONIC: u32 = 1; ++pub const CLOCK_PROCESS_CPUTIME_ID: u32 = 2; ++pub const CLOCK_THREAD_CPUTIME_ID: u32 = 3; ++pub const CLOCK_MONOTONIC_RAW: u32 = 4; ++pub const CLOCK_REALTIME_COARSE: u32 = 5; ++pub const CLOCK_MONOTONIC_COARSE: u32 = 6; ++pub const CLOCK_BOOTTIME: u32 = 7; ++pub const CLOCK_REALTIME_ALARM: u32 = 8; ++pub const CLOCK_BOOTTIME_ALARM: u32 = 9; ++pub const CLOCK_SGI_CYCLE: u32 = 10; ++pub const CLOCK_TAI: u32 = 11; ++pub const TIMER_ABSTIME: u32 = 1; ++pub const PTHREAD_CREATE_JOINABLE: u32 = 0; ++pub const PTHREAD_CREATE_DETACHED: u32 = 1; ++pub const PTHREAD_MUTEX_NORMAL: u32 = 0; ++pub const PTHREAD_MUTEX_DEFAULT: u32 = 0; ++pub const PTHREAD_MUTEX_RECURSIVE: u32 = 1; ++pub const PTHREAD_MUTEX_ERRORCHECK: u32 = 2; ++pub const PTHREAD_MUTEX_STALLED: u32 = 0; ++pub const PTHREAD_MUTEX_ROBUST: u32 = 1; ++pub const PTHREAD_PRIO_NONE: u32 = 0; ++pub const PTHREAD_PRIO_INHERIT: u32 = 1; ++pub const PTHREAD_PRIO_PROTECT: u32 = 2; ++pub const PTHREAD_INHERIT_SCHED: u32 = 0; ++pub const PTHREAD_EXPLICIT_SCHED: u32 = 1; ++pub const PTHREAD_SCOPE_SYSTEM: u32 = 0; ++pub const PTHREAD_SCOPE_PROCESS: u32 = 1; ++pub const PTHREAD_PROCESS_PRIVATE: u32 = 0; ++pub const PTHREAD_PROCESS_SHARED: u32 = 1; ++pub const PTHREAD_ONCE_INIT: u32 = 0; ++pub const PTHREAD_CANCEL_ENABLE: u32 = 0; ++pub const PTHREAD_CANCEL_DISABLE: u32 = 1; ++pub const PTHREAD_CANCEL_MASKED: u32 = 2; ++pub const PTHREAD_CANCEL_DEFERRED: u32 = 0; ++pub const PTHREAD_CANCEL_ASYNCHRONOUS: u32 = 1; ++pub const PTHREAD_BARRIER_SERIAL_THREAD: i32 = -1; ++pub const MA_SIMD_ALIGNMENT: u32 = 32; ++pub const __alignas_is_defined: u32 = 1; ++pub const __alignof_is_defined: u32 = 1; ++pub const MA_MIN_CHANNELS: u32 = 1; ++pub const MA_MAX_CHANNELS: u32 = 254; ++pub const MA_MAX_FILTER_ORDER: u32 = 8; ++pub const MA_MAX_LOG_CALLBACKS: u32 = 4; ++pub const MA_CHANNEL_INDEX_NULL: u32 = 255; ++pub const MA_DATA_SOURCE_SELF_MANAGED_RANGE_AND_LOOP_POINT: u32 = 1; ++pub const MA_DATA_FORMAT_FLAG_EXCLUSIVE_MODE: u32 = 2; ++pub const MA_MAX_DEVICE_NAME_LENGTH: u32 = 255; ++pub const MA_RESOURCE_MANAGER_MAX_JOB_THREAD_COUNT: u32 = 64; ++pub const MA_MAX_NODE_BUS_COUNT: u32 = 254; ++pub const MA_MAX_NODE_LOCAL_BUS_COUNT: u32 = 2; ++pub const MA_NODE_BUS_COUNT_UNKNOWN: u32 = 255; ++pub const MA_ENGINE_MAX_LISTENERS: u32 = 4; ++pub const MA_SOUND_SOURCE_CHANNEL_COUNT: u32 = 4294967295; ++pub type wchar_t = core::ffi::c_uint; ++#[repr(C)] ++#[repr(align(16))] ++#[derive(Debug, Copy, Clone)] ++pub struct max_align_t { ++ pub __clang_max_align_nonce1: core::ffi::c_longlong, ++ pub __bindgen_padding_0: u64, ++ pub __clang_max_align_nonce2: u128, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of max_align_t"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of max_align_t"][::core::mem::align_of::() - 16usize]; ++ ["Offset of field: max_align_t::__clang_max_align_nonce1"] ++ [::core::mem::offset_of!(max_align_t, __clang_max_align_nonce1) - 0usize]; ++ ["Offset of field: max_align_t::__clang_max_align_nonce2"] ++ [::core::mem::offset_of!(max_align_t, __clang_max_align_nonce2) - 16usize]; ++}; ++pub type ma_int8 = core::ffi::c_schar; ++pub type ma_uint8 = core::ffi::c_uchar; ++pub type ma_int16 = core::ffi::c_short; ++pub type ma_uint16 = core::ffi::c_ushort; ++pub type ma_int32 = core::ffi::c_int; ++pub type ma_uint32 = core::ffi::c_uint; ++pub type ma_int64 = core::ffi::c_longlong; ++pub type ma_uint64 = core::ffi::c_ulonglong; ++pub type ma_uintptr = ma_uint64; ++pub type ma_bool8 = ma_uint8; ++pub type ma_bool32 = ma_uint32; ++pub type ma_float = f32; ++pub type ma_double = f64; ++pub type ma_handle = *mut core::ffi::c_void; ++pub type ma_ptr = *mut core::ffi::c_void; ++pub type ma_proc = ::core::option::Option; ++pub type time_t = core::ffi::c_long; ++pub type clockid_t = core::ffi::c_int; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct timespec { ++ pub tv_sec: time_t, ++ pub tv_nsec: core::ffi::c_long, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of timespec"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of timespec"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: timespec::tv_sec"][::core::mem::offset_of!(timespec, tv_sec) - 0usize]; ++ ["Offset of field: timespec::tv_nsec"][::core::mem::offset_of!(timespec, tv_nsec) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __pthread { ++ _unused: [u8; 0], ++} ++pub type pthread_t = *mut __pthread; ++pub type pthread_once_t = core::ffi::c_int; ++pub type pthread_key_t = core::ffi::c_uint; ++pub type pthread_spinlock_t = core::ffi::c_int; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_mutexattr_t { ++ pub __attr: core::ffi::c_uint, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_mutexattr_t"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of pthread_mutexattr_t"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: pthread_mutexattr_t::__attr"] ++ [::core::mem::offset_of!(pthread_mutexattr_t, __attr) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_condattr_t { ++ pub __attr: core::ffi::c_uint, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_condattr_t"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of pthread_condattr_t"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: pthread_condattr_t::__attr"] ++ [::core::mem::offset_of!(pthread_condattr_t, __attr) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_barrierattr_t { ++ pub __attr: core::ffi::c_uint, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_barrierattr_t"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of pthread_barrierattr_t"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: pthread_barrierattr_t::__attr"] ++ [::core::mem::offset_of!(pthread_barrierattr_t, __attr) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_rwlockattr_t { ++ pub __attr: [core::ffi::c_uint; 2usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_rwlockattr_t"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of pthread_rwlockattr_t"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: pthread_rwlockattr_t::__attr"] ++ [::core::mem::offset_of!(pthread_rwlockattr_t, __attr) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __sigset_t { ++ pub __bits: [core::ffi::c_ulong; 16usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __sigset_t"][::core::mem::size_of::<__sigset_t>() - 128usize]; ++ ["Alignment of __sigset_t"][::core::mem::align_of::<__sigset_t>() - 8usize]; ++ ["Offset of field: __sigset_t::__bits"][::core::mem::offset_of!(__sigset_t, __bits) - 0usize]; ++}; ++pub type sigset_t = __sigset_t; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct pthread_attr_t { ++ pub __u: pthread_attr_t__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_attr_t__bindgen_ty_1 { ++ pub __i: [core::ffi::c_int; 14usize], ++ pub __vi: [core::ffi::c_int; 14usize], ++ pub __s: [core::ffi::c_ulong; 7usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_attr_t__bindgen_ty_1"] ++ [::core::mem::size_of::() - 56usize]; ++ ["Alignment of pthread_attr_t__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_attr_t__bindgen_ty_1::__i"] ++ [::core::mem::offset_of!(pthread_attr_t__bindgen_ty_1, __i) - 0usize]; ++ ["Offset of field: pthread_attr_t__bindgen_ty_1::__vi"] ++ [::core::mem::offset_of!(pthread_attr_t__bindgen_ty_1, __vi) - 0usize]; ++ ["Offset of field: pthread_attr_t__bindgen_ty_1::__s"] ++ [::core::mem::offset_of!(pthread_attr_t__bindgen_ty_1, __s) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_attr_t"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of pthread_attr_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_attr_t::__u"][::core::mem::offset_of!(pthread_attr_t, __u) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct pthread_mutex_t { ++ pub __u: pthread_mutex_t__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_mutex_t__bindgen_ty_1 { ++ pub __i: [core::ffi::c_int; 10usize], ++ pub __vi: [core::ffi::c_int; 10usize], ++ pub __p: [*mut core::ffi::c_void; 5usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_mutex_t__bindgen_ty_1"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of pthread_mutex_t__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_mutex_t__bindgen_ty_1::__i"] ++ [::core::mem::offset_of!(pthread_mutex_t__bindgen_ty_1, __i) - 0usize]; ++ ["Offset of field: pthread_mutex_t__bindgen_ty_1::__vi"] ++ [::core::mem::offset_of!(pthread_mutex_t__bindgen_ty_1, __vi) - 0usize]; ++ ["Offset of field: pthread_mutex_t__bindgen_ty_1::__p"] ++ [::core::mem::offset_of!(pthread_mutex_t__bindgen_ty_1, __p) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_mutex_t"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of pthread_mutex_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_mutex_t::__u"] ++ [::core::mem::offset_of!(pthread_mutex_t, __u) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct pthread_cond_t { ++ pub __u: pthread_cond_t__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_cond_t__bindgen_ty_1 { ++ pub __i: [core::ffi::c_int; 12usize], ++ pub __vi: [core::ffi::c_int; 12usize], ++ pub __p: [*mut core::ffi::c_void; 6usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_cond_t__bindgen_ty_1"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of pthread_cond_t__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_cond_t__bindgen_ty_1::__i"] ++ [::core::mem::offset_of!(pthread_cond_t__bindgen_ty_1, __i) - 0usize]; ++ ["Offset of field: pthread_cond_t__bindgen_ty_1::__vi"] ++ [::core::mem::offset_of!(pthread_cond_t__bindgen_ty_1, __vi) - 0usize]; ++ ["Offset of field: pthread_cond_t__bindgen_ty_1::__p"] ++ [::core::mem::offset_of!(pthread_cond_t__bindgen_ty_1, __p) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_cond_t"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of pthread_cond_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_cond_t::__u"][::core::mem::offset_of!(pthread_cond_t, __u) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct pthread_rwlock_t { ++ pub __u: pthread_rwlock_t__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_rwlock_t__bindgen_ty_1 { ++ pub __i: [core::ffi::c_int; 14usize], ++ pub __vi: [core::ffi::c_int; 14usize], ++ pub __p: [*mut core::ffi::c_void; 7usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_rwlock_t__bindgen_ty_1"] ++ [::core::mem::size_of::() - 56usize]; ++ ["Alignment of pthread_rwlock_t__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_rwlock_t__bindgen_ty_1::__i"] ++ [::core::mem::offset_of!(pthread_rwlock_t__bindgen_ty_1, __i) - 0usize]; ++ ["Offset of field: pthread_rwlock_t__bindgen_ty_1::__vi"] ++ [::core::mem::offset_of!(pthread_rwlock_t__bindgen_ty_1, __vi) - 0usize]; ++ ["Offset of field: pthread_rwlock_t__bindgen_ty_1::__p"] ++ [::core::mem::offset_of!(pthread_rwlock_t__bindgen_ty_1, __p) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_rwlock_t"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of pthread_rwlock_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_rwlock_t::__u"] ++ [::core::mem::offset_of!(pthread_rwlock_t, __u) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct pthread_barrier_t { ++ pub __u: pthread_barrier_t__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_barrier_t__bindgen_ty_1 { ++ pub __i: [core::ffi::c_int; 8usize], ++ pub __vi: [core::ffi::c_int; 8usize], ++ pub __p: [*mut core::ffi::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_barrier_t__bindgen_ty_1"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of pthread_barrier_t__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_barrier_t__bindgen_ty_1::__i"] ++ [::core::mem::offset_of!(pthread_barrier_t__bindgen_ty_1, __i) - 0usize]; ++ ["Offset of field: pthread_barrier_t__bindgen_ty_1::__vi"] ++ [::core::mem::offset_of!(pthread_barrier_t__bindgen_ty_1, __vi) - 0usize]; ++ ["Offset of field: pthread_barrier_t__bindgen_ty_1::__p"] ++ [::core::mem::offset_of!(pthread_barrier_t__bindgen_ty_1, __p) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_barrier_t"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of pthread_barrier_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_barrier_t::__u"] ++ [::core::mem::offset_of!(pthread_barrier_t, __u) - 0usize]; ++}; ++pub type pid_t = core::ffi::c_int; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sched_param { ++ pub sched_priority: core::ffi::c_int, ++ pub __reserved1: core::ffi::c_int, ++ pub __reserved2: [sched_param__bindgen_ty_1; 2usize], ++ pub __reserved3: core::ffi::c_int, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sched_param__bindgen_ty_1 { ++ pub __reserved1: time_t, ++ pub __reserved2: core::ffi::c_long, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sched_param__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of sched_param__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: sched_param__bindgen_ty_1::__reserved1"] ++ [::core::mem::offset_of!(sched_param__bindgen_ty_1, __reserved1) - 0usize]; ++ ["Offset of field: sched_param__bindgen_ty_1::__reserved2"] ++ [::core::mem::offset_of!(sched_param__bindgen_ty_1, __reserved2) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sched_param"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of sched_param"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: sched_param::sched_priority"] ++ [::core::mem::offset_of!(sched_param, sched_priority) - 0usize]; ++ ["Offset of field: sched_param::__reserved1"] ++ [::core::mem::offset_of!(sched_param, __reserved1) - 4usize]; ++ ["Offset of field: sched_param::__reserved2"] ++ [::core::mem::offset_of!(sched_param, __reserved2) - 8usize]; ++ ["Offset of field: sched_param::__reserved3"] ++ [::core::mem::offset_of!(sched_param, __reserved3) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn sched_get_priority_max(arg1: core::ffi::c_int) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_get_priority_min(arg1: core::ffi::c_int) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_getparam(arg1: pid_t, arg2: *mut sched_param) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_getscheduler(arg1: pid_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_rr_get_interval(arg1: pid_t, arg2: *mut timespec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_setparam(arg1: pid_t, arg2: *const sched_param) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_setscheduler( ++ arg1: pid_t, ++ arg2: core::ffi::c_int, ++ arg3: *const sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_yield() -> core::ffi::c_int; ++} ++pub type timer_t = *mut core::ffi::c_void; ++pub type clock_t = core::ffi::c_long; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __locale_struct { ++ _unused: [u8; 0], ++} ++pub type locale_t = *mut __locale_struct; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct tm { ++ pub tm_sec: core::ffi::c_int, ++ pub tm_min: core::ffi::c_int, ++ pub tm_hour: core::ffi::c_int, ++ pub tm_mday: core::ffi::c_int, ++ pub tm_mon: core::ffi::c_int, ++ pub tm_year: core::ffi::c_int, ++ pub tm_wday: core::ffi::c_int, ++ pub tm_yday: core::ffi::c_int, ++ pub tm_isdst: core::ffi::c_int, ++ pub tm_gmtoff: core::ffi::c_long, ++ pub tm_zone: *const core::ffi::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of tm"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of tm"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: tm::tm_sec"][::core::mem::offset_of!(tm, tm_sec) - 0usize]; ++ ["Offset of field: tm::tm_min"][::core::mem::offset_of!(tm, tm_min) - 4usize]; ++ ["Offset of field: tm::tm_hour"][::core::mem::offset_of!(tm, tm_hour) - 8usize]; ++ ["Offset of field: tm::tm_mday"][::core::mem::offset_of!(tm, tm_mday) - 12usize]; ++ ["Offset of field: tm::tm_mon"][::core::mem::offset_of!(tm, tm_mon) - 16usize]; ++ ["Offset of field: tm::tm_year"][::core::mem::offset_of!(tm, tm_year) - 20usize]; ++ ["Offset of field: tm::tm_wday"][::core::mem::offset_of!(tm, tm_wday) - 24usize]; ++ ["Offset of field: tm::tm_yday"][::core::mem::offset_of!(tm, tm_yday) - 28usize]; ++ ["Offset of field: tm::tm_isdst"][::core::mem::offset_of!(tm, tm_isdst) - 32usize]; ++ ["Offset of field: tm::tm_gmtoff"][::core::mem::offset_of!(tm, tm_gmtoff) - 40usize]; ++ ["Offset of field: tm::tm_zone"][::core::mem::offset_of!(tm, tm_zone) - 48usize]; ++}; ++unsafe extern "C" { ++ pub fn clock() -> clock_t; ++} ++unsafe extern "C" { ++ pub fn time(arg1: *mut time_t) -> time_t; ++} ++unsafe extern "C" { ++ pub fn difftime(arg1: time_t, arg2: time_t) -> f64; ++} ++unsafe extern "C" { ++ pub fn mktime(arg1: *mut tm) -> time_t; ++} ++unsafe extern "C" { ++ pub fn strftime( ++ arg1: *mut core::ffi::c_char, ++ arg2: usize, ++ arg3: *const core::ffi::c_char, ++ arg4: *const tm, ++ ) -> usize; ++} ++unsafe extern "C" { ++ pub fn gmtime(arg1: *const time_t) -> *mut tm; ++} ++unsafe extern "C" { ++ pub fn localtime(arg1: *const time_t) -> *mut tm; ++} ++unsafe extern "C" { ++ pub fn asctime(arg1: *const tm) -> *mut core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ctime(arg1: *const time_t) -> *mut core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn timespec_get(arg1: *mut timespec, arg2: core::ffi::c_int) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn strftime_l( ++ arg1: *mut core::ffi::c_char, ++ arg2: usize, ++ arg3: *const core::ffi::c_char, ++ arg4: *const tm, ++ arg5: locale_t, ++ ) -> usize; ++} ++unsafe extern "C" { ++ pub fn gmtime_r(arg1: *const time_t, arg2: *mut tm) -> *mut tm; ++} ++unsafe extern "C" { ++ pub fn localtime_r(arg1: *const time_t, arg2: *mut tm) -> *mut tm; ++} ++unsafe extern "C" { ++ pub fn asctime_r(arg1: *const tm, arg2: *mut core::ffi::c_char) -> *mut core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ctime_r(arg1: *const time_t, arg2: *mut core::ffi::c_char) -> *mut core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn tzset(); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct itimerspec { ++ pub it_interval: timespec, ++ pub it_value: timespec, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of itimerspec"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of itimerspec"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: itimerspec::it_interval"] ++ [::core::mem::offset_of!(itimerspec, it_interval) - 0usize]; ++ ["Offset of field: itimerspec::it_value"] ++ [::core::mem::offset_of!(itimerspec, it_value) - 16usize]; ++}; ++unsafe extern "C" { ++ pub fn nanosleep(arg1: *const timespec, arg2: *mut timespec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_getres(arg1: clockid_t, arg2: *mut timespec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_gettime(arg1: clockid_t, arg2: *mut timespec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_settime(arg1: clockid_t, arg2: *const timespec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_nanosleep( ++ arg1: clockid_t, ++ arg2: core::ffi::c_int, ++ arg3: *const timespec, ++ arg4: *mut timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_getcpuclockid(arg1: pid_t, arg2: *mut clockid_t) -> core::ffi::c_int; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sigevent { ++ _unused: [u8; 0], ++} ++unsafe extern "C" { ++ pub fn timer_create( ++ arg1: clockid_t, ++ arg2: *mut sigevent, ++ arg3: *mut timer_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timer_delete(arg1: timer_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timer_settime( ++ arg1: timer_t, ++ arg2: core::ffi::c_int, ++ arg3: *const itimerspec, ++ arg4: *mut itimerspec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timer_gettime(arg1: timer_t, arg2: *mut itimerspec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timer_getoverrun(arg1: timer_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub static mut tzname: [*mut core::ffi::c_char; 2usize]; ++} ++unsafe extern "C" { ++ pub fn strptime( ++ arg1: *const core::ffi::c_char, ++ arg2: *const core::ffi::c_char, ++ arg3: *mut tm, ++ ) -> *mut core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub static mut daylight: core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub static mut timezone: core::ffi::c_long; ++} ++unsafe extern "C" { ++ pub static mut getdate_err: core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn getdate(arg1: *const core::ffi::c_char) -> *mut tm; ++} ++unsafe extern "C" { ++ pub fn stime(arg1: *const time_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timegm(arg1: *mut tm) -> time_t; ++} ++unsafe extern "C" { ++ pub fn pthread_create( ++ arg1: *mut pthread_t, ++ arg2: *const pthread_attr_t, ++ arg3: ::core::option::Option< ++ unsafe extern "C" fn(arg1: *mut core::ffi::c_void) -> *mut core::ffi::c_void, ++ >, ++ arg4: *mut core::ffi::c_void, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_detach(arg1: pthread_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_exit(arg1: *mut core::ffi::c_void); ++} ++unsafe extern "C" { ++ pub fn pthread_join(arg1: pthread_t, arg2: *mut *mut core::ffi::c_void) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_self() -> pthread_t; ++} ++unsafe extern "C" { ++ pub fn pthread_equal(arg1: pthread_t, arg2: pthread_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_setcancelstate( ++ arg1: core::ffi::c_int, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_setcanceltype( ++ arg1: core::ffi::c_int, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_testcancel(); ++} ++unsafe extern "C" { ++ pub fn pthread_cancel(arg1: pthread_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_getschedparam( ++ arg1: pthread_t, ++ arg2: *mut core::ffi::c_int, ++ arg3: *mut sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_setschedparam( ++ arg1: pthread_t, ++ arg2: core::ffi::c_int, ++ arg3: *const sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_setschedprio(arg1: pthread_t, arg2: core::ffi::c_int) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_once( ++ arg1: *mut pthread_once_t, ++ arg2: ::core::option::Option, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_init( ++ arg1: *mut pthread_mutex_t, ++ arg2: *const pthread_mutexattr_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_lock(arg1: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_unlock(arg1: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_trylock(arg1: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_timedlock( ++ arg1: *mut pthread_mutex_t, ++ arg2: *const timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_destroy(arg1: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_consistent(arg1: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_getprioceiling( ++ arg1: *const pthread_mutex_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_setprioceiling( ++ arg1: *mut pthread_mutex_t, ++ arg2: core::ffi::c_int, ++ arg3: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_init( ++ arg1: *mut pthread_cond_t, ++ arg2: *const pthread_condattr_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_destroy(arg1: *mut pthread_cond_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_wait( ++ arg1: *mut pthread_cond_t, ++ arg2: *mut pthread_mutex_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_timedwait( ++ arg1: *mut pthread_cond_t, ++ arg2: *mut pthread_mutex_t, ++ arg3: *const timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_broadcast(arg1: *mut pthread_cond_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_signal(arg1: *mut pthread_cond_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_init( ++ arg1: *mut pthread_rwlock_t, ++ arg2: *const pthread_rwlockattr_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_destroy(arg1: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_rdlock(arg1: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_tryrdlock(arg1: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_timedrdlock( ++ arg1: *mut pthread_rwlock_t, ++ arg2: *const timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_wrlock(arg1: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_trywrlock(arg1: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_timedwrlock( ++ arg1: *mut pthread_rwlock_t, ++ arg2: *const timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_unlock(arg1: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_init( ++ arg1: *mut pthread_spinlock_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_destroy(arg1: *mut pthread_spinlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_lock(arg1: *mut pthread_spinlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_trylock(arg1: *mut pthread_spinlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_unlock(arg1: *mut pthread_spinlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrier_init( ++ arg1: *mut pthread_barrier_t, ++ arg2: *const pthread_barrierattr_t, ++ arg3: core::ffi::c_uint, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrier_destroy(arg1: *mut pthread_barrier_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrier_wait(arg1: *mut pthread_barrier_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_key_create( ++ arg1: *mut pthread_key_t, ++ arg2: ::core::option::Option, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_key_delete(arg1: pthread_key_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_getspecific(arg1: pthread_key_t) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn pthread_setspecific( ++ arg1: pthread_key_t, ++ arg2: *const core::ffi::c_void, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_init(arg1: *mut pthread_attr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_destroy(arg1: *mut pthread_attr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getguardsize( ++ arg1: *const pthread_attr_t, ++ arg2: *mut usize, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setguardsize(arg1: *mut pthread_attr_t, arg2: usize) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getstacksize( ++ arg1: *const pthread_attr_t, ++ arg2: *mut usize, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setstacksize(arg1: *mut pthread_attr_t, arg2: usize) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getdetachstate( ++ arg1: *const pthread_attr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setdetachstate( ++ arg1: *mut pthread_attr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getstack( ++ arg1: *const pthread_attr_t, ++ arg2: *mut *mut core::ffi::c_void, ++ arg3: *mut usize, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setstack( ++ arg1: *mut pthread_attr_t, ++ arg2: *mut core::ffi::c_void, ++ arg3: usize, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getscope( ++ arg1: *const pthread_attr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setscope( ++ arg1: *mut pthread_attr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getschedpolicy( ++ arg1: *const pthread_attr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setschedpolicy( ++ arg1: *mut pthread_attr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getschedparam( ++ arg1: *const pthread_attr_t, ++ arg2: *mut sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setschedparam( ++ arg1: *mut pthread_attr_t, ++ arg2: *const sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getinheritsched( ++ arg1: *const pthread_attr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setinheritsched( ++ arg1: *mut pthread_attr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_destroy(arg1: *mut pthread_mutexattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_getprioceiling( ++ arg1: *const pthread_mutexattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_getprotocol( ++ arg1: *const pthread_mutexattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_getpshared( ++ arg1: *const pthread_mutexattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_getrobust( ++ arg1: *const pthread_mutexattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_gettype( ++ arg1: *const pthread_mutexattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_init(arg1: *mut pthread_mutexattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_setprioceiling( ++ arg1: *mut pthread_mutexattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_setprotocol( ++ arg1: *mut pthread_mutexattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_setpshared( ++ arg1: *mut pthread_mutexattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_setrobust( ++ arg1: *mut pthread_mutexattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_settype( ++ arg1: *mut pthread_mutexattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_init(arg1: *mut pthread_condattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_destroy(arg1: *mut pthread_condattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_setclock( ++ arg1: *mut pthread_condattr_t, ++ arg2: clockid_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_setpshared( ++ arg1: *mut pthread_condattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_getclock( ++ arg1: *const pthread_condattr_t, ++ arg2: *mut clockid_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_getpshared( ++ arg1: *const pthread_condattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlockattr_init(arg1: *mut pthread_rwlockattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlockattr_destroy(arg1: *mut pthread_rwlockattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlockattr_setpshared( ++ arg1: *mut pthread_rwlockattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlockattr_getpshared( ++ arg1: *const pthread_rwlockattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrierattr_destroy(arg1: *mut pthread_barrierattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrierattr_getpshared( ++ arg1: *const pthread_barrierattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrierattr_init(arg1: *mut pthread_barrierattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrierattr_setpshared( ++ arg1: *mut pthread_barrierattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_atfork( ++ arg1: ::core::option::Option, ++ arg2: ::core::option::Option, ++ arg3: ::core::option::Option, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_getconcurrency() -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_setconcurrency(arg1: core::ffi::c_int) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_getcpuclockid(arg1: pthread_t, arg2: *mut clockid_t) -> core::ffi::c_int; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __ptcb { ++ pub __f: ::core::option::Option, ++ pub __x: *mut core::ffi::c_void, ++ pub __next: *mut __ptcb, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __ptcb"][::core::mem::size_of::<__ptcb>() - 24usize]; ++ ["Alignment of __ptcb"][::core::mem::align_of::<__ptcb>() - 8usize]; ++ ["Offset of field: __ptcb::__f"][::core::mem::offset_of!(__ptcb, __f) - 0usize]; ++ ["Offset of field: __ptcb::__x"][::core::mem::offset_of!(__ptcb, __x) - 8usize]; ++ ["Offset of field: __ptcb::__next"][::core::mem::offset_of!(__ptcb, __next) - 16usize]; ++}; ++unsafe extern "C" { ++ pub fn _pthread_cleanup_push( ++ arg1: *mut __ptcb, ++ arg2: ::core::option::Option, ++ arg3: *mut core::ffi::c_void, ++ ); ++} ++unsafe extern "C" { ++ pub fn _pthread_cleanup_pop(arg1: *mut __ptcb, arg2: core::ffi::c_int); ++} ++pub type ma_pthread_t = pthread_t; ++pub type ma_pthread_mutex_t = pthread_mutex_t; ++pub type ma_pthread_cond_t = pthread_cond_t; ++pub type ma_wchar_win32 = ma_uint16; ++pub const ma_log_level_MA_LOG_LEVEL_DEBUG: ma_log_level = 4; ++pub const ma_log_level_MA_LOG_LEVEL_INFO: ma_log_level = 3; ++pub const ma_log_level_MA_LOG_LEVEL_WARNING: ma_log_level = 2; ++pub const ma_log_level_MA_LOG_LEVEL_ERROR: ma_log_level = 1; ++pub type ma_log_level = core::ffi::c_uint; ++pub type ma_channel = ma_uint8; ++pub const _ma_channel_position_MA_CHANNEL_NONE: _ma_channel_position = 0; ++pub const _ma_channel_position_MA_CHANNEL_MONO: _ma_channel_position = 1; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_LEFT: _ma_channel_position = 2; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_RIGHT: _ma_channel_position = 3; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_CENTER: _ma_channel_position = 4; ++pub const _ma_channel_position_MA_CHANNEL_LFE: _ma_channel_position = 5; ++pub const _ma_channel_position_MA_CHANNEL_BACK_LEFT: _ma_channel_position = 6; ++pub const _ma_channel_position_MA_CHANNEL_BACK_RIGHT: _ma_channel_position = 7; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_LEFT_CENTER: _ma_channel_position = 8; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_RIGHT_CENTER: _ma_channel_position = 9; ++pub const _ma_channel_position_MA_CHANNEL_BACK_CENTER: _ma_channel_position = 10; ++pub const _ma_channel_position_MA_CHANNEL_SIDE_LEFT: _ma_channel_position = 11; ++pub const _ma_channel_position_MA_CHANNEL_SIDE_RIGHT: _ma_channel_position = 12; ++pub const _ma_channel_position_MA_CHANNEL_TOP_CENTER: _ma_channel_position = 13; ++pub const _ma_channel_position_MA_CHANNEL_TOP_FRONT_LEFT: _ma_channel_position = 14; ++pub const _ma_channel_position_MA_CHANNEL_TOP_FRONT_CENTER: _ma_channel_position = 15; ++pub const _ma_channel_position_MA_CHANNEL_TOP_FRONT_RIGHT: _ma_channel_position = 16; ++pub const _ma_channel_position_MA_CHANNEL_TOP_BACK_LEFT: _ma_channel_position = 17; ++pub const _ma_channel_position_MA_CHANNEL_TOP_BACK_CENTER: _ma_channel_position = 18; ++pub const _ma_channel_position_MA_CHANNEL_TOP_BACK_RIGHT: _ma_channel_position = 19; ++pub const _ma_channel_position_MA_CHANNEL_AUX_0: _ma_channel_position = 20; ++pub const _ma_channel_position_MA_CHANNEL_AUX_1: _ma_channel_position = 21; ++pub const _ma_channel_position_MA_CHANNEL_AUX_2: _ma_channel_position = 22; ++pub const _ma_channel_position_MA_CHANNEL_AUX_3: _ma_channel_position = 23; ++pub const _ma_channel_position_MA_CHANNEL_AUX_4: _ma_channel_position = 24; ++pub const _ma_channel_position_MA_CHANNEL_AUX_5: _ma_channel_position = 25; ++pub const _ma_channel_position_MA_CHANNEL_AUX_6: _ma_channel_position = 26; ++pub const _ma_channel_position_MA_CHANNEL_AUX_7: _ma_channel_position = 27; ++pub const _ma_channel_position_MA_CHANNEL_AUX_8: _ma_channel_position = 28; ++pub const _ma_channel_position_MA_CHANNEL_AUX_9: _ma_channel_position = 29; ++pub const _ma_channel_position_MA_CHANNEL_AUX_10: _ma_channel_position = 30; ++pub const _ma_channel_position_MA_CHANNEL_AUX_11: _ma_channel_position = 31; ++pub const _ma_channel_position_MA_CHANNEL_AUX_12: _ma_channel_position = 32; ++pub const _ma_channel_position_MA_CHANNEL_AUX_13: _ma_channel_position = 33; ++pub const _ma_channel_position_MA_CHANNEL_AUX_14: _ma_channel_position = 34; ++pub const _ma_channel_position_MA_CHANNEL_AUX_15: _ma_channel_position = 35; ++pub const _ma_channel_position_MA_CHANNEL_AUX_16: _ma_channel_position = 36; ++pub const _ma_channel_position_MA_CHANNEL_AUX_17: _ma_channel_position = 37; ++pub const _ma_channel_position_MA_CHANNEL_AUX_18: _ma_channel_position = 38; ++pub const _ma_channel_position_MA_CHANNEL_AUX_19: _ma_channel_position = 39; ++pub const _ma_channel_position_MA_CHANNEL_AUX_20: _ma_channel_position = 40; ++pub const _ma_channel_position_MA_CHANNEL_AUX_21: _ma_channel_position = 41; ++pub const _ma_channel_position_MA_CHANNEL_AUX_22: _ma_channel_position = 42; ++pub const _ma_channel_position_MA_CHANNEL_AUX_23: _ma_channel_position = 43; ++pub const _ma_channel_position_MA_CHANNEL_AUX_24: _ma_channel_position = 44; ++pub const _ma_channel_position_MA_CHANNEL_AUX_25: _ma_channel_position = 45; ++pub const _ma_channel_position_MA_CHANNEL_AUX_26: _ma_channel_position = 46; ++pub const _ma_channel_position_MA_CHANNEL_AUX_27: _ma_channel_position = 47; ++pub const _ma_channel_position_MA_CHANNEL_AUX_28: _ma_channel_position = 48; ++pub const _ma_channel_position_MA_CHANNEL_AUX_29: _ma_channel_position = 49; ++pub const _ma_channel_position_MA_CHANNEL_AUX_30: _ma_channel_position = 50; ++pub const _ma_channel_position_MA_CHANNEL_AUX_31: _ma_channel_position = 51; ++pub const _ma_channel_position_MA_CHANNEL_LEFT: _ma_channel_position = 2; ++pub const _ma_channel_position_MA_CHANNEL_RIGHT: _ma_channel_position = 3; ++pub const _ma_channel_position_MA_CHANNEL_POSITION_COUNT: _ma_channel_position = 52; ++pub type _ma_channel_position = core::ffi::c_uint; ++pub const ma_result_MA_SUCCESS: ma_result = 0; ++pub const ma_result_MA_ERROR: ma_result = -1; ++pub const ma_result_MA_INVALID_ARGS: ma_result = -2; ++pub const ma_result_MA_INVALID_OPERATION: ma_result = -3; ++pub const ma_result_MA_OUT_OF_MEMORY: ma_result = -4; ++pub const ma_result_MA_OUT_OF_RANGE: ma_result = -5; ++pub const ma_result_MA_ACCESS_DENIED: ma_result = -6; ++pub const ma_result_MA_DOES_NOT_EXIST: ma_result = -7; ++pub const ma_result_MA_ALREADY_EXISTS: ma_result = -8; ++pub const ma_result_MA_TOO_MANY_OPEN_FILES: ma_result = -9; ++pub const ma_result_MA_INVALID_FILE: ma_result = -10; ++pub const ma_result_MA_TOO_BIG: ma_result = -11; ++pub const ma_result_MA_PATH_TOO_LONG: ma_result = -12; ++pub const ma_result_MA_NAME_TOO_LONG: ma_result = -13; ++pub const ma_result_MA_NOT_DIRECTORY: ma_result = -14; ++pub const ma_result_MA_IS_DIRECTORY: ma_result = -15; ++pub const ma_result_MA_DIRECTORY_NOT_EMPTY: ma_result = -16; ++pub const ma_result_MA_AT_END: ma_result = -17; ++pub const ma_result_MA_NO_SPACE: ma_result = -18; ++pub const ma_result_MA_BUSY: ma_result = -19; ++pub const ma_result_MA_IO_ERROR: ma_result = -20; ++pub const ma_result_MA_INTERRUPT: ma_result = -21; ++pub const ma_result_MA_UNAVAILABLE: ma_result = -22; ++pub const ma_result_MA_ALREADY_IN_USE: ma_result = -23; ++pub const ma_result_MA_BAD_ADDRESS: ma_result = -24; ++pub const ma_result_MA_BAD_SEEK: ma_result = -25; ++pub const ma_result_MA_BAD_PIPE: ma_result = -26; ++pub const ma_result_MA_DEADLOCK: ma_result = -27; ++pub const ma_result_MA_TOO_MANY_LINKS: ma_result = -28; ++pub const ma_result_MA_NOT_IMPLEMENTED: ma_result = -29; ++pub const ma_result_MA_NO_MESSAGE: ma_result = -30; ++pub const ma_result_MA_BAD_MESSAGE: ma_result = -31; ++pub const ma_result_MA_NO_DATA_AVAILABLE: ma_result = -32; ++pub const ma_result_MA_INVALID_DATA: ma_result = -33; ++pub const ma_result_MA_TIMEOUT: ma_result = -34; ++pub const ma_result_MA_NO_NETWORK: ma_result = -35; ++pub const ma_result_MA_NOT_UNIQUE: ma_result = -36; ++pub const ma_result_MA_NOT_SOCKET: ma_result = -37; ++pub const ma_result_MA_NO_ADDRESS: ma_result = -38; ++pub const ma_result_MA_BAD_PROTOCOL: ma_result = -39; ++pub const ma_result_MA_PROTOCOL_UNAVAILABLE: ma_result = -40; ++pub const ma_result_MA_PROTOCOL_NOT_SUPPORTED: ma_result = -41; ++pub const ma_result_MA_PROTOCOL_FAMILY_NOT_SUPPORTED: ma_result = -42; ++pub const ma_result_MA_ADDRESS_FAMILY_NOT_SUPPORTED: ma_result = -43; ++pub const ma_result_MA_SOCKET_NOT_SUPPORTED: ma_result = -44; ++pub const ma_result_MA_CONNECTION_RESET: ma_result = -45; ++pub const ma_result_MA_ALREADY_CONNECTED: ma_result = -46; ++pub const ma_result_MA_NOT_CONNECTED: ma_result = -47; ++pub const ma_result_MA_CONNECTION_REFUSED: ma_result = -48; ++pub const ma_result_MA_NO_HOST: ma_result = -49; ++pub const ma_result_MA_IN_PROGRESS: ma_result = -50; ++pub const ma_result_MA_CANCELLED: ma_result = -51; ++pub const ma_result_MA_MEMORY_ALREADY_MAPPED: ma_result = -52; ++pub const ma_result_MA_CRC_MISMATCH: ma_result = -100; ++pub const ma_result_MA_FORMAT_NOT_SUPPORTED: ma_result = -200; ++pub const ma_result_MA_DEVICE_TYPE_NOT_SUPPORTED: ma_result = -201; ++pub const ma_result_MA_SHARE_MODE_NOT_SUPPORTED: ma_result = -202; ++pub const ma_result_MA_NO_BACKEND: ma_result = -203; ++pub const ma_result_MA_NO_DEVICE: ma_result = -204; ++pub const ma_result_MA_API_NOT_FOUND: ma_result = -205; ++pub const ma_result_MA_INVALID_DEVICE_CONFIG: ma_result = -206; ++pub const ma_result_MA_LOOP: ma_result = -207; ++pub const ma_result_MA_BACKEND_NOT_ENABLED: ma_result = -208; ++pub const ma_result_MA_DEVICE_NOT_INITIALIZED: ma_result = -300; ++pub const ma_result_MA_DEVICE_ALREADY_INITIALIZED: ma_result = -301; ++pub const ma_result_MA_DEVICE_NOT_STARTED: ma_result = -302; ++pub const ma_result_MA_DEVICE_NOT_STOPPED: ma_result = -303; ++pub const ma_result_MA_FAILED_TO_INIT_BACKEND: ma_result = -400; ++pub const ma_result_MA_FAILED_TO_OPEN_BACKEND_DEVICE: ma_result = -401; ++pub const ma_result_MA_FAILED_TO_START_BACKEND_DEVICE: ma_result = -402; ++pub const ma_result_MA_FAILED_TO_STOP_BACKEND_DEVICE: ma_result = -403; ++pub type ma_result = core::ffi::c_int; ++pub const ma_stream_format_ma_stream_format_pcm: ma_stream_format = 0; ++pub type ma_stream_format = core::ffi::c_uint; ++pub const ma_stream_layout_ma_stream_layout_interleaved: ma_stream_layout = 0; ++pub const ma_stream_layout_ma_stream_layout_deinterleaved: ma_stream_layout = 1; ++pub type ma_stream_layout = core::ffi::c_uint; ++pub const ma_dither_mode_ma_dither_mode_none: ma_dither_mode = 0; ++pub const ma_dither_mode_ma_dither_mode_rectangle: ma_dither_mode = 1; ++pub const ma_dither_mode_ma_dither_mode_triangle: ma_dither_mode = 2; ++pub type ma_dither_mode = core::ffi::c_uint; ++pub const ma_format_ma_format_unknown: ma_format = 0; ++pub const ma_format_ma_format_u8: ma_format = 1; ++pub const ma_format_ma_format_s16: ma_format = 2; ++pub const ma_format_ma_format_s24: ma_format = 3; ++pub const ma_format_ma_format_s32: ma_format = 4; ++pub const ma_format_ma_format_f32: ma_format = 5; ++pub const ma_format_ma_format_count: ma_format = 6; ++pub type ma_format = core::ffi::c_uint; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_48000: ma_standard_sample_rate = 48000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_44100: ma_standard_sample_rate = 44100; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_32000: ma_standard_sample_rate = 32000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_24000: ma_standard_sample_rate = 24000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_22050: ma_standard_sample_rate = 22050; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_88200: ma_standard_sample_rate = 88200; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_96000: ma_standard_sample_rate = 96000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_176400: ma_standard_sample_rate = 176400; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_192000: ma_standard_sample_rate = 192000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_16000: ma_standard_sample_rate = 16000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_11025: ma_standard_sample_rate = 11025; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_8000: ma_standard_sample_rate = 8000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_352800: ma_standard_sample_rate = 352800; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_384000: ma_standard_sample_rate = 384000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_min: ma_standard_sample_rate = 8000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_max: ma_standard_sample_rate = 384000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_count: ma_standard_sample_rate = 14; ++pub type ma_standard_sample_rate = core::ffi::c_uint; ++pub const ma_channel_mix_mode_ma_channel_mix_mode_rectangular: ma_channel_mix_mode = 0; ++pub const ma_channel_mix_mode_ma_channel_mix_mode_simple: ma_channel_mix_mode = 1; ++pub const ma_channel_mix_mode_ma_channel_mix_mode_custom_weights: ma_channel_mix_mode = 2; ++pub const ma_channel_mix_mode_ma_channel_mix_mode_default: ma_channel_mix_mode = 0; ++pub type ma_channel_mix_mode = core::ffi::c_uint; ++pub const ma_standard_channel_map_ma_standard_channel_map_microsoft: ma_standard_channel_map = 0; ++pub const ma_standard_channel_map_ma_standard_channel_map_alsa: ma_standard_channel_map = 1; ++pub const ma_standard_channel_map_ma_standard_channel_map_rfc3551: ma_standard_channel_map = 2; ++pub const ma_standard_channel_map_ma_standard_channel_map_flac: ma_standard_channel_map = 3; ++pub const ma_standard_channel_map_ma_standard_channel_map_vorbis: ma_standard_channel_map = 4; ++pub const ma_standard_channel_map_ma_standard_channel_map_sound4: ma_standard_channel_map = 5; ++pub const ma_standard_channel_map_ma_standard_channel_map_sndio: ma_standard_channel_map = 6; ++pub const ma_standard_channel_map_ma_standard_channel_map_webaudio: ma_standard_channel_map = 3; ++pub const ma_standard_channel_map_ma_standard_channel_map_default: ma_standard_channel_map = 0; ++pub type ma_standard_channel_map = core::ffi::c_uint; ++pub const ma_performance_profile_ma_performance_profile_low_latency: ma_performance_profile = 0; ++pub const ma_performance_profile_ma_performance_profile_conservative: ma_performance_profile = 1; ++pub type ma_performance_profile = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_allocation_callbacks { ++ pub pUserData: *mut core::ffi::c_void, ++ pub onMalloc: ::core::option::Option< ++ unsafe extern "C" fn( ++ sz: usize, ++ pUserData: *mut core::ffi::c_void, ++ ) -> *mut core::ffi::c_void, ++ >, ++ pub onRealloc: ::core::option::Option< ++ unsafe extern "C" fn( ++ p: *mut core::ffi::c_void, ++ sz: usize, ++ pUserData: *mut core::ffi::c_void, ++ ) -> *mut core::ffi::c_void, ++ >, ++ pub onFree: ::core::option::Option< ++ unsafe extern "C" fn(p: *mut core::ffi::c_void, pUserData: *mut core::ffi::c_void), ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_allocation_callbacks"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_allocation_callbacks"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_allocation_callbacks::pUserData"] ++ [::core::mem::offset_of!(ma_allocation_callbacks, pUserData) - 0usize]; ++ ["Offset of field: ma_allocation_callbacks::onMalloc"] ++ [::core::mem::offset_of!(ma_allocation_callbacks, onMalloc) - 8usize]; ++ ["Offset of field: ma_allocation_callbacks::onRealloc"] ++ [::core::mem::offset_of!(ma_allocation_callbacks, onRealloc) - 16usize]; ++ ["Offset of field: ma_allocation_callbacks::onFree"] ++ [::core::mem::offset_of!(ma_allocation_callbacks, onFree) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lcg { ++ pub state: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lcg"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_lcg"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_lcg::state"][::core::mem::offset_of!(ma_lcg, state) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_uint32 { ++ pub value: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_uint32"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_uint32"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_uint32::value"] ++ [::core::mem::offset_of!(ma_atomic_uint32, value) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_int32 { ++ pub value: ma_int32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_int32"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_int32"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_int32::value"] ++ [::core::mem::offset_of!(ma_atomic_int32, value) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_uint64 { ++ pub value: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_uint64"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_atomic_uint64"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_atomic_uint64::value"] ++ [::core::mem::offset_of!(ma_atomic_uint64, value) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_float { ++ pub value: ma_float, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_float"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_float"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_float::value"] ++ [::core::mem::offset_of!(ma_atomic_float, value) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_bool32 { ++ pub value: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_bool32"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_bool32"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_bool32::value"] ++ [::core::mem::offset_of!(ma_atomic_bool32, value) - 0usize]; ++}; ++pub type ma_spinlock = ma_uint32; ++pub const ma_thread_priority_ma_thread_priority_idle: ma_thread_priority = -5; ++pub const ma_thread_priority_ma_thread_priority_lowest: ma_thread_priority = -4; ++pub const ma_thread_priority_ma_thread_priority_low: ma_thread_priority = -3; ++pub const ma_thread_priority_ma_thread_priority_normal: ma_thread_priority = -2; ++pub const ma_thread_priority_ma_thread_priority_high: ma_thread_priority = -1; ++pub const ma_thread_priority_ma_thread_priority_highest: ma_thread_priority = 0; ++pub const ma_thread_priority_ma_thread_priority_realtime: ma_thread_priority = 1; ++pub const ma_thread_priority_ma_thread_priority_default: ma_thread_priority = 0; ++pub type ma_thread_priority = core::ffi::c_int; ++pub type ma_thread = ma_pthread_t; ++pub type ma_mutex = ma_pthread_mutex_t; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_event { ++ pub value: ma_uint32, ++ pub lock: ma_pthread_mutex_t, ++ pub cond: ma_pthread_cond_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_event"][::core::mem::size_of::() - 96usize]; ++ ["Alignment of ma_event"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_event::value"][::core::mem::offset_of!(ma_event, value) - 0usize]; ++ ["Offset of field: ma_event::lock"][::core::mem::offset_of!(ma_event, lock) - 8usize]; ++ ["Offset of field: ma_event::cond"][::core::mem::offset_of!(ma_event, cond) - 48usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_semaphore { ++ pub value: core::ffi::c_int, ++ pub lock: ma_pthread_mutex_t, ++ pub cond: ma_pthread_cond_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_semaphore"][::core::mem::size_of::() - 96usize]; ++ ["Alignment of ma_semaphore"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_semaphore::value"][::core::mem::offset_of!(ma_semaphore, value) - 0usize]; ++ ["Offset of field: ma_semaphore::lock"][::core::mem::offset_of!(ma_semaphore, lock) - 8usize]; ++ ["Offset of field: ma_semaphore::cond"][::core::mem::offset_of!(ma_semaphore, cond) - 48usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_version(pMajor: *mut ma_uint32, pMinor: *mut ma_uint32, pRevision: *mut ma_uint32); ++} ++unsafe extern "C" { ++ pub fn ma_version_string() -> *const core::ffi::c_char; ++} ++pub type __gnuc_va_list = __BindgenOpaqueArray; ++pub type va_list = __BindgenOpaqueArray; ++pub type ma_log_callback_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ level: ma_uint32, ++ pMessage: *const core::ffi::c_char, ++ ), ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_log_callback { ++ pub onLog: ma_log_callback_proc, ++ pub pUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_log_callback"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_log_callback"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_log_callback::onLog"] ++ [::core::mem::offset_of!(ma_log_callback, onLog) - 0usize]; ++ ["Offset of field: ma_log_callback::pUserData"] ++ [::core::mem::offset_of!(ma_log_callback, pUserData) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_log_callback_init( ++ onLog: ma_log_callback_proc, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_log_callback; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_log { ++ pub callbacks: [ma_log_callback; 4usize], ++ pub callbackCount: ma_uint32, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub lock: ma_mutex, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_log"][::core::mem::size_of::() - 144usize]; ++ ["Alignment of ma_log"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_log::callbacks"][::core::mem::offset_of!(ma_log, callbacks) - 0usize]; ++ ["Offset of field: ma_log::callbackCount"] ++ [::core::mem::offset_of!(ma_log, callbackCount) - 64usize]; ++ ["Offset of field: ma_log::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_log, allocationCallbacks) - 72usize]; ++ ["Offset of field: ma_log::lock"][::core::mem::offset_of!(ma_log, lock) - 104usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_log_init( ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pLog: *mut ma_log, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_uninit(pLog: *mut ma_log); ++} ++unsafe extern "C" { ++ pub fn ma_log_register_callback(pLog: *mut ma_log, callback: ma_log_callback) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_unregister_callback(pLog: *mut ma_log, callback: ma_log_callback) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_post( ++ pLog: *mut ma_log, ++ level: ma_uint32, ++ pMessage: *const core::ffi::c_char, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_postv( ++ pLog: *mut ma_log, ++ level: ma_uint32, ++ pFormat: *const core::ffi::c_char, ++ args: va_list, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_postf( ++ pLog: *mut ma_log, ++ level: ma_uint32, ++ pFormat: *const core::ffi::c_char, ++ ... ++ ) -> ma_result; ++} ++#[doc = "Biquad Filtering"] ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_biquad_coefficient { ++ pub f32_: f32, ++ pub s32: ma_int32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad_coefficient"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_biquad_coefficient"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_biquad_coefficient::f32_"] ++ [::core::mem::offset_of!(ma_biquad_coefficient, f32_) - 0usize]; ++ ["Offset of field: ma_biquad_coefficient::s32"] ++ [::core::mem::offset_of!(ma_biquad_coefficient, s32) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_biquad_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub b0: f64, ++ pub b1: f64, ++ pub b2: f64, ++ pub a0: f64, ++ pub a1: f64, ++ pub a2: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad_config"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_biquad_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_biquad_config::format"] ++ [::core::mem::offset_of!(ma_biquad_config, format) - 0usize]; ++ ["Offset of field: ma_biquad_config::channels"] ++ [::core::mem::offset_of!(ma_biquad_config, channels) - 4usize]; ++ ["Offset of field: ma_biquad_config::b0"] ++ [::core::mem::offset_of!(ma_biquad_config, b0) - 8usize]; ++ ["Offset of field: ma_biquad_config::b1"] ++ [::core::mem::offset_of!(ma_biquad_config, b1) - 16usize]; ++ ["Offset of field: ma_biquad_config::b2"] ++ [::core::mem::offset_of!(ma_biquad_config, b2) - 24usize]; ++ ["Offset of field: ma_biquad_config::a0"] ++ [::core::mem::offset_of!(ma_biquad_config, a0) - 32usize]; ++ ["Offset of field: ma_biquad_config::a1"] ++ [::core::mem::offset_of!(ma_biquad_config, a1) - 40usize]; ++ ["Offset of field: ma_biquad_config::a2"] ++ [::core::mem::offset_of!(ma_biquad_config, a2) - 48usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_biquad_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ b0: f64, ++ b1: f64, ++ b2: f64, ++ a0: f64, ++ a1: f64, ++ a2: f64, ++ ) -> ma_biquad_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_biquad { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub b0: ma_biquad_coefficient, ++ pub b1: ma_biquad_coefficient, ++ pub b2: ma_biquad_coefficient, ++ pub a1: ma_biquad_coefficient, ++ pub a2: ma_biquad_coefficient, ++ pub pR1: *mut ma_biquad_coefficient, ++ pub pR2: *mut ma_biquad_coefficient, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_biquad"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_biquad::format"][::core::mem::offset_of!(ma_biquad, format) - 0usize]; ++ ["Offset of field: ma_biquad::channels"][::core::mem::offset_of!(ma_biquad, channels) - 4usize]; ++ ["Offset of field: ma_biquad::b0"][::core::mem::offset_of!(ma_biquad, b0) - 8usize]; ++ ["Offset of field: ma_biquad::b1"][::core::mem::offset_of!(ma_biquad, b1) - 12usize]; ++ ["Offset of field: ma_biquad::b2"][::core::mem::offset_of!(ma_biquad, b2) - 16usize]; ++ ["Offset of field: ma_biquad::a1"][::core::mem::offset_of!(ma_biquad, a1) - 20usize]; ++ ["Offset of field: ma_biquad::a2"][::core::mem::offset_of!(ma_biquad, a2) - 24usize]; ++ ["Offset of field: ma_biquad::pR1"][::core::mem::offset_of!(ma_biquad, pR1) - 32usize]; ++ ["Offset of field: ma_biquad::pR2"][::core::mem::offset_of!(ma_biquad, pR2) - 40usize]; ++ ["Offset of field: ma_biquad::_pHeap"][::core::mem::offset_of!(ma_biquad, _pHeap) - 48usize]; ++ ["Offset of field: ma_biquad::_ownsHeap"] ++ [::core::mem::offset_of!(ma_biquad, _ownsHeap) - 56usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_biquad_get_heap_size( ++ pConfig: *const ma_biquad_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_init_preallocated( ++ pConfig: *const ma_biquad_config, ++ pHeap: *mut core::ffi::c_void, ++ pBQ: *mut ma_biquad, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_init( ++ pConfig: *const ma_biquad_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pBQ: *mut ma_biquad, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_uninit( ++ pBQ: *mut ma_biquad, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_biquad_reinit(pConfig: *const ma_biquad_config, pBQ: *mut ma_biquad) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_clear_cache(pBQ: *mut ma_biquad) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_process_pcm_frames( ++ pBQ: *mut ma_biquad, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_get_latency(pBQ: *const ma_biquad) -> ma_uint32; ++} ++#[doc = "Low-Pass Filtering"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf1_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub q: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf1_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_lpf1_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf1_config::format"] ++ [::core::mem::offset_of!(ma_lpf1_config, format) - 0usize]; ++ ["Offset of field: ma_lpf1_config::channels"] ++ [::core::mem::offset_of!(ma_lpf1_config, channels) - 4usize]; ++ ["Offset of field: ma_lpf1_config::sampleRate"] ++ [::core::mem::offset_of!(ma_lpf1_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_lpf1_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_lpf1_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_lpf1_config::q"][::core::mem::offset_of!(ma_lpf1_config, q) - 24usize]; ++}; ++#[doc = "Low-Pass Filtering"] ++pub type ma_lpf2_config = ma_lpf1_config; ++unsafe extern "C" { ++ pub fn ma_lpf1_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ ) -> ma_lpf1_config; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ q: f64, ++ ) -> ma_lpf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_lpf1 { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub a: ma_biquad_coefficient, ++ pub pR1: *mut ma_biquad_coefficient, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf1"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_lpf1"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf1::format"][::core::mem::offset_of!(ma_lpf1, format) - 0usize]; ++ ["Offset of field: ma_lpf1::channels"][::core::mem::offset_of!(ma_lpf1, channels) - 4usize]; ++ ["Offset of field: ma_lpf1::a"][::core::mem::offset_of!(ma_lpf1, a) - 8usize]; ++ ["Offset of field: ma_lpf1::pR1"][::core::mem::offset_of!(ma_lpf1, pR1) - 16usize]; ++ ["Offset of field: ma_lpf1::_pHeap"][::core::mem::offset_of!(ma_lpf1, _pHeap) - 24usize]; ++ ["Offset of field: ma_lpf1::_ownsHeap"][::core::mem::offset_of!(ma_lpf1, _ownsHeap) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf1_get_heap_size( ++ pConfig: *const ma_lpf1_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_init_preallocated( ++ pConfig: *const ma_lpf1_config, ++ pHeap: *mut core::ffi::c_void, ++ pLPF: *mut ma_lpf1, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_init( ++ pConfig: *const ma_lpf1_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pLPF: *mut ma_lpf1, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_uninit(pLPF: *mut ma_lpf1, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_reinit(pConfig: *const ma_lpf1_config, pLPF: *mut ma_lpf1) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_clear_cache(pLPF: *mut ma_lpf1) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_process_pcm_frames( ++ pLPF: *mut ma_lpf1, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_get_latency(pLPF: *const ma_lpf1) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_lpf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_lpf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf2::bq"][::core::mem::offset_of!(ma_lpf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf2_get_heap_size( ++ pConfig: *const ma_lpf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_init_preallocated( ++ pConfig: *const ma_lpf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pHPF: *mut ma_lpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_init( ++ pConfig: *const ma_lpf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pLPF: *mut ma_lpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_uninit(pLPF: *mut ma_lpf2, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_reinit(pConfig: *const ma_lpf2_config, pLPF: *mut ma_lpf2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_clear_cache(pLPF: *mut ma_lpf2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_process_pcm_frames( ++ pLPF: *mut ma_lpf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_get_latency(pLPF: *const ma_lpf2) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub order: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_lpf_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf_config::format"] ++ [::core::mem::offset_of!(ma_lpf_config, format) - 0usize]; ++ ["Offset of field: ma_lpf_config::channels"] ++ [::core::mem::offset_of!(ma_lpf_config, channels) - 4usize]; ++ ["Offset of field: ma_lpf_config::sampleRate"] ++ [::core::mem::offset_of!(ma_lpf_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_lpf_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_lpf_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_lpf_config::order"] ++ [::core::mem::offset_of!(ma_lpf_config, order) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_lpf_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub lpf1Count: ma_uint32, ++ pub lpf2Count: ma_uint32, ++ pub pLPF1: *mut ma_lpf1, ++ pub pLPF2: *mut ma_lpf2, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_lpf"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf::format"][::core::mem::offset_of!(ma_lpf, format) - 0usize]; ++ ["Offset of field: ma_lpf::channels"][::core::mem::offset_of!(ma_lpf, channels) - 4usize]; ++ ["Offset of field: ma_lpf::sampleRate"][::core::mem::offset_of!(ma_lpf, sampleRate) - 8usize]; ++ ["Offset of field: ma_lpf::lpf1Count"][::core::mem::offset_of!(ma_lpf, lpf1Count) - 12usize]; ++ ["Offset of field: ma_lpf::lpf2Count"][::core::mem::offset_of!(ma_lpf, lpf2Count) - 16usize]; ++ ["Offset of field: ma_lpf::pLPF1"][::core::mem::offset_of!(ma_lpf, pLPF1) - 24usize]; ++ ["Offset of field: ma_lpf::pLPF2"][::core::mem::offset_of!(ma_lpf, pLPF2) - 32usize]; ++ ["Offset of field: ma_lpf::_pHeap"][::core::mem::offset_of!(ma_lpf, _pHeap) - 40usize]; ++ ["Offset of field: ma_lpf::_ownsHeap"][::core::mem::offset_of!(ma_lpf, _ownsHeap) - 48usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf_get_heap_size( ++ pConfig: *const ma_lpf_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_init_preallocated( ++ pConfig: *const ma_lpf_config, ++ pHeap: *mut core::ffi::c_void, ++ pLPF: *mut ma_lpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_init( ++ pConfig: *const ma_lpf_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pLPF: *mut ma_lpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_uninit(pLPF: *mut ma_lpf, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_lpf_reinit(pConfig: *const ma_lpf_config, pLPF: *mut ma_lpf) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_clear_cache(pLPF: *mut ma_lpf) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_process_pcm_frames( ++ pLPF: *mut ma_lpf, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_get_latency(pLPF: *const ma_lpf) -> ma_uint32; ++} ++#[doc = "High-Pass Filtering"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf1_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub q: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf1_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_hpf1_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf1_config::format"] ++ [::core::mem::offset_of!(ma_hpf1_config, format) - 0usize]; ++ ["Offset of field: ma_hpf1_config::channels"] ++ [::core::mem::offset_of!(ma_hpf1_config, channels) - 4usize]; ++ ["Offset of field: ma_hpf1_config::sampleRate"] ++ [::core::mem::offset_of!(ma_hpf1_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_hpf1_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_hpf1_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_hpf1_config::q"][::core::mem::offset_of!(ma_hpf1_config, q) - 24usize]; ++}; ++#[doc = "High-Pass Filtering"] ++pub type ma_hpf2_config = ma_hpf1_config; ++unsafe extern "C" { ++ pub fn ma_hpf1_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ ) -> ma_hpf1_config; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ q: f64, ++ ) -> ma_hpf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_hpf1 { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub a: ma_biquad_coefficient, ++ pub pR1: *mut ma_biquad_coefficient, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf1"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_hpf1"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf1::format"][::core::mem::offset_of!(ma_hpf1, format) - 0usize]; ++ ["Offset of field: ma_hpf1::channels"][::core::mem::offset_of!(ma_hpf1, channels) - 4usize]; ++ ["Offset of field: ma_hpf1::a"][::core::mem::offset_of!(ma_hpf1, a) - 8usize]; ++ ["Offset of field: ma_hpf1::pR1"][::core::mem::offset_of!(ma_hpf1, pR1) - 16usize]; ++ ["Offset of field: ma_hpf1::_pHeap"][::core::mem::offset_of!(ma_hpf1, _pHeap) - 24usize]; ++ ["Offset of field: ma_hpf1::_ownsHeap"][::core::mem::offset_of!(ma_hpf1, _ownsHeap) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf1_get_heap_size( ++ pConfig: *const ma_hpf1_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_init_preallocated( ++ pConfig: *const ma_hpf1_config, ++ pHeap: *mut core::ffi::c_void, ++ pLPF: *mut ma_hpf1, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_init( ++ pConfig: *const ma_hpf1_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pHPF: *mut ma_hpf1, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_uninit(pHPF: *mut ma_hpf1, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_reinit(pConfig: *const ma_hpf1_config, pHPF: *mut ma_hpf1) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_process_pcm_frames( ++ pHPF: *mut ma_hpf1, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_get_latency(pHPF: *const ma_hpf1) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_hpf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_hpf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf2::bq"][::core::mem::offset_of!(ma_hpf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf2_get_heap_size( ++ pConfig: *const ma_hpf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_init_preallocated( ++ pConfig: *const ma_hpf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pHPF: *mut ma_hpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_init( ++ pConfig: *const ma_hpf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pHPF: *mut ma_hpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_uninit(pHPF: *mut ma_hpf2, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_reinit(pConfig: *const ma_hpf2_config, pHPF: *mut ma_hpf2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_process_pcm_frames( ++ pHPF: *mut ma_hpf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_get_latency(pHPF: *const ma_hpf2) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub order: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_hpf_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf_config::format"] ++ [::core::mem::offset_of!(ma_hpf_config, format) - 0usize]; ++ ["Offset of field: ma_hpf_config::channels"] ++ [::core::mem::offset_of!(ma_hpf_config, channels) - 4usize]; ++ ["Offset of field: ma_hpf_config::sampleRate"] ++ [::core::mem::offset_of!(ma_hpf_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_hpf_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_hpf_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_hpf_config::order"] ++ [::core::mem::offset_of!(ma_hpf_config, order) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_hpf_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub hpf1Count: ma_uint32, ++ pub hpf2Count: ma_uint32, ++ pub pHPF1: *mut ma_hpf1, ++ pub pHPF2: *mut ma_hpf2, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_hpf"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf::format"][::core::mem::offset_of!(ma_hpf, format) - 0usize]; ++ ["Offset of field: ma_hpf::channels"][::core::mem::offset_of!(ma_hpf, channels) - 4usize]; ++ ["Offset of field: ma_hpf::sampleRate"][::core::mem::offset_of!(ma_hpf, sampleRate) - 8usize]; ++ ["Offset of field: ma_hpf::hpf1Count"][::core::mem::offset_of!(ma_hpf, hpf1Count) - 12usize]; ++ ["Offset of field: ma_hpf::hpf2Count"][::core::mem::offset_of!(ma_hpf, hpf2Count) - 16usize]; ++ ["Offset of field: ma_hpf::pHPF1"][::core::mem::offset_of!(ma_hpf, pHPF1) - 24usize]; ++ ["Offset of field: ma_hpf::pHPF2"][::core::mem::offset_of!(ma_hpf, pHPF2) - 32usize]; ++ ["Offset of field: ma_hpf::_pHeap"][::core::mem::offset_of!(ma_hpf, _pHeap) - 40usize]; ++ ["Offset of field: ma_hpf::_ownsHeap"][::core::mem::offset_of!(ma_hpf, _ownsHeap) - 48usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf_get_heap_size( ++ pConfig: *const ma_hpf_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_init_preallocated( ++ pConfig: *const ma_hpf_config, ++ pHeap: *mut core::ffi::c_void, ++ pLPF: *mut ma_hpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_init( ++ pConfig: *const ma_hpf_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pHPF: *mut ma_hpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_uninit(pHPF: *mut ma_hpf, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_hpf_reinit(pConfig: *const ma_hpf_config, pHPF: *mut ma_hpf) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_process_pcm_frames( ++ pHPF: *mut ma_hpf, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_get_latency(pHPF: *const ma_hpf) -> ma_uint32; ++} ++#[doc = "Band-Pass Filtering"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub q: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf2_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_bpf2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf2_config::format"] ++ [::core::mem::offset_of!(ma_bpf2_config, format) - 0usize]; ++ ["Offset of field: ma_bpf2_config::channels"] ++ [::core::mem::offset_of!(ma_bpf2_config, channels) - 4usize]; ++ ["Offset of field: ma_bpf2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_bpf2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_bpf2_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_bpf2_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_bpf2_config::q"][::core::mem::offset_of!(ma_bpf2_config, q) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ q: f64, ++ ) -> ma_bpf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_bpf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_bpf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf2::bq"][::core::mem::offset_of!(ma_bpf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf2_get_heap_size( ++ pConfig: *const ma_bpf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_init_preallocated( ++ pConfig: *const ma_bpf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pBPF: *mut ma_bpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_init( ++ pConfig: *const ma_bpf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pBPF: *mut ma_bpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_uninit(pBPF: *mut ma_bpf2, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_reinit(pConfig: *const ma_bpf2_config, pBPF: *mut ma_bpf2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_process_pcm_frames( ++ pBPF: *mut ma_bpf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_get_latency(pBPF: *const ma_bpf2) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub order: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_bpf_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf_config::format"] ++ [::core::mem::offset_of!(ma_bpf_config, format) - 0usize]; ++ ["Offset of field: ma_bpf_config::channels"] ++ [::core::mem::offset_of!(ma_bpf_config, channels) - 4usize]; ++ ["Offset of field: ma_bpf_config::sampleRate"] ++ [::core::mem::offset_of!(ma_bpf_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_bpf_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_bpf_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_bpf_config::order"] ++ [::core::mem::offset_of!(ma_bpf_config, order) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_bpf_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub bpf2Count: ma_uint32, ++ pub pBPF2: *mut ma_bpf2, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_bpf"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf::format"][::core::mem::offset_of!(ma_bpf, format) - 0usize]; ++ ["Offset of field: ma_bpf::channels"][::core::mem::offset_of!(ma_bpf, channels) - 4usize]; ++ ["Offset of field: ma_bpf::bpf2Count"][::core::mem::offset_of!(ma_bpf, bpf2Count) - 8usize]; ++ ["Offset of field: ma_bpf::pBPF2"][::core::mem::offset_of!(ma_bpf, pBPF2) - 16usize]; ++ ["Offset of field: ma_bpf::_pHeap"][::core::mem::offset_of!(ma_bpf, _pHeap) - 24usize]; ++ ["Offset of field: ma_bpf::_ownsHeap"][::core::mem::offset_of!(ma_bpf, _ownsHeap) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf_get_heap_size( ++ pConfig: *const ma_bpf_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_init_preallocated( ++ pConfig: *const ma_bpf_config, ++ pHeap: *mut core::ffi::c_void, ++ pBPF: *mut ma_bpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_init( ++ pConfig: *const ma_bpf_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pBPF: *mut ma_bpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_uninit(pBPF: *mut ma_bpf, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_bpf_reinit(pConfig: *const ma_bpf_config, pBPF: *mut ma_bpf) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_process_pcm_frames( ++ pBPF: *mut ma_bpf, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_get_latency(pBPF: *const ma_bpf) -> ma_uint32; ++} ++#[doc = "Notching Filter"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_notch2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub q: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_notch2_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_notch2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_notch2_config::format"] ++ [::core::mem::offset_of!(ma_notch2_config, format) - 0usize]; ++ ["Offset of field: ma_notch2_config::channels"] ++ [::core::mem::offset_of!(ma_notch2_config, channels) - 4usize]; ++ ["Offset of field: ma_notch2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_notch2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_notch2_config::q"] ++ [::core::mem::offset_of!(ma_notch2_config, q) - 16usize]; ++ ["Offset of field: ma_notch2_config::frequency"] ++ [::core::mem::offset_of!(ma_notch2_config, frequency) - 24usize]; ++}; ++#[doc = "Notching Filter"] ++pub type ma_notch_config = ma_notch2_config; ++unsafe extern "C" { ++ pub fn ma_notch2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ q: f64, ++ frequency: f64, ++ ) -> ma_notch2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_notch2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_notch2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_notch2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_notch2::bq"][::core::mem::offset_of!(ma_notch2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_notch2_get_heap_size( ++ pConfig: *const ma_notch2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_init_preallocated( ++ pConfig: *const ma_notch2_config, ++ pHeap: *mut core::ffi::c_void, ++ pFilter: *mut ma_notch2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_init( ++ pConfig: *const ma_notch2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pFilter: *mut ma_notch2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_uninit( ++ pFilter: *mut ma_notch2, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_notch2_reinit(pConfig: *const ma_notch2_config, pFilter: *mut ma_notch2) ++ -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_process_pcm_frames( ++ pFilter: *mut ma_notch2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_get_latency(pFilter: *const ma_notch2) -> ma_uint32; ++} ++#[doc = "Peaking EQ Filter"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_peak2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub gainDB: f64, ++ pub q: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_peak2_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_peak2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_peak2_config::format"] ++ [::core::mem::offset_of!(ma_peak2_config, format) - 0usize]; ++ ["Offset of field: ma_peak2_config::channels"] ++ [::core::mem::offset_of!(ma_peak2_config, channels) - 4usize]; ++ ["Offset of field: ma_peak2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_peak2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_peak2_config::gainDB"] ++ [::core::mem::offset_of!(ma_peak2_config, gainDB) - 16usize]; ++ ["Offset of field: ma_peak2_config::q"][::core::mem::offset_of!(ma_peak2_config, q) - 24usize]; ++ ["Offset of field: ma_peak2_config::frequency"] ++ [::core::mem::offset_of!(ma_peak2_config, frequency) - 32usize]; ++}; ++#[doc = "Peaking EQ Filter"] ++pub type ma_peak_config = ma_peak2_config; ++unsafe extern "C" { ++ pub fn ma_peak2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ q: f64, ++ frequency: f64, ++ ) -> ma_peak2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_peak2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_peak2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_peak2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_peak2::bq"][::core::mem::offset_of!(ma_peak2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_peak2_get_heap_size( ++ pConfig: *const ma_peak2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_init_preallocated( ++ pConfig: *const ma_peak2_config, ++ pHeap: *mut core::ffi::c_void, ++ pFilter: *mut ma_peak2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_init( ++ pConfig: *const ma_peak2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pFilter: *mut ma_peak2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_uninit( ++ pFilter: *mut ma_peak2, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_peak2_reinit(pConfig: *const ma_peak2_config, pFilter: *mut ma_peak2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_process_pcm_frames( ++ pFilter: *mut ma_peak2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_get_latency(pFilter: *const ma_peak2) -> ma_uint32; ++} ++#[doc = "Low Shelf Filter"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_loshelf2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub gainDB: f64, ++ pub shelfSlope: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_loshelf2_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_loshelf2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_loshelf2_config::format"] ++ [::core::mem::offset_of!(ma_loshelf2_config, format) - 0usize]; ++ ["Offset of field: ma_loshelf2_config::channels"] ++ [::core::mem::offset_of!(ma_loshelf2_config, channels) - 4usize]; ++ ["Offset of field: ma_loshelf2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_loshelf2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_loshelf2_config::gainDB"] ++ [::core::mem::offset_of!(ma_loshelf2_config, gainDB) - 16usize]; ++ ["Offset of field: ma_loshelf2_config::shelfSlope"] ++ [::core::mem::offset_of!(ma_loshelf2_config, shelfSlope) - 24usize]; ++ ["Offset of field: ma_loshelf2_config::frequency"] ++ [::core::mem::offset_of!(ma_loshelf2_config, frequency) - 32usize]; ++}; ++#[doc = "Low Shelf Filter"] ++pub type ma_loshelf_config = ma_loshelf2_config; ++unsafe extern "C" { ++ pub fn ma_loshelf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ shelfSlope: f64, ++ frequency: f64, ++ ) -> ma_loshelf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_loshelf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_loshelf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_loshelf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_loshelf2::bq"][::core::mem::offset_of!(ma_loshelf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_loshelf2_get_heap_size( ++ pConfig: *const ma_loshelf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_init_preallocated( ++ pConfig: *const ma_loshelf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pFilter: *mut ma_loshelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_init( ++ pConfig: *const ma_loshelf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pFilter: *mut ma_loshelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_uninit( ++ pFilter: *mut ma_loshelf2, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_reinit( ++ pConfig: *const ma_loshelf2_config, ++ pFilter: *mut ma_loshelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_process_pcm_frames( ++ pFilter: *mut ma_loshelf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_get_latency(pFilter: *const ma_loshelf2) -> ma_uint32; ++} ++#[doc = "High Shelf Filter"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hishelf2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub gainDB: f64, ++ pub shelfSlope: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hishelf2_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_hishelf2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hishelf2_config::format"] ++ [::core::mem::offset_of!(ma_hishelf2_config, format) - 0usize]; ++ ["Offset of field: ma_hishelf2_config::channels"] ++ [::core::mem::offset_of!(ma_hishelf2_config, channels) - 4usize]; ++ ["Offset of field: ma_hishelf2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_hishelf2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_hishelf2_config::gainDB"] ++ [::core::mem::offset_of!(ma_hishelf2_config, gainDB) - 16usize]; ++ ["Offset of field: ma_hishelf2_config::shelfSlope"] ++ [::core::mem::offset_of!(ma_hishelf2_config, shelfSlope) - 24usize]; ++ ["Offset of field: ma_hishelf2_config::frequency"] ++ [::core::mem::offset_of!(ma_hishelf2_config, frequency) - 32usize]; ++}; ++#[doc = "High Shelf Filter"] ++pub type ma_hishelf_config = ma_hishelf2_config; ++unsafe extern "C" { ++ pub fn ma_hishelf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ shelfSlope: f64, ++ frequency: f64, ++ ) -> ma_hishelf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_hishelf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hishelf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_hishelf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hishelf2::bq"][::core::mem::offset_of!(ma_hishelf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hishelf2_get_heap_size( ++ pConfig: *const ma_hishelf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_init_preallocated( ++ pConfig: *const ma_hishelf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pFilter: *mut ma_hishelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_init( ++ pConfig: *const ma_hishelf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pFilter: *mut ma_hishelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_uninit( ++ pFilter: *mut ma_hishelf2, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_reinit( ++ pConfig: *const ma_hishelf2_config, ++ pFilter: *mut ma_hishelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_process_pcm_frames( ++ pFilter: *mut ma_hishelf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_get_latency(pFilter: *const ma_hishelf2) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_delay_config { ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub delayInFrames: ma_uint32, ++ pub delayStart: ma_bool32, ++ pub wet: f32, ++ pub dry: f32, ++ pub decay: f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_delay_config"][::core::mem::size_of::() - 28usize]; ++ ["Alignment of ma_delay_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_delay_config::channels"] ++ [::core::mem::offset_of!(ma_delay_config, channels) - 0usize]; ++ ["Offset of field: ma_delay_config::sampleRate"] ++ [::core::mem::offset_of!(ma_delay_config, sampleRate) - 4usize]; ++ ["Offset of field: ma_delay_config::delayInFrames"] ++ [::core::mem::offset_of!(ma_delay_config, delayInFrames) - 8usize]; ++ ["Offset of field: ma_delay_config::delayStart"] ++ [::core::mem::offset_of!(ma_delay_config, delayStart) - 12usize]; ++ ["Offset of field: ma_delay_config::wet"] ++ [::core::mem::offset_of!(ma_delay_config, wet) - 16usize]; ++ ["Offset of field: ma_delay_config::dry"] ++ [::core::mem::offset_of!(ma_delay_config, dry) - 20usize]; ++ ["Offset of field: ma_delay_config::decay"] ++ [::core::mem::offset_of!(ma_delay_config, decay) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_delay_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ delayInFrames: ma_uint32, ++ decay: f32, ++ ) -> ma_delay_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_delay { ++ pub config: ma_delay_config, ++ pub cursor: ma_uint32, ++ pub bufferSizeInFrames: ma_uint32, ++ pub pBuffer: *mut f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_delay"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_delay"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_delay::config"][::core::mem::offset_of!(ma_delay, config) - 0usize]; ++ ["Offset of field: ma_delay::cursor"][::core::mem::offset_of!(ma_delay, cursor) - 28usize]; ++ ["Offset of field: ma_delay::bufferSizeInFrames"] ++ [::core::mem::offset_of!(ma_delay, bufferSizeInFrames) - 32usize]; ++ ["Offset of field: ma_delay::pBuffer"][::core::mem::offset_of!(ma_delay, pBuffer) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_delay_init( ++ pConfig: *const ma_delay_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pDelay: *mut ma_delay, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_delay_uninit( ++ pDelay: *mut ma_delay, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_delay_process_pcm_frames( ++ pDelay: *mut ma_delay, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_delay_set_wet(pDelay: *mut ma_delay, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_get_wet(pDelay: *const ma_delay) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_delay_set_dry(pDelay: *mut ma_delay, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_get_dry(pDelay: *const ma_delay) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_delay_set_decay(pDelay: *mut ma_delay, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_get_decay(pDelay: *const ma_delay) -> f32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_gainer_config { ++ pub channels: ma_uint32, ++ pub smoothTimeInFrames: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_gainer_config"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_gainer_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_gainer_config::channels"] ++ [::core::mem::offset_of!(ma_gainer_config, channels) - 0usize]; ++ ["Offset of field: ma_gainer_config::smoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_gainer_config, smoothTimeInFrames) - 4usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_gainer_config_init( ++ channels: ma_uint32, ++ smoothTimeInFrames: ma_uint32, ++ ) -> ma_gainer_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_gainer { ++ pub config: ma_gainer_config, ++ pub t: ma_uint32, ++ pub masterVolume: f32, ++ pub pOldGains: *mut f32, ++ pub pNewGains: *mut f32, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_gainer"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_gainer"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_gainer::config"][::core::mem::offset_of!(ma_gainer, config) - 0usize]; ++ ["Offset of field: ma_gainer::t"][::core::mem::offset_of!(ma_gainer, t) - 8usize]; ++ ["Offset of field: ma_gainer::masterVolume"] ++ [::core::mem::offset_of!(ma_gainer, masterVolume) - 12usize]; ++ ["Offset of field: ma_gainer::pOldGains"] ++ [::core::mem::offset_of!(ma_gainer, pOldGains) - 16usize]; ++ ["Offset of field: ma_gainer::pNewGains"] ++ [::core::mem::offset_of!(ma_gainer, pNewGains) - 24usize]; ++ ["Offset of field: ma_gainer::_pHeap"][::core::mem::offset_of!(ma_gainer, _pHeap) - 32usize]; ++ ["Offset of field: ma_gainer::_ownsHeap"] ++ [::core::mem::offset_of!(ma_gainer, _ownsHeap) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_gainer_get_heap_size( ++ pConfig: *const ma_gainer_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_init_preallocated( ++ pConfig: *const ma_gainer_config, ++ pHeap: *mut core::ffi::c_void, ++ pGainer: *mut ma_gainer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_init( ++ pConfig: *const ma_gainer_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pGainer: *mut ma_gainer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_uninit( ++ pGainer: *mut ma_gainer, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_gainer_process_pcm_frames( ++ pGainer: *mut ma_gainer, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_set_gain(pGainer: *mut ma_gainer, newGain: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_set_gains(pGainer: *mut ma_gainer, pNewGains: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_set_master_volume(pGainer: *mut ma_gainer, volume: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_get_master_volume(pGainer: *const ma_gainer, pVolume: *mut f32) -> ma_result; ++} ++pub const ma_pan_mode_ma_pan_mode_balance: ma_pan_mode = 0; ++pub const ma_pan_mode_ma_pan_mode_pan: ma_pan_mode = 1; ++pub type ma_pan_mode = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_panner_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub mode: ma_pan_mode, ++ pub pan: f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_panner_config"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_panner_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_panner_config::format"] ++ [::core::mem::offset_of!(ma_panner_config, format) - 0usize]; ++ ["Offset of field: ma_panner_config::channels"] ++ [::core::mem::offset_of!(ma_panner_config, channels) - 4usize]; ++ ["Offset of field: ma_panner_config::mode"] ++ [::core::mem::offset_of!(ma_panner_config, mode) - 8usize]; ++ ["Offset of field: ma_panner_config::pan"] ++ [::core::mem::offset_of!(ma_panner_config, pan) - 12usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_panner_config_init(format: ma_format, channels: ma_uint32) -> ma_panner_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_panner { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub mode: ma_pan_mode, ++ pub pan: f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_panner"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_panner"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_panner::format"][::core::mem::offset_of!(ma_panner, format) - 0usize]; ++ ["Offset of field: ma_panner::channels"][::core::mem::offset_of!(ma_panner, channels) - 4usize]; ++ ["Offset of field: ma_panner::mode"][::core::mem::offset_of!(ma_panner, mode) - 8usize]; ++ ["Offset of field: ma_panner::pan"][::core::mem::offset_of!(ma_panner, pan) - 12usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_panner_init(pConfig: *const ma_panner_config, pPanner: *mut ma_panner) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_panner_process_pcm_frames( ++ pPanner: *mut ma_panner, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_panner_set_mode(pPanner: *mut ma_panner, mode: ma_pan_mode); ++} ++unsafe extern "C" { ++ pub fn ma_panner_get_mode(pPanner: *const ma_panner) -> ma_pan_mode; ++} ++unsafe extern "C" { ++ pub fn ma_panner_set_pan(pPanner: *mut ma_panner, pan: f32); ++} ++unsafe extern "C" { ++ pub fn ma_panner_get_pan(pPanner: *const ma_panner) -> f32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_fader_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_fader_config"][::core::mem::size_of::() - 12usize]; ++ ["Alignment of ma_fader_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_fader_config::format"] ++ [::core::mem::offset_of!(ma_fader_config, format) - 0usize]; ++ ["Offset of field: ma_fader_config::channels"] ++ [::core::mem::offset_of!(ma_fader_config, channels) - 4usize]; ++ ["Offset of field: ma_fader_config::sampleRate"] ++ [::core::mem::offset_of!(ma_fader_config, sampleRate) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_fader_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_fader_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_fader { ++ pub config: ma_fader_config, ++ pub volumeBeg: f32, ++ pub volumeEnd: f32, ++ pub lengthInFrames: ma_uint64, ++ pub cursorInFrames: ma_int64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_fader"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_fader"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_fader::config"][::core::mem::offset_of!(ma_fader, config) - 0usize]; ++ ["Offset of field: ma_fader::volumeBeg"] ++ [::core::mem::offset_of!(ma_fader, volumeBeg) - 12usize]; ++ ["Offset of field: ma_fader::volumeEnd"] ++ [::core::mem::offset_of!(ma_fader, volumeEnd) - 16usize]; ++ ["Offset of field: ma_fader::lengthInFrames"] ++ [::core::mem::offset_of!(ma_fader, lengthInFrames) - 24usize]; ++ ["Offset of field: ma_fader::cursorInFrames"] ++ [::core::mem::offset_of!(ma_fader, cursorInFrames) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_fader_init(pConfig: *const ma_fader_config, pFader: *mut ma_fader) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fader_process_pcm_frames( ++ pFader: *mut ma_fader, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fader_get_data_format( ++ pFader: *const ma_fader, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_fader_set_fade( ++ pFader: *mut ma_fader, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ lengthInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_fader_set_fade_ex( ++ pFader: *mut ma_fader, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ lengthInFrames: ma_uint64, ++ startOffsetInFrames: ma_int64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_fader_get_current_volume(pFader: *const ma_fader) -> f32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_vec3f { ++ pub x: f32, ++ pub y: f32, ++ pub z: f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_vec3f"][::core::mem::size_of::() - 12usize]; ++ ["Alignment of ma_vec3f"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_vec3f::x"][::core::mem::offset_of!(ma_vec3f, x) - 0usize]; ++ ["Offset of field: ma_vec3f::y"][::core::mem::offset_of!(ma_vec3f, y) - 4usize]; ++ ["Offset of field: ma_vec3f::z"][::core::mem::offset_of!(ma_vec3f, z) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_vec3f { ++ pub v: ma_vec3f, ++ pub lock: ma_spinlock, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_vec3f"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_atomic_vec3f"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_vec3f::v"][::core::mem::offset_of!(ma_atomic_vec3f, v) - 0usize]; ++ ["Offset of field: ma_atomic_vec3f::lock"] ++ [::core::mem::offset_of!(ma_atomic_vec3f, lock) - 12usize]; ++}; ++pub const ma_attenuation_model_ma_attenuation_model_none: ma_attenuation_model = 0; ++pub const ma_attenuation_model_ma_attenuation_model_inverse: ma_attenuation_model = 1; ++pub const ma_attenuation_model_ma_attenuation_model_linear: ma_attenuation_model = 2; ++pub const ma_attenuation_model_ma_attenuation_model_exponential: ma_attenuation_model = 3; ++pub type ma_attenuation_model = core::ffi::c_uint; ++pub const ma_positioning_ma_positioning_absolute: ma_positioning = 0; ++pub const ma_positioning_ma_positioning_relative: ma_positioning = 1; ++pub type ma_positioning = core::ffi::c_uint; ++pub const ma_handedness_ma_handedness_right: ma_handedness = 0; ++pub const ma_handedness_ma_handedness_left: ma_handedness = 1; ++pub type ma_handedness = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_spatializer_listener_config { ++ pub channelsOut: ma_uint32, ++ pub pChannelMapOut: *mut ma_channel, ++ pub handedness: ma_handedness, ++ pub coneInnerAngleInRadians: f32, ++ pub coneOuterAngleInRadians: f32, ++ pub coneOuterGain: f32, ++ pub speedOfSound: f32, ++ pub worldUp: ma_vec3f, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_spatializer_listener_config"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_spatializer_listener_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_spatializer_listener_config::channelsOut"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, channelsOut) - 0usize]; ++ ["Offset of field: ma_spatializer_listener_config::pChannelMapOut"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, pChannelMapOut) - 8usize]; ++ ["Offset of field: ma_spatializer_listener_config::handedness"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, handedness) - 16usize]; ++ ["Offset of field: ma_spatializer_listener_config::coneInnerAngleInRadians"][::core::mem::offset_of!( ++ ma_spatializer_listener_config, ++ coneInnerAngleInRadians ++ ) - 20usize]; ++ ["Offset of field: ma_spatializer_listener_config::coneOuterAngleInRadians"][::core::mem::offset_of!( ++ ma_spatializer_listener_config, ++ coneOuterAngleInRadians ++ ) - 24usize]; ++ ["Offset of field: ma_spatializer_listener_config::coneOuterGain"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, coneOuterGain) - 28usize]; ++ ["Offset of field: ma_spatializer_listener_config::speedOfSound"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, speedOfSound) - 32usize]; ++ ["Offset of field: ma_spatializer_listener_config::worldUp"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, worldUp) - 36usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_config_init( ++ channelsOut: ma_uint32, ++ ) -> ma_spatializer_listener_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_spatializer_listener { ++ pub config: ma_spatializer_listener_config, ++ pub position: ma_atomic_vec3f, ++ pub direction: ma_atomic_vec3f, ++ pub velocity: ma_atomic_vec3f, ++ pub isEnabled: ma_bool32, ++ pub _ownsHeap: ma_bool32, ++ pub _pHeap: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_spatializer_listener"] ++ [::core::mem::size_of::() - 112usize]; ++ ["Alignment of ma_spatializer_listener"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_spatializer_listener::config"] ++ [::core::mem::offset_of!(ma_spatializer_listener, config) - 0usize]; ++ ["Offset of field: ma_spatializer_listener::position"] ++ [::core::mem::offset_of!(ma_spatializer_listener, position) - 48usize]; ++ ["Offset of field: ma_spatializer_listener::direction"] ++ [::core::mem::offset_of!(ma_spatializer_listener, direction) - 64usize]; ++ ["Offset of field: ma_spatializer_listener::velocity"] ++ [::core::mem::offset_of!(ma_spatializer_listener, velocity) - 80usize]; ++ ["Offset of field: ma_spatializer_listener::isEnabled"] ++ [::core::mem::offset_of!(ma_spatializer_listener, isEnabled) - 96usize]; ++ ["Offset of field: ma_spatializer_listener::_ownsHeap"] ++ [::core::mem::offset_of!(ma_spatializer_listener, _ownsHeap) - 100usize]; ++ ["Offset of field: ma_spatializer_listener::_pHeap"] ++ [::core::mem::offset_of!(ma_spatializer_listener, _pHeap) - 104usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_heap_size( ++ pConfig: *const ma_spatializer_listener_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_init_preallocated( ++ pConfig: *const ma_spatializer_listener_config, ++ pHeap: *mut core::ffi::c_void, ++ pListener: *mut ma_spatializer_listener, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_init( ++ pConfig: *const ma_spatializer_listener_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pListener: *mut ma_spatializer_listener, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_uninit( ++ pListener: *mut ma_spatializer_listener, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_channel_map( ++ pListener: *mut ma_spatializer_listener, ++ ) -> *mut ma_channel; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_cone( ++ pListener: *mut ma_spatializer_listener, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_cone( ++ pListener: *const ma_spatializer_listener, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_position( ++ pListener: *mut ma_spatializer_listener, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_position( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_direction( ++ pListener: *mut ma_spatializer_listener, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_direction( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_velocity( ++ pListener: *mut ma_spatializer_listener, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_velocity( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_speed_of_sound( ++ pListener: *mut ma_spatializer_listener, ++ speedOfSound: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_speed_of_sound( ++ pListener: *const ma_spatializer_listener, ++ ) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_world_up( ++ pListener: *mut ma_spatializer_listener, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_world_up( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_enabled( ++ pListener: *mut ma_spatializer_listener, ++ isEnabled: ma_bool32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_is_enabled( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_bool32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_spatializer_config { ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub pChannelMapIn: *mut ma_channel, ++ pub attenuationModel: ma_attenuation_model, ++ pub positioning: ma_positioning, ++ pub handedness: ma_handedness, ++ pub minGain: f32, ++ pub maxGain: f32, ++ pub minDistance: f32, ++ pub maxDistance: f32, ++ pub rolloff: f32, ++ pub coneInnerAngleInRadians: f32, ++ pub coneOuterAngleInRadians: f32, ++ pub coneOuterGain: f32, ++ pub dopplerFactor: f32, ++ pub directionalAttenuationFactor: f32, ++ pub minSpatializationChannelGain: f32, ++ pub gainSmoothTimeInFrames: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_spatializer_config"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_spatializer_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_spatializer_config::channelsIn"] ++ [::core::mem::offset_of!(ma_spatializer_config, channelsIn) - 0usize]; ++ ["Offset of field: ma_spatializer_config::channelsOut"] ++ [::core::mem::offset_of!(ma_spatializer_config, channelsOut) - 4usize]; ++ ["Offset of field: ma_spatializer_config::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_spatializer_config, pChannelMapIn) - 8usize]; ++ ["Offset of field: ma_spatializer_config::attenuationModel"] ++ [::core::mem::offset_of!(ma_spatializer_config, attenuationModel) - 16usize]; ++ ["Offset of field: ma_spatializer_config::positioning"] ++ [::core::mem::offset_of!(ma_spatializer_config, positioning) - 20usize]; ++ ["Offset of field: ma_spatializer_config::handedness"] ++ [::core::mem::offset_of!(ma_spatializer_config, handedness) - 24usize]; ++ ["Offset of field: ma_spatializer_config::minGain"] ++ [::core::mem::offset_of!(ma_spatializer_config, minGain) - 28usize]; ++ ["Offset of field: ma_spatializer_config::maxGain"] ++ [::core::mem::offset_of!(ma_spatializer_config, maxGain) - 32usize]; ++ ["Offset of field: ma_spatializer_config::minDistance"] ++ [::core::mem::offset_of!(ma_spatializer_config, minDistance) - 36usize]; ++ ["Offset of field: ma_spatializer_config::maxDistance"] ++ [::core::mem::offset_of!(ma_spatializer_config, maxDistance) - 40usize]; ++ ["Offset of field: ma_spatializer_config::rolloff"] ++ [::core::mem::offset_of!(ma_spatializer_config, rolloff) - 44usize]; ++ ["Offset of field: ma_spatializer_config::coneInnerAngleInRadians"] ++ [::core::mem::offset_of!(ma_spatializer_config, coneInnerAngleInRadians) - 48usize]; ++ ["Offset of field: ma_spatializer_config::coneOuterAngleInRadians"] ++ [::core::mem::offset_of!(ma_spatializer_config, coneOuterAngleInRadians) - 52usize]; ++ ["Offset of field: ma_spatializer_config::coneOuterGain"] ++ [::core::mem::offset_of!(ma_spatializer_config, coneOuterGain) - 56usize]; ++ ["Offset of field: ma_spatializer_config::dopplerFactor"] ++ [::core::mem::offset_of!(ma_spatializer_config, dopplerFactor) - 60usize]; ++ ["Offset of field: ma_spatializer_config::directionalAttenuationFactor"] ++ [::core::mem::offset_of!(ma_spatializer_config, directionalAttenuationFactor) - 64usize]; ++ ["Offset of field: ma_spatializer_config::minSpatializationChannelGain"] ++ [::core::mem::offset_of!(ma_spatializer_config, minSpatializationChannelGain) - 68usize]; ++ ["Offset of field: ma_spatializer_config::gainSmoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_spatializer_config, gainSmoothTimeInFrames) - 72usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_spatializer_config_init( ++ channelsIn: ma_uint32, ++ channelsOut: ma_uint32, ++ ) -> ma_spatializer_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_spatializer { ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub pChannelMapIn: *mut ma_channel, ++ pub attenuationModel: ma_attenuation_model, ++ pub positioning: ma_positioning, ++ pub handedness: ma_handedness, ++ pub minGain: f32, ++ pub maxGain: f32, ++ pub minDistance: f32, ++ pub maxDistance: f32, ++ pub rolloff: f32, ++ pub coneInnerAngleInRadians: f32, ++ pub coneOuterAngleInRadians: f32, ++ pub coneOuterGain: f32, ++ pub dopplerFactor: f32, ++ pub directionalAttenuationFactor: f32, ++ pub gainSmoothTimeInFrames: ma_uint32, ++ pub position: ma_atomic_vec3f, ++ pub direction: ma_atomic_vec3f, ++ pub velocity: ma_atomic_vec3f, ++ pub dopplerPitch: f32, ++ pub minSpatializationChannelGain: f32, ++ pub gainer: ma_gainer, ++ pub pNewChannelGainsOut: *mut f32, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_spatializer"][::core::mem::size_of::() - 200usize]; ++ ["Alignment of ma_spatializer"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_spatializer::channelsIn"] ++ [::core::mem::offset_of!(ma_spatializer, channelsIn) - 0usize]; ++ ["Offset of field: ma_spatializer::channelsOut"] ++ [::core::mem::offset_of!(ma_spatializer, channelsOut) - 4usize]; ++ ["Offset of field: ma_spatializer::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_spatializer, pChannelMapIn) - 8usize]; ++ ["Offset of field: ma_spatializer::attenuationModel"] ++ [::core::mem::offset_of!(ma_spatializer, attenuationModel) - 16usize]; ++ ["Offset of field: ma_spatializer::positioning"] ++ [::core::mem::offset_of!(ma_spatializer, positioning) - 20usize]; ++ ["Offset of field: ma_spatializer::handedness"] ++ [::core::mem::offset_of!(ma_spatializer, handedness) - 24usize]; ++ ["Offset of field: ma_spatializer::minGain"] ++ [::core::mem::offset_of!(ma_spatializer, minGain) - 28usize]; ++ ["Offset of field: ma_spatializer::maxGain"] ++ [::core::mem::offset_of!(ma_spatializer, maxGain) - 32usize]; ++ ["Offset of field: ma_spatializer::minDistance"] ++ [::core::mem::offset_of!(ma_spatializer, minDistance) - 36usize]; ++ ["Offset of field: ma_spatializer::maxDistance"] ++ [::core::mem::offset_of!(ma_spatializer, maxDistance) - 40usize]; ++ ["Offset of field: ma_spatializer::rolloff"] ++ [::core::mem::offset_of!(ma_spatializer, rolloff) - 44usize]; ++ ["Offset of field: ma_spatializer::coneInnerAngleInRadians"] ++ [::core::mem::offset_of!(ma_spatializer, coneInnerAngleInRadians) - 48usize]; ++ ["Offset of field: ma_spatializer::coneOuterAngleInRadians"] ++ [::core::mem::offset_of!(ma_spatializer, coneOuterAngleInRadians) - 52usize]; ++ ["Offset of field: ma_spatializer::coneOuterGain"] ++ [::core::mem::offset_of!(ma_spatializer, coneOuterGain) - 56usize]; ++ ["Offset of field: ma_spatializer::dopplerFactor"] ++ [::core::mem::offset_of!(ma_spatializer, dopplerFactor) - 60usize]; ++ ["Offset of field: ma_spatializer::directionalAttenuationFactor"] ++ [::core::mem::offset_of!(ma_spatializer, directionalAttenuationFactor) - 64usize]; ++ ["Offset of field: ma_spatializer::gainSmoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_spatializer, gainSmoothTimeInFrames) - 68usize]; ++ ["Offset of field: ma_spatializer::position"] ++ [::core::mem::offset_of!(ma_spatializer, position) - 72usize]; ++ ["Offset of field: ma_spatializer::direction"] ++ [::core::mem::offset_of!(ma_spatializer, direction) - 88usize]; ++ ["Offset of field: ma_spatializer::velocity"] ++ [::core::mem::offset_of!(ma_spatializer, velocity) - 104usize]; ++ ["Offset of field: ma_spatializer::dopplerPitch"] ++ [::core::mem::offset_of!(ma_spatializer, dopplerPitch) - 120usize]; ++ ["Offset of field: ma_spatializer::minSpatializationChannelGain"] ++ [::core::mem::offset_of!(ma_spatializer, minSpatializationChannelGain) - 124usize]; ++ ["Offset of field: ma_spatializer::gainer"] ++ [::core::mem::offset_of!(ma_spatializer, gainer) - 128usize]; ++ ["Offset of field: ma_spatializer::pNewChannelGainsOut"] ++ [::core::mem::offset_of!(ma_spatializer, pNewChannelGainsOut) - 176usize]; ++ ["Offset of field: ma_spatializer::_pHeap"] ++ [::core::mem::offset_of!(ma_spatializer, _pHeap) - 184usize]; ++ ["Offset of field: ma_spatializer::_ownsHeap"] ++ [::core::mem::offset_of!(ma_spatializer, _ownsHeap) - 192usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_spatializer_get_heap_size( ++ pConfig: *const ma_spatializer_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_init_preallocated( ++ pConfig: *const ma_spatializer_config, ++ pHeap: *mut core::ffi::c_void, ++ pSpatializer: *mut ma_spatializer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_init( ++ pConfig: *const ma_spatializer_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pSpatializer: *mut ma_spatializer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_uninit( ++ pSpatializer: *mut ma_spatializer, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_process_pcm_frames( ++ pSpatializer: *mut ma_spatializer, ++ pListener: *mut ma_spatializer_listener, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_master_volume( ++ pSpatializer: *mut ma_spatializer, ++ volume: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_master_volume( ++ pSpatializer: *const ma_spatializer, ++ pVolume: *mut f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_input_channels(pSpatializer: *const ma_spatializer) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_output_channels(pSpatializer: *const ma_spatializer) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_attenuation_model( ++ pSpatializer: *mut ma_spatializer, ++ attenuationModel: ma_attenuation_model, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_attenuation_model( ++ pSpatializer: *const ma_spatializer, ++ ) -> ma_attenuation_model; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_positioning( ++ pSpatializer: *mut ma_spatializer, ++ positioning: ma_positioning, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_positioning(pSpatializer: *const ma_spatializer) -> ma_positioning; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_rolloff(pSpatializer: *mut ma_spatializer, rolloff: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_rolloff(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_min_gain(pSpatializer: *mut ma_spatializer, minGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_min_gain(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_max_gain(pSpatializer: *mut ma_spatializer, maxGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_max_gain(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_min_distance(pSpatializer: *mut ma_spatializer, minDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_min_distance(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_max_distance(pSpatializer: *mut ma_spatializer, maxDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_max_distance(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_cone( ++ pSpatializer: *mut ma_spatializer, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_cone( ++ pSpatializer: *const ma_spatializer, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_doppler_factor(pSpatializer: *mut ma_spatializer, dopplerFactor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_doppler_factor(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_directional_attenuation_factor( ++ pSpatializer: *mut ma_spatializer, ++ directionalAttenuationFactor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_directional_attenuation_factor( ++ pSpatializer: *const ma_spatializer, ++ ) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_position(pSpatializer: *mut ma_spatializer, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_position(pSpatializer: *const ma_spatializer) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_direction(pSpatializer: *mut ma_spatializer, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_direction(pSpatializer: *const ma_spatializer) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_velocity(pSpatializer: *mut ma_spatializer, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_velocity(pSpatializer: *const ma_spatializer) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_relative_position_and_direction( ++ pSpatializer: *const ma_spatializer, ++ pListener: *const ma_spatializer_listener, ++ pRelativePos: *mut ma_vec3f, ++ pRelativeDir: *mut ma_vec3f, ++ ); ++} ++#[doc = "Resampling"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_linear_resampler_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub lpfOrder: ma_uint32, ++ pub lpfNyquistFactor: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_linear_resampler_config"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_linear_resampler_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_linear_resampler_config::format"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, format) - 0usize]; ++ ["Offset of field: ma_linear_resampler_config::channels"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, channels) - 4usize]; ++ ["Offset of field: ma_linear_resampler_config::sampleRateIn"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, sampleRateIn) - 8usize]; ++ ["Offset of field: ma_linear_resampler_config::sampleRateOut"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, sampleRateOut) - 12usize]; ++ ["Offset of field: ma_linear_resampler_config::lpfOrder"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, lpfOrder) - 16usize]; ++ ["Offset of field: ma_linear_resampler_config::lpfNyquistFactor"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, lpfNyquistFactor) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_linear_resampler_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_linear_resampler_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_linear_resampler { ++ pub config: ma_linear_resampler_config, ++ pub inAdvanceInt: ma_uint32, ++ pub inAdvanceFrac: ma_uint32, ++ pub inTimeInt: ma_uint32, ++ pub inTimeFrac: ma_uint32, ++ pub x0: ma_linear_resampler__bindgen_ty_1, ++ pub x1: ma_linear_resampler__bindgen_ty_2, ++ pub lpf: ma_lpf, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_linear_resampler__bindgen_ty_1 { ++ pub f32_: *mut f32, ++ pub s16: *mut ma_int16, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_linear_resampler__bindgen_ty_1"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_linear_resampler__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_linear_resampler__bindgen_ty_1::f32_"] ++ [::core::mem::offset_of!(ma_linear_resampler__bindgen_ty_1, f32_) - 0usize]; ++ ["Offset of field: ma_linear_resampler__bindgen_ty_1::s16"] ++ [::core::mem::offset_of!(ma_linear_resampler__bindgen_ty_1, s16) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_linear_resampler__bindgen_ty_2 { ++ pub f32_: *mut f32, ++ pub s16: *mut ma_int16, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_linear_resampler__bindgen_ty_2"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_linear_resampler__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_linear_resampler__bindgen_ty_2::f32_"] ++ [::core::mem::offset_of!(ma_linear_resampler__bindgen_ty_2, f32_) - 0usize]; ++ ["Offset of field: ma_linear_resampler__bindgen_ty_2::s16"] ++ [::core::mem::offset_of!(ma_linear_resampler__bindgen_ty_2, s16) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_linear_resampler"][::core::mem::size_of::() - 136usize]; ++ ["Alignment of ma_linear_resampler"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_linear_resampler::config"] ++ [::core::mem::offset_of!(ma_linear_resampler, config) - 0usize]; ++ ["Offset of field: ma_linear_resampler::inAdvanceInt"] ++ [::core::mem::offset_of!(ma_linear_resampler, inAdvanceInt) - 32usize]; ++ ["Offset of field: ma_linear_resampler::inAdvanceFrac"] ++ [::core::mem::offset_of!(ma_linear_resampler, inAdvanceFrac) - 36usize]; ++ ["Offset of field: ma_linear_resampler::inTimeInt"] ++ [::core::mem::offset_of!(ma_linear_resampler, inTimeInt) - 40usize]; ++ ["Offset of field: ma_linear_resampler::inTimeFrac"] ++ [::core::mem::offset_of!(ma_linear_resampler, inTimeFrac) - 44usize]; ++ ["Offset of field: ma_linear_resampler::x0"] ++ [::core::mem::offset_of!(ma_linear_resampler, x0) - 48usize]; ++ ["Offset of field: ma_linear_resampler::x1"] ++ [::core::mem::offset_of!(ma_linear_resampler, x1) - 56usize]; ++ ["Offset of field: ma_linear_resampler::lpf"] ++ [::core::mem::offset_of!(ma_linear_resampler, lpf) - 64usize]; ++ ["Offset of field: ma_linear_resampler::_pHeap"] ++ [::core::mem::offset_of!(ma_linear_resampler, _pHeap) - 120usize]; ++ ["Offset of field: ma_linear_resampler::_ownsHeap"] ++ [::core::mem::offset_of!(ma_linear_resampler, _ownsHeap) - 128usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_heap_size( ++ pConfig: *const ma_linear_resampler_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_init_preallocated( ++ pConfig: *const ma_linear_resampler_config, ++ pHeap: *mut core::ffi::c_void, ++ pResampler: *mut ma_linear_resampler, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_init( ++ pConfig: *const ma_linear_resampler_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pResampler: *mut ma_linear_resampler, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_uninit( ++ pResampler: *mut ma_linear_resampler, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_process_pcm_frames( ++ pResampler: *mut ma_linear_resampler, ++ pFramesIn: *const core::ffi::c_void, ++ pFrameCountIn: *mut ma_uint64, ++ pFramesOut: *mut core::ffi::c_void, ++ pFrameCountOut: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_set_rate( ++ pResampler: *mut ma_linear_resampler, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_set_rate_ratio( ++ pResampler: *mut ma_linear_resampler, ++ ratioInOut: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_input_latency( ++ pResampler: *const ma_linear_resampler, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_output_latency( ++ pResampler: *const ma_linear_resampler, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_required_input_frame_count( ++ pResampler: *const ma_linear_resampler, ++ outputFrameCount: ma_uint64, ++ pInputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_expected_output_frame_count( ++ pResampler: *const ma_linear_resampler, ++ inputFrameCount: ma_uint64, ++ pOutputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_reset(pResampler: *mut ma_linear_resampler) -> ma_result; ++} ++pub type ma_resampling_backend = core::ffi::c_void; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resampling_backend_vtable { ++ pub onGetHeapSize: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_resampler_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result, ++ >, ++ pub onInit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_resampler_config, ++ pHeap: *mut core::ffi::c_void, ++ ppBackend: *mut *mut ma_resampling_backend, ++ ) -> ma_result, ++ >, ++ pub onUninit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_resampling_backend, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ), ++ >, ++ pub onProcess: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_resampling_backend, ++ pFramesIn: *const core::ffi::c_void, ++ pFrameCountIn: *mut ma_uint64, ++ pFramesOut: *mut core::ffi::c_void, ++ pFrameCountOut: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onSetRate: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_resampling_backend, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_result, ++ >, ++ pub onGetInputLatency: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *const ma_resampling_backend, ++ ) -> ma_uint64, ++ >, ++ pub onGetOutputLatency: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *const ma_resampling_backend, ++ ) -> ma_uint64, ++ >, ++ pub onGetRequiredInputFrameCount: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *const ma_resampling_backend, ++ outputFrameCount: ma_uint64, ++ pInputFrameCount: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onGetExpectedOutputFrameCount: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *const ma_resampling_backend, ++ inputFrameCount: ma_uint64, ++ pOutputFrameCount: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onReset: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_resampling_backend, ++ ) -> ma_result, ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampling_backend_vtable"] ++ [::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_resampling_backend_vtable"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetHeapSize"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onGetHeapSize) - 0usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onInit"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onInit) - 8usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onUninit"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onUninit) - 16usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onProcess"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onProcess) - 24usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onSetRate"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onSetRate) - 32usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetInputLatency"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onGetInputLatency) - 40usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetOutputLatency"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onGetOutputLatency) - 48usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetRequiredInputFrameCount"][::core::mem::offset_of!( ++ ma_resampling_backend_vtable, ++ onGetRequiredInputFrameCount ++ ) - 56usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetExpectedOutputFrameCount"][::core::mem::offset_of!( ++ ma_resampling_backend_vtable, ++ onGetExpectedOutputFrameCount ++ ) - 64usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onReset"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onReset) - 72usize]; ++}; ++pub const ma_resample_algorithm_ma_resample_algorithm_linear: ma_resample_algorithm = 0; ++pub const ma_resample_algorithm_ma_resample_algorithm_custom: ma_resample_algorithm = 1; ++pub type ma_resample_algorithm = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resampler_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub algorithm: ma_resample_algorithm, ++ pub pBackendVTable: *mut ma_resampling_backend_vtable, ++ pub pBackendUserData: *mut core::ffi::c_void, ++ pub linear: ma_resampler_config__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resampler_config__bindgen_ty_1 { ++ pub lpfOrder: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampler_config__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_resampler_config__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_resampler_config__bindgen_ty_1::lpfOrder"] ++ [::core::mem::offset_of!(ma_resampler_config__bindgen_ty_1, lpfOrder) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampler_config"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_resampler_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resampler_config::format"] ++ [::core::mem::offset_of!(ma_resampler_config, format) - 0usize]; ++ ["Offset of field: ma_resampler_config::channels"] ++ [::core::mem::offset_of!(ma_resampler_config, channels) - 4usize]; ++ ["Offset of field: ma_resampler_config::sampleRateIn"] ++ [::core::mem::offset_of!(ma_resampler_config, sampleRateIn) - 8usize]; ++ ["Offset of field: ma_resampler_config::sampleRateOut"] ++ [::core::mem::offset_of!(ma_resampler_config, sampleRateOut) - 12usize]; ++ ["Offset of field: ma_resampler_config::algorithm"] ++ [::core::mem::offset_of!(ma_resampler_config, algorithm) - 16usize]; ++ ["Offset of field: ma_resampler_config::pBackendVTable"] ++ [::core::mem::offset_of!(ma_resampler_config, pBackendVTable) - 24usize]; ++ ["Offset of field: ma_resampler_config::pBackendUserData"] ++ [::core::mem::offset_of!(ma_resampler_config, pBackendUserData) - 32usize]; ++ ["Offset of field: ma_resampler_config::linear"] ++ [::core::mem::offset_of!(ma_resampler_config, linear) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resampler_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ algorithm: ma_resample_algorithm, ++ ) -> ma_resampler_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resampler { ++ pub pBackend: *mut ma_resampling_backend, ++ pub pBackendVTable: *mut ma_resampling_backend_vtable, ++ pub pBackendUserData: *mut core::ffi::c_void, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub state: ma_resampler__bindgen_ty_1, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_resampler__bindgen_ty_1 { ++ pub linear: ma_linear_resampler, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampler__bindgen_ty_1"] ++ [::core::mem::size_of::() - 136usize]; ++ ["Alignment of ma_resampler__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resampler__bindgen_ty_1::linear"] ++ [::core::mem::offset_of!(ma_resampler__bindgen_ty_1, linear) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampler"][::core::mem::size_of::() - 192usize]; ++ ["Alignment of ma_resampler"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resampler::pBackend"] ++ [::core::mem::offset_of!(ma_resampler, pBackend) - 0usize]; ++ ["Offset of field: ma_resampler::pBackendVTable"] ++ [::core::mem::offset_of!(ma_resampler, pBackendVTable) - 8usize]; ++ ["Offset of field: ma_resampler::pBackendUserData"] ++ [::core::mem::offset_of!(ma_resampler, pBackendUserData) - 16usize]; ++ ["Offset of field: ma_resampler::format"] ++ [::core::mem::offset_of!(ma_resampler, format) - 24usize]; ++ ["Offset of field: ma_resampler::channels"] ++ [::core::mem::offset_of!(ma_resampler, channels) - 28usize]; ++ ["Offset of field: ma_resampler::sampleRateIn"] ++ [::core::mem::offset_of!(ma_resampler, sampleRateIn) - 32usize]; ++ ["Offset of field: ma_resampler::sampleRateOut"] ++ [::core::mem::offset_of!(ma_resampler, sampleRateOut) - 36usize]; ++ ["Offset of field: ma_resampler::state"] ++ [::core::mem::offset_of!(ma_resampler, state) - 40usize]; ++ ["Offset of field: ma_resampler::_pHeap"] ++ [::core::mem::offset_of!(ma_resampler, _pHeap) - 176usize]; ++ ["Offset of field: ma_resampler::_ownsHeap"] ++ [::core::mem::offset_of!(ma_resampler, _ownsHeap) - 184usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resampler_get_heap_size( ++ pConfig: *const ma_resampler_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_init_preallocated( ++ pConfig: *const ma_resampler_config, ++ pHeap: *mut core::ffi::c_void, ++ pResampler: *mut ma_resampler, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_init( ++ pConfig: *const ma_resampler_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pResampler: *mut ma_resampler, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_uninit( ++ pResampler: *mut ma_resampler, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_resampler_process_pcm_frames( ++ pResampler: *mut ma_resampler, ++ pFramesIn: *const core::ffi::c_void, ++ pFrameCountIn: *mut ma_uint64, ++ pFramesOut: *mut core::ffi::c_void, ++ pFrameCountOut: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_set_rate( ++ pResampler: *mut ma_resampler, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_set_rate_ratio(pResampler: *mut ma_resampler, ratio: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_get_input_latency(pResampler: *const ma_resampler) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_get_output_latency(pResampler: *const ma_resampler) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_get_required_input_frame_count( ++ pResampler: *const ma_resampler, ++ outputFrameCount: ma_uint64, ++ pInputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_get_expected_output_frame_count( ++ pResampler: *const ma_resampler, ++ inputFrameCount: ma_uint64, ++ pOutputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_reset(pResampler: *mut ma_resampler) -> ma_result; ++} ++pub const ma_channel_conversion_path_ma_channel_conversion_path_unknown: ++ ma_channel_conversion_path = 0; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_passthrough: ++ ma_channel_conversion_path = 1; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_mono_out: ++ ma_channel_conversion_path = 2; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_mono_in: ++ ma_channel_conversion_path = 3; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_shuffle: ++ ma_channel_conversion_path = 4; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_weights: ++ ma_channel_conversion_path = 5; ++#[doc = "Channel Conversion"] ++pub type ma_channel_conversion_path = core::ffi::c_uint; ++pub const ma_mono_expansion_mode_ma_mono_expansion_mode_duplicate: ma_mono_expansion_mode = 0; ++pub const ma_mono_expansion_mode_ma_mono_expansion_mode_average: ma_mono_expansion_mode = 1; ++pub const ma_mono_expansion_mode_ma_mono_expansion_mode_stereo_only: ma_mono_expansion_mode = 2; ++pub const ma_mono_expansion_mode_ma_mono_expansion_mode_default: ma_mono_expansion_mode = 0; ++pub type ma_mono_expansion_mode = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_channel_converter_config { ++ pub format: ma_format, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub pChannelMapIn: *const ma_channel, ++ pub pChannelMapOut: *const ma_channel, ++ pub mixingMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub ppWeights: *mut *mut f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_channel_converter_config"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_channel_converter_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_channel_converter_config::format"] ++ [::core::mem::offset_of!(ma_channel_converter_config, format) - 0usize]; ++ ["Offset of field: ma_channel_converter_config::channelsIn"] ++ [::core::mem::offset_of!(ma_channel_converter_config, channelsIn) - 4usize]; ++ ["Offset of field: ma_channel_converter_config::channelsOut"] ++ [::core::mem::offset_of!(ma_channel_converter_config, channelsOut) - 8usize]; ++ ["Offset of field: ma_channel_converter_config::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_channel_converter_config, pChannelMapIn) - 16usize]; ++ ["Offset of field: ma_channel_converter_config::pChannelMapOut"] ++ [::core::mem::offset_of!(ma_channel_converter_config, pChannelMapOut) - 24usize]; ++ ["Offset of field: ma_channel_converter_config::mixingMode"] ++ [::core::mem::offset_of!(ma_channel_converter_config, mixingMode) - 32usize]; ++ ["Offset of field: ma_channel_converter_config::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_channel_converter_config, ++ calculateLFEFromSpatialChannels ++ ) - 36usize]; ++ ["Offset of field: ma_channel_converter_config::ppWeights"] ++ [::core::mem::offset_of!(ma_channel_converter_config, ppWeights) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_channel_converter_config_init( ++ format: ma_format, ++ channelsIn: ma_uint32, ++ pChannelMapIn: *const ma_channel, ++ channelsOut: ma_uint32, ++ pChannelMapOut: *const ma_channel, ++ mixingMode: ma_channel_mix_mode, ++ ) -> ma_channel_converter_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_channel_converter { ++ pub format: ma_format, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub mixingMode: ma_channel_mix_mode, ++ pub conversionPath: ma_channel_conversion_path, ++ pub pChannelMapIn: *mut ma_channel, ++ pub pChannelMapOut: *mut ma_channel, ++ pub pShuffleTable: *mut ma_uint8, ++ pub weights: ma_channel_converter__bindgen_ty_1, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_channel_converter__bindgen_ty_1 { ++ pub f32_: *mut *mut f32, ++ pub s16: *mut *mut ma_int32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_channel_converter__bindgen_ty_1"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_channel_converter__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_channel_converter__bindgen_ty_1::f32_"] ++ [::core::mem::offset_of!(ma_channel_converter__bindgen_ty_1, f32_) - 0usize]; ++ ["Offset of field: ma_channel_converter__bindgen_ty_1::s16"] ++ [::core::mem::offset_of!(ma_channel_converter__bindgen_ty_1, s16) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_channel_converter"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_channel_converter"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_channel_converter::format"] ++ [::core::mem::offset_of!(ma_channel_converter, format) - 0usize]; ++ ["Offset of field: ma_channel_converter::channelsIn"] ++ [::core::mem::offset_of!(ma_channel_converter, channelsIn) - 4usize]; ++ ["Offset of field: ma_channel_converter::channelsOut"] ++ [::core::mem::offset_of!(ma_channel_converter, channelsOut) - 8usize]; ++ ["Offset of field: ma_channel_converter::mixingMode"] ++ [::core::mem::offset_of!(ma_channel_converter, mixingMode) - 12usize]; ++ ["Offset of field: ma_channel_converter::conversionPath"] ++ [::core::mem::offset_of!(ma_channel_converter, conversionPath) - 16usize]; ++ ["Offset of field: ma_channel_converter::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_channel_converter, pChannelMapIn) - 24usize]; ++ ["Offset of field: ma_channel_converter::pChannelMapOut"] ++ [::core::mem::offset_of!(ma_channel_converter, pChannelMapOut) - 32usize]; ++ ["Offset of field: ma_channel_converter::pShuffleTable"] ++ [::core::mem::offset_of!(ma_channel_converter, pShuffleTable) - 40usize]; ++ ["Offset of field: ma_channel_converter::weights"] ++ [::core::mem::offset_of!(ma_channel_converter, weights) - 48usize]; ++ ["Offset of field: ma_channel_converter::_pHeap"] ++ [::core::mem::offset_of!(ma_channel_converter, _pHeap) - 56usize]; ++ ["Offset of field: ma_channel_converter::_ownsHeap"] ++ [::core::mem::offset_of!(ma_channel_converter, _ownsHeap) - 64usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_channel_converter_get_heap_size( ++ pConfig: *const ma_channel_converter_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_init_preallocated( ++ pConfig: *const ma_channel_converter_config, ++ pHeap: *mut core::ffi::c_void, ++ pConverter: *mut ma_channel_converter, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_init( ++ pConfig: *const ma_channel_converter_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pConverter: *mut ma_channel_converter, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_uninit( ++ pConverter: *mut ma_channel_converter, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_process_pcm_frames( ++ pConverter: *mut ma_channel_converter, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_get_input_channel_map( ++ pConverter: *const ma_channel_converter, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_get_output_channel_map( ++ pConverter: *const ma_channel_converter, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++#[doc = "Data Conversion"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_converter_config { ++ pub formatIn: ma_format, ++ pub formatOut: ma_format, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub pChannelMapIn: *mut ma_channel, ++ pub pChannelMapOut: *mut ma_channel, ++ pub ditherMode: ma_dither_mode, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub ppChannelWeights: *mut *mut f32, ++ pub allowDynamicSampleRate: ma_bool32, ++ pub resampling: ma_resampler_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_converter_config"] ++ [::core::mem::size_of::() - 120usize]; ++ ["Alignment of ma_data_converter_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_converter_config::formatIn"] ++ [::core::mem::offset_of!(ma_data_converter_config, formatIn) - 0usize]; ++ ["Offset of field: ma_data_converter_config::formatOut"] ++ [::core::mem::offset_of!(ma_data_converter_config, formatOut) - 4usize]; ++ ["Offset of field: ma_data_converter_config::channelsIn"] ++ [::core::mem::offset_of!(ma_data_converter_config, channelsIn) - 8usize]; ++ ["Offset of field: ma_data_converter_config::channelsOut"] ++ [::core::mem::offset_of!(ma_data_converter_config, channelsOut) - 12usize]; ++ ["Offset of field: ma_data_converter_config::sampleRateIn"] ++ [::core::mem::offset_of!(ma_data_converter_config, sampleRateIn) - 16usize]; ++ ["Offset of field: ma_data_converter_config::sampleRateOut"] ++ [::core::mem::offset_of!(ma_data_converter_config, sampleRateOut) - 20usize]; ++ ["Offset of field: ma_data_converter_config::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_data_converter_config, pChannelMapIn) - 24usize]; ++ ["Offset of field: ma_data_converter_config::pChannelMapOut"] ++ [::core::mem::offset_of!(ma_data_converter_config, pChannelMapOut) - 32usize]; ++ ["Offset of field: ma_data_converter_config::ditherMode"] ++ [::core::mem::offset_of!(ma_data_converter_config, ditherMode) - 40usize]; ++ ["Offset of field: ma_data_converter_config::channelMixMode"] ++ [::core::mem::offset_of!(ma_data_converter_config, channelMixMode) - 44usize]; ++ ["Offset of field: ma_data_converter_config::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_data_converter_config, ++ calculateLFEFromSpatialChannels ++ ) - 48usize]; ++ ["Offset of field: ma_data_converter_config::ppChannelWeights"] ++ [::core::mem::offset_of!(ma_data_converter_config, ppChannelWeights) - 56usize]; ++ ["Offset of field: ma_data_converter_config::allowDynamicSampleRate"] ++ [::core::mem::offset_of!(ma_data_converter_config, allowDynamicSampleRate) - 64usize]; ++ ["Offset of field: ma_data_converter_config::resampling"] ++ [::core::mem::offset_of!(ma_data_converter_config, resampling) - 72usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_converter_config_init_default() -> ma_data_converter_config; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_config_init( ++ formatIn: ma_format, ++ formatOut: ma_format, ++ channelsIn: ma_uint32, ++ channelsOut: ma_uint32, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_data_converter_config; ++} ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_passthrough: ++ ma_data_converter_execution_path = 0; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_format_only: ++ ma_data_converter_execution_path = 1; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_channels_only: ++ ma_data_converter_execution_path = 2; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_resample_only: ++ ma_data_converter_execution_path = 3; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_resample_first: ++ ma_data_converter_execution_path = 4; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_channels_first: ++ ma_data_converter_execution_path = 5; ++pub type ma_data_converter_execution_path = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_data_converter { ++ pub formatIn: ma_format, ++ pub formatOut: ma_format, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub ditherMode: ma_dither_mode, ++ pub executionPath: ma_data_converter_execution_path, ++ pub channelConverter: ma_channel_converter, ++ pub resampler: ma_resampler, ++ pub hasPreFormatConversion: ma_bool8, ++ pub hasPostFormatConversion: ma_bool8, ++ pub hasChannelConverter: ma_bool8, ++ pub hasResampler: ma_bool8, ++ pub isPassthrough: ma_bool8, ++ pub _ownsHeap: ma_bool8, ++ pub _pHeap: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_converter"][::core::mem::size_of::() - 312usize]; ++ ["Alignment of ma_data_converter"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_converter::formatIn"] ++ [::core::mem::offset_of!(ma_data_converter, formatIn) - 0usize]; ++ ["Offset of field: ma_data_converter::formatOut"] ++ [::core::mem::offset_of!(ma_data_converter, formatOut) - 4usize]; ++ ["Offset of field: ma_data_converter::channelsIn"] ++ [::core::mem::offset_of!(ma_data_converter, channelsIn) - 8usize]; ++ ["Offset of field: ma_data_converter::channelsOut"] ++ [::core::mem::offset_of!(ma_data_converter, channelsOut) - 12usize]; ++ ["Offset of field: ma_data_converter::sampleRateIn"] ++ [::core::mem::offset_of!(ma_data_converter, sampleRateIn) - 16usize]; ++ ["Offset of field: ma_data_converter::sampleRateOut"] ++ [::core::mem::offset_of!(ma_data_converter, sampleRateOut) - 20usize]; ++ ["Offset of field: ma_data_converter::ditherMode"] ++ [::core::mem::offset_of!(ma_data_converter, ditherMode) - 24usize]; ++ ["Offset of field: ma_data_converter::executionPath"] ++ [::core::mem::offset_of!(ma_data_converter, executionPath) - 28usize]; ++ ["Offset of field: ma_data_converter::channelConverter"] ++ [::core::mem::offset_of!(ma_data_converter, channelConverter) - 32usize]; ++ ["Offset of field: ma_data_converter::resampler"] ++ [::core::mem::offset_of!(ma_data_converter, resampler) - 104usize]; ++ ["Offset of field: ma_data_converter::hasPreFormatConversion"] ++ [::core::mem::offset_of!(ma_data_converter, hasPreFormatConversion) - 296usize]; ++ ["Offset of field: ma_data_converter::hasPostFormatConversion"] ++ [::core::mem::offset_of!(ma_data_converter, hasPostFormatConversion) - 297usize]; ++ ["Offset of field: ma_data_converter::hasChannelConverter"] ++ [::core::mem::offset_of!(ma_data_converter, hasChannelConverter) - 298usize]; ++ ["Offset of field: ma_data_converter::hasResampler"] ++ [::core::mem::offset_of!(ma_data_converter, hasResampler) - 299usize]; ++ ["Offset of field: ma_data_converter::isPassthrough"] ++ [::core::mem::offset_of!(ma_data_converter, isPassthrough) - 300usize]; ++ ["Offset of field: ma_data_converter::_ownsHeap"] ++ [::core::mem::offset_of!(ma_data_converter, _ownsHeap) - 301usize]; ++ ["Offset of field: ma_data_converter::_pHeap"] ++ [::core::mem::offset_of!(ma_data_converter, _pHeap) - 304usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_converter_get_heap_size( ++ pConfig: *const ma_data_converter_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_init_preallocated( ++ pConfig: *const ma_data_converter_config, ++ pHeap: *mut core::ffi::c_void, ++ pConverter: *mut ma_data_converter, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_init( ++ pConfig: *const ma_data_converter_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pConverter: *mut ma_data_converter, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_uninit( ++ pConverter: *mut ma_data_converter, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_process_pcm_frames( ++ pConverter: *mut ma_data_converter, ++ pFramesIn: *const core::ffi::c_void, ++ pFrameCountIn: *mut ma_uint64, ++ pFramesOut: *mut core::ffi::c_void, ++ pFrameCountOut: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_set_rate( ++ pConverter: *mut ma_data_converter, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_set_rate_ratio( ++ pConverter: *mut ma_data_converter, ++ ratioInOut: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_input_latency(pConverter: *const ma_data_converter) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_output_latency(pConverter: *const ma_data_converter) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_required_input_frame_count( ++ pConverter: *const ma_data_converter, ++ outputFrameCount: ma_uint64, ++ pInputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_expected_output_frame_count( ++ pConverter: *const ma_data_converter, ++ inputFrameCount: ma_uint64, ++ pOutputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_input_channel_map( ++ pConverter: *const ma_data_converter, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_output_channel_map( ++ pConverter: *const ma_data_converter, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_reset(pConverter: *mut ma_data_converter) -> ma_result; ++} ++unsafe extern "C" { ++ #[doc = "Format Conversion"] ++ pub fn ma_pcm_u8_to_s16( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_u8_to_s24( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_u8_to_s32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_u8_to_f32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s16_to_u8( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s16_to_s24( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s16_to_s32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s16_to_f32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s24_to_u8( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s24_to_s16( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s24_to_s32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s24_to_f32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s32_to_u8( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s32_to_s16( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s32_to_s24( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s32_to_f32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_f32_to_u8( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_f32_to_s16( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_f32_to_s24( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_f32_to_s32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_convert( ++ pOut: *mut core::ffi::c_void, ++ formatOut: ma_format, ++ pIn: *const core::ffi::c_void, ++ formatIn: ma_format, ++ sampleCount: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_convert_pcm_frames_format( ++ pOut: *mut core::ffi::c_void, ++ formatOut: ma_format, ++ pIn: *const core::ffi::c_void, ++ formatIn: ma_format, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_deinterleave_pcm_frames( ++ format: ma_format, ++ channels: ma_uint32, ++ frameCount: ma_uint64, ++ pInterleavedPCMFrames: *const core::ffi::c_void, ++ ppDeinterleavedPCMFrames: *mut *mut core::ffi::c_void, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_interleave_pcm_frames( ++ format: ma_format, ++ channels: ma_uint32, ++ frameCount: ma_uint64, ++ ppDeinterleavedPCMFrames: *mut *const core::ffi::c_void, ++ pInterleavedPCMFrames: *mut core::ffi::c_void, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_get_channel( ++ pChannelMap: *const ma_channel, ++ channelCount: ma_uint32, ++ channelIndex: ma_uint32, ++ ) -> ma_channel; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_init_blank(pChannelMap: *mut ma_channel, channels: ma_uint32); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_init_standard( ++ standardChannelMap: ma_standard_channel_map, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_copy(pOut: *mut ma_channel, pIn: *const ma_channel, channels: ma_uint32); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_copy_or_default( ++ pOut: *mut ma_channel, ++ channelMapCapOut: usize, ++ pIn: *const ma_channel, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_is_valid( ++ pChannelMap: *const ma_channel, ++ channels: ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_is_equal( ++ pChannelMapA: *const ma_channel, ++ pChannelMapB: *const ma_channel, ++ channels: ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_is_blank( ++ pChannelMap: *const ma_channel, ++ channels: ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_contains_channel_position( ++ channels: ma_uint32, ++ pChannelMap: *const ma_channel, ++ channelPosition: ma_channel, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_find_channel_position( ++ channels: ma_uint32, ++ pChannelMap: *const ma_channel, ++ channelPosition: ma_channel, ++ pChannelIndex: *mut ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_to_string( ++ pChannelMap: *const ma_channel, ++ channels: ma_uint32, ++ pBufferOut: *mut core::ffi::c_char, ++ bufferCap: usize, ++ ) -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_channel_position_to_string(channel: ma_channel) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ #[doc = "Conversion Helpers"] ++ pub fn ma_convert_frames( ++ pOut: *mut core::ffi::c_void, ++ frameCountOut: ma_uint64, ++ formatOut: ma_format, ++ channelsOut: ma_uint32, ++ sampleRateOut: ma_uint32, ++ pIn: *const core::ffi::c_void, ++ frameCountIn: ma_uint64, ++ formatIn: ma_format, ++ channelsIn: ma_uint32, ++ sampleRateIn: ma_uint32, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_convert_frames_ex( ++ pOut: *mut core::ffi::c_void, ++ frameCountOut: ma_uint64, ++ pIn: *const core::ffi::c_void, ++ frameCountIn: ma_uint64, ++ pConfig: *const ma_data_converter_config, ++ ) -> ma_uint64; ++} ++#[doc = "Data Source"] ++pub type ma_data_source = core::ffi::c_void; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_vtable { ++ pub onRead: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDataSource: *mut ma_data_source, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onSeek: ::core::option::Option< ++ unsafe extern "C" fn(pDataSource: *mut ma_data_source, frameIndex: ma_uint64) -> ma_result, ++ >, ++ pub onGetDataFormat: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDataSource: *mut ma_data_source, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result, ++ >, ++ pub onGetCursor: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDataSource: *mut ma_data_source, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onGetLength: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDataSource: *mut ma_data_source, ++ pLength: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onSetLooping: ::core::option::Option< ++ unsafe extern "C" fn(pDataSource: *mut ma_data_source, isLooping: ma_bool32) -> ma_result, ++ >, ++ pub flags: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_vtable"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_data_source_vtable"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_vtable::onRead"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onRead) - 0usize]; ++ ["Offset of field: ma_data_source_vtable::onSeek"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onSeek) - 8usize]; ++ ["Offset of field: ma_data_source_vtable::onGetDataFormat"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onGetDataFormat) - 16usize]; ++ ["Offset of field: ma_data_source_vtable::onGetCursor"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onGetCursor) - 24usize]; ++ ["Offset of field: ma_data_source_vtable::onGetLength"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onGetLength) - 32usize]; ++ ["Offset of field: ma_data_source_vtable::onSetLooping"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onSetLooping) - 40usize]; ++ ["Offset of field: ma_data_source_vtable::flags"] ++ [::core::mem::offset_of!(ma_data_source_vtable, flags) - 48usize]; ++}; ++pub type ma_data_source_get_next_proc = ::core::option::Option< ++ unsafe extern "C" fn(pDataSource: *mut ma_data_source) -> *mut ma_data_source, ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_config { ++ pub vtable: *const ma_data_source_vtable, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_config"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_data_source_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_config::vtable"] ++ [::core::mem::offset_of!(ma_data_source_config, vtable) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_source_config_init() -> ma_data_source_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_base { ++ pub vtable: *const ma_data_source_vtable, ++ pub rangeBegInFrames: ma_uint64, ++ pub rangeEndInFrames: ma_uint64, ++ pub loopBegInFrames: ma_uint64, ++ pub loopEndInFrames: ma_uint64, ++ pub pCurrent: *mut ma_data_source, ++ pub pNext: *mut ma_data_source, ++ pub onGetNext: ma_data_source_get_next_proc, ++ pub isLooping: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_base"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_data_source_base"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_base::vtable"] ++ [::core::mem::offset_of!(ma_data_source_base, vtable) - 0usize]; ++ ["Offset of field: ma_data_source_base::rangeBegInFrames"] ++ [::core::mem::offset_of!(ma_data_source_base, rangeBegInFrames) - 8usize]; ++ ["Offset of field: ma_data_source_base::rangeEndInFrames"] ++ [::core::mem::offset_of!(ma_data_source_base, rangeEndInFrames) - 16usize]; ++ ["Offset of field: ma_data_source_base::loopBegInFrames"] ++ [::core::mem::offset_of!(ma_data_source_base, loopBegInFrames) - 24usize]; ++ ["Offset of field: ma_data_source_base::loopEndInFrames"] ++ [::core::mem::offset_of!(ma_data_source_base, loopEndInFrames) - 32usize]; ++ ["Offset of field: ma_data_source_base::pCurrent"] ++ [::core::mem::offset_of!(ma_data_source_base, pCurrent) - 40usize]; ++ ["Offset of field: ma_data_source_base::pNext"] ++ [::core::mem::offset_of!(ma_data_source_base, pNext) - 48usize]; ++ ["Offset of field: ma_data_source_base::onGetNext"] ++ [::core::mem::offset_of!(ma_data_source_base, onGetNext) - 56usize]; ++ ["Offset of field: ma_data_source_base::isLooping"] ++ [::core::mem::offset_of!(ma_data_source_base, isLooping) - 64usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_source_init( ++ pConfig: *const ma_data_source_config, ++ pDataSource: *mut ma_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_uninit(pDataSource: *mut ma_data_source); ++} ++unsafe extern "C" { ++ pub fn ma_data_source_read_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_seek_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ frameCount: ma_uint64, ++ pFramesSeeked: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_seek_to_pcm_frame( ++ pDataSource: *mut ma_data_source, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_seek_seconds( ++ pDataSource: *mut ma_data_source, ++ secondCount: f32, ++ pSecondsSeeked: *mut f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_seek_to_second( ++ pDataSource: *mut ma_data_source, ++ seekPointInSeconds: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_data_format( ++ pDataSource: *mut ma_data_source, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_cursor_in_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_length_in_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_cursor_in_seconds( ++ pDataSource: *mut ma_data_source, ++ pCursor: *mut f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_length_in_seconds( ++ pDataSource: *mut ma_data_source, ++ pLength: *mut f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_looping( ++ pDataSource: *mut ma_data_source, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_is_looping(pDataSource: *const ma_data_source) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_range_in_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ rangeBegInFrames: ma_uint64, ++ rangeEndInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_range_in_pcm_frames( ++ pDataSource: *const ma_data_source, ++ pRangeBegInFrames: *mut ma_uint64, ++ pRangeEndInFrames: *mut ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_loop_point_in_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ loopBegInFrames: ma_uint64, ++ loopEndInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_loop_point_in_pcm_frames( ++ pDataSource: *const ma_data_source, ++ pLoopBegInFrames: *mut ma_uint64, ++ pLoopEndInFrames: *mut ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_current( ++ pDataSource: *mut ma_data_source, ++ pCurrentDataSource: *mut ma_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_current(pDataSource: *const ma_data_source) -> *mut ma_data_source; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_next( ++ pDataSource: *mut ma_data_source, ++ pNextDataSource: *mut ma_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_next(pDataSource: *const ma_data_source) -> *mut ma_data_source; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_next_callback( ++ pDataSource: *mut ma_data_source, ++ onGetNext: ma_data_source_get_next_proc, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_next_callback( ++ pDataSource: *const ma_data_source, ++ ) -> ma_data_source_get_next_proc; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_audio_buffer_ref { ++ pub ds: ma_data_source_base, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cursor: ma_uint64, ++ pub sizeInFrames: ma_uint64, ++ pub pData: *const core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_audio_buffer_ref"][::core::mem::size_of::() - 112usize]; ++ ["Alignment of ma_audio_buffer_ref"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_audio_buffer_ref::ds"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, ds) - 0usize]; ++ ["Offset of field: ma_audio_buffer_ref::format"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, format) - 72usize]; ++ ["Offset of field: ma_audio_buffer_ref::channels"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, channels) - 76usize]; ++ ["Offset of field: ma_audio_buffer_ref::sampleRate"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, sampleRate) - 80usize]; ++ ["Offset of field: ma_audio_buffer_ref::cursor"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, cursor) - 88usize]; ++ ["Offset of field: ma_audio_buffer_ref::sizeInFrames"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, sizeInFrames) - 96usize]; ++ ["Offset of field: ma_audio_buffer_ref::pData"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, pData) - 104usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_init( ++ format: ma_format, ++ channels: ma_uint32, ++ pData: *const core::ffi::c_void, ++ sizeInFrames: ma_uint64, ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_uninit(pAudioBufferRef: *mut ma_audio_buffer_ref); ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_set_data( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ pData: *const core::ffi::c_void, ++ sizeInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_read_pcm_frames( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ loop_: ma_bool32, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_seek_to_pcm_frame( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_map( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ ppFramesOut: *mut *mut core::ffi::c_void, ++ pFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_unmap( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_at_end(pAudioBufferRef: *const ma_audio_buffer_ref) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_get_cursor_in_pcm_frames( ++ pAudioBufferRef: *const ma_audio_buffer_ref, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_get_length_in_pcm_frames( ++ pAudioBufferRef: *const ma_audio_buffer_ref, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_get_available_frames( ++ pAudioBufferRef: *const ma_audio_buffer_ref, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_audio_buffer_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub sizeInFrames: ma_uint64, ++ pub pData: *const core::ffi::c_void, ++ pub allocationCallbacks: ma_allocation_callbacks, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_audio_buffer_config"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_audio_buffer_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_audio_buffer_config::format"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, format) - 0usize]; ++ ["Offset of field: ma_audio_buffer_config::channels"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, channels) - 4usize]; ++ ["Offset of field: ma_audio_buffer_config::sampleRate"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_audio_buffer_config::sizeInFrames"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, sizeInFrames) - 16usize]; ++ ["Offset of field: ma_audio_buffer_config::pData"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, pData) - 24usize]; ++ ["Offset of field: ma_audio_buffer_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, allocationCallbacks) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_audio_buffer_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sizeInFrames: ma_uint64, ++ pData: *const core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_audio_buffer_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_audio_buffer { ++ pub ref_: ma_audio_buffer_ref, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub ownsData: ma_bool32, ++ pub _pExtraData: [ma_uint8; 1usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_audio_buffer"][::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_audio_buffer"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_audio_buffer::ref_"] ++ [::core::mem::offset_of!(ma_audio_buffer, ref_) - 0usize]; ++ ["Offset of field: ma_audio_buffer::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_audio_buffer, allocationCallbacks) - 112usize]; ++ ["Offset of field: ma_audio_buffer::ownsData"] ++ [::core::mem::offset_of!(ma_audio_buffer, ownsData) - 144usize]; ++ ["Offset of field: ma_audio_buffer::_pExtraData"] ++ [::core::mem::offset_of!(ma_audio_buffer, _pExtraData) - 148usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_audio_buffer_init( ++ pConfig: *const ma_audio_buffer_config, ++ pAudioBuffer: *mut ma_audio_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_init_copy( ++ pConfig: *const ma_audio_buffer_config, ++ pAudioBuffer: *mut ma_audio_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_alloc_and_init( ++ pConfig: *const ma_audio_buffer_config, ++ ppAudioBuffer: *mut *mut ma_audio_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_uninit(pAudioBuffer: *mut ma_audio_buffer); ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_uninit_and_free(pAudioBuffer: *mut ma_audio_buffer); ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_read_pcm_frames( ++ pAudioBuffer: *mut ma_audio_buffer, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ loop_: ma_bool32, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_seek_to_pcm_frame( ++ pAudioBuffer: *mut ma_audio_buffer, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_map( ++ pAudioBuffer: *mut ma_audio_buffer, ++ ppFramesOut: *mut *mut core::ffi::c_void, ++ pFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_unmap( ++ pAudioBuffer: *mut ma_audio_buffer, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_at_end(pAudioBuffer: *const ma_audio_buffer) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_get_cursor_in_pcm_frames( ++ pAudioBuffer: *const ma_audio_buffer, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_get_length_in_pcm_frames( ++ pAudioBuffer: *const ma_audio_buffer, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_get_available_frames( ++ pAudioBuffer: *const ma_audio_buffer, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_paged_audio_buffer_page { ++ pub pNext: *mut ma_paged_audio_buffer_page, ++ pub sizeInFrames: ma_uint64, ++ pub pAudioData: [ma_uint8; 1usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_paged_audio_buffer_page"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_paged_audio_buffer_page"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_page::pNext"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_page, pNext) - 0usize]; ++ ["Offset of field: ma_paged_audio_buffer_page::sizeInFrames"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_page, sizeInFrames) - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_page::pAudioData"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_page, pAudioData) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_paged_audio_buffer_data { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub head: ma_paged_audio_buffer_page, ++ pub pTail: *mut ma_paged_audio_buffer_page, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_paged_audio_buffer_data"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_paged_audio_buffer_data"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_data::format"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_data, format) - 0usize]; ++ ["Offset of field: ma_paged_audio_buffer_data::channels"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_data, channels) - 4usize]; ++ ["Offset of field: ma_paged_audio_buffer_data::head"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_data, head) - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_data::pTail"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_data, pTail) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_init( ++ format: ma_format, ++ channels: ma_uint32, ++ pData: *mut ma_paged_audio_buffer_data, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_uninit( ++ pData: *mut ma_paged_audio_buffer_data, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_get_head( ++ pData: *mut ma_paged_audio_buffer_data, ++ ) -> *mut ma_paged_audio_buffer_page; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_get_tail( ++ pData: *mut ma_paged_audio_buffer_data, ++ ) -> *mut ma_paged_audio_buffer_page; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_get_length_in_pcm_frames( ++ pData: *mut ma_paged_audio_buffer_data, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_allocate_page( ++ pData: *mut ma_paged_audio_buffer_data, ++ pageSizeInFrames: ma_uint64, ++ pInitialData: *const core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppPage: *mut *mut ma_paged_audio_buffer_page, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_free_page( ++ pData: *mut ma_paged_audio_buffer_data, ++ pPage: *mut ma_paged_audio_buffer_page, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_append_page( ++ pData: *mut ma_paged_audio_buffer_data, ++ pPage: *mut ma_paged_audio_buffer_page, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_allocate_and_append_page( ++ pData: *mut ma_paged_audio_buffer_data, ++ pageSizeInFrames: ma_uint32, ++ pInitialData: *const core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_paged_audio_buffer_config { ++ pub pData: *mut ma_paged_audio_buffer_data, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_paged_audio_buffer_config"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_paged_audio_buffer_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_config::pData"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_config, pData) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_config_init( ++ pData: *mut ma_paged_audio_buffer_data, ++ ) -> ma_paged_audio_buffer_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_paged_audio_buffer { ++ pub ds: ma_data_source_base, ++ pub pData: *mut ma_paged_audio_buffer_data, ++ pub pCurrent: *mut ma_paged_audio_buffer_page, ++ pub relativeCursor: ma_uint64, ++ pub absoluteCursor: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_paged_audio_buffer"][::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_paged_audio_buffer"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer::ds"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, ds) - 0usize]; ++ ["Offset of field: ma_paged_audio_buffer::pData"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, pData) - 72usize]; ++ ["Offset of field: ma_paged_audio_buffer::pCurrent"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, pCurrent) - 80usize]; ++ ["Offset of field: ma_paged_audio_buffer::relativeCursor"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, relativeCursor) - 88usize]; ++ ["Offset of field: ma_paged_audio_buffer::absoluteCursor"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, absoluteCursor) - 96usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_init( ++ pConfig: *const ma_paged_audio_buffer_config, ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_uninit(pPagedAudioBuffer: *mut ma_paged_audio_buffer); ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_read_pcm_frames( ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_seek_to_pcm_frame( ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_get_cursor_in_pcm_frames( ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_get_length_in_pcm_frames( ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++#[doc = "Ring Buffer"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_rb { ++ pub pBuffer: *mut core::ffi::c_void, ++ pub subbufferSizeInBytes: ma_uint32, ++ pub subbufferCount: ma_uint32, ++ pub subbufferStrideInBytes: ma_uint32, ++ pub encodedReadOffset: ma_uint32, ++ pub encodedWriteOffset: ma_uint32, ++ pub ownsBuffer: ma_bool8, ++ pub clearOnWriteAcquire: ma_bool8, ++ pub allocationCallbacks: ma_allocation_callbacks, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_rb"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_rb"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_rb::pBuffer"][::core::mem::offset_of!(ma_rb, pBuffer) - 0usize]; ++ ["Offset of field: ma_rb::subbufferSizeInBytes"] ++ [::core::mem::offset_of!(ma_rb, subbufferSizeInBytes) - 8usize]; ++ ["Offset of field: ma_rb::subbufferCount"] ++ [::core::mem::offset_of!(ma_rb, subbufferCount) - 12usize]; ++ ["Offset of field: ma_rb::subbufferStrideInBytes"] ++ [::core::mem::offset_of!(ma_rb, subbufferStrideInBytes) - 16usize]; ++ ["Offset of field: ma_rb::encodedReadOffset"] ++ [::core::mem::offset_of!(ma_rb, encodedReadOffset) - 20usize]; ++ ["Offset of field: ma_rb::encodedWriteOffset"] ++ [::core::mem::offset_of!(ma_rb, encodedWriteOffset) - 24usize]; ++ ["Offset of field: ma_rb::ownsBuffer"][::core::mem::offset_of!(ma_rb, ownsBuffer) - 28usize]; ++ ["Offset of field: ma_rb::clearOnWriteAcquire"] ++ [::core::mem::offset_of!(ma_rb, clearOnWriteAcquire) - 29usize]; ++ ["Offset of field: ma_rb::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_rb, allocationCallbacks) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_rb_init_ex( ++ subbufferSizeInBytes: usize, ++ subbufferCount: usize, ++ subbufferStrideInBytes: usize, ++ pOptionalPreallocatedBuffer: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_init( ++ bufferSizeInBytes: usize, ++ pOptionalPreallocatedBuffer: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_uninit(pRB: *mut ma_rb); ++} ++unsafe extern "C" { ++ pub fn ma_rb_reset(pRB: *mut ma_rb); ++} ++unsafe extern "C" { ++ pub fn ma_rb_acquire_read( ++ pRB: *mut ma_rb, ++ pSizeInBytes: *mut usize, ++ ppBufferOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_commit_read(pRB: *mut ma_rb, sizeInBytes: usize) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_acquire_write( ++ pRB: *mut ma_rb, ++ pSizeInBytes: *mut usize, ++ ppBufferOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_commit_write(pRB: *mut ma_rb, sizeInBytes: usize) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_seek_read(pRB: *mut ma_rb, offsetInBytes: usize) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_seek_write(pRB: *mut ma_rb, offsetInBytes: usize) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_pointer_distance(pRB: *mut ma_rb) -> ma_int32; ++} ++unsafe extern "C" { ++ pub fn ma_rb_available_read(pRB: *mut ma_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_rb_available_write(pRB: *mut ma_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_rb_get_subbuffer_size(pRB: *mut ma_rb) -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_rb_get_subbuffer_stride(pRB: *mut ma_rb) -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_rb_get_subbuffer_offset(pRB: *mut ma_rb, subbufferIndex: usize) -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_rb_get_subbuffer_ptr( ++ pRB: *mut ma_rb, ++ subbufferIndex: usize, ++ pBuffer: *mut core::ffi::c_void, ++ ) -> *mut core::ffi::c_void; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_pcm_rb { ++ pub ds: ma_data_source_base, ++ pub rb: ma_rb, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_pcm_rb"][::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_pcm_rb"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_pcm_rb::ds"][::core::mem::offset_of!(ma_pcm_rb, ds) - 0usize]; ++ ["Offset of field: ma_pcm_rb::rb"][::core::mem::offset_of!(ma_pcm_rb, rb) - 72usize]; ++ ["Offset of field: ma_pcm_rb::format"][::core::mem::offset_of!(ma_pcm_rb, format) - 136usize]; ++ ["Offset of field: ma_pcm_rb::channels"] ++ [::core::mem::offset_of!(ma_pcm_rb, channels) - 140usize]; ++ ["Offset of field: ma_pcm_rb::sampleRate"] ++ [::core::mem::offset_of!(ma_pcm_rb, sampleRate) - 144usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_pcm_rb_init_ex( ++ format: ma_format, ++ channels: ma_uint32, ++ subbufferSizeInFrames: ma_uint32, ++ subbufferCount: ma_uint32, ++ subbufferStrideInFrames: ma_uint32, ++ pOptionalPreallocatedBuffer: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_pcm_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_init( ++ format: ma_format, ++ channels: ma_uint32, ++ bufferSizeInFrames: ma_uint32, ++ pOptionalPreallocatedBuffer: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_pcm_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_uninit(pRB: *mut ma_pcm_rb); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_reset(pRB: *mut ma_pcm_rb); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_acquire_read( ++ pRB: *mut ma_pcm_rb, ++ pSizeInFrames: *mut ma_uint32, ++ ppBufferOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_commit_read(pRB: *mut ma_pcm_rb, sizeInFrames: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_acquire_write( ++ pRB: *mut ma_pcm_rb, ++ pSizeInFrames: *mut ma_uint32, ++ ppBufferOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_commit_write(pRB: *mut ma_pcm_rb, sizeInFrames: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_seek_read(pRB: *mut ma_pcm_rb, offsetInFrames: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_seek_write(pRB: *mut ma_pcm_rb, offsetInFrames: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_pointer_distance(pRB: *mut ma_pcm_rb) -> ma_int32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_available_read(pRB: *mut ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_available_write(pRB: *mut ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_subbuffer_size(pRB: *mut ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_subbuffer_stride(pRB: *mut ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_subbuffer_offset( ++ pRB: *mut ma_pcm_rb, ++ subbufferIndex: ma_uint32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_subbuffer_ptr( ++ pRB: *mut ma_pcm_rb, ++ subbufferIndex: ma_uint32, ++ pBuffer: *mut core::ffi::c_void, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_format(pRB: *const ma_pcm_rb) -> ma_format; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_channels(pRB: *const ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_sample_rate(pRB: *const ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_set_sample_rate(pRB: *mut ma_pcm_rb, sampleRate: ma_uint32); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_duplex_rb { ++ pub rb: ma_pcm_rb, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_duplex_rb"][::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_duplex_rb"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_duplex_rb::rb"][::core::mem::offset_of!(ma_duplex_rb, rb) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_duplex_rb_init( ++ captureFormat: ma_format, ++ captureChannels: ma_uint32, ++ sampleRate: ma_uint32, ++ captureInternalSampleRate: ma_uint32, ++ captureInternalPeriodSizeInFrames: ma_uint32, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_duplex_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_duplex_rb_uninit(pRB: *mut ma_duplex_rb) -> ma_result; ++} ++unsafe extern "C" { ++ #[doc = "Miscellaneous Helpers"] ++ pub fn ma_result_description(result: ma_result) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ma_malloc( ++ sz: usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_calloc( ++ sz: usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_realloc( ++ p: *mut core::ffi::c_void, ++ sz: usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_free(p: *mut core::ffi::c_void, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_aligned_malloc( ++ sz: usize, ++ alignment: usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_aligned_free( ++ p: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_get_format_name(format: ma_format) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ma_blend_f32( ++ pOut: *mut f32, ++ pInA: *mut f32, ++ pInB: *mut f32, ++ factor: f32, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_get_bytes_per_sample(format: ma_format) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_log_level_to_string(logLevel: ma_uint32) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ #[doc = "Synchronization"] ++ pub fn ma_spinlock_lock(pSpinlock: *mut ma_spinlock) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spinlock_lock_noyield(pSpinlock: *mut ma_spinlock) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spinlock_unlock(pSpinlock: *mut ma_spinlock) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_mutex_init(pMutex: *mut ma_mutex) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_mutex_uninit(pMutex: *mut ma_mutex); ++} ++unsafe extern "C" { ++ pub fn ma_mutex_lock(pMutex: *mut ma_mutex); ++} ++unsafe extern "C" { ++ pub fn ma_mutex_unlock(pMutex: *mut ma_mutex); ++} ++unsafe extern "C" { ++ pub fn ma_event_init(pEvent: *mut ma_event) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_event_uninit(pEvent: *mut ma_event); ++} ++unsafe extern "C" { ++ pub fn ma_event_wait(pEvent: *mut ma_event) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_event_signal(pEvent: *mut ma_event) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_semaphore_init( ++ initialValue: core::ffi::c_int, ++ pSemaphore: *mut ma_semaphore, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_semaphore_uninit(pSemaphore: *mut ma_semaphore); ++} ++unsafe extern "C" { ++ pub fn ma_semaphore_wait(pSemaphore: *mut ma_semaphore) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_semaphore_release(pSemaphore: *mut ma_semaphore) -> ma_result; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_fence { ++ pub e: ma_event, ++ pub counter: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_fence"][::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_fence"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_fence::e"][::core::mem::offset_of!(ma_fence, e) - 0usize]; ++ ["Offset of field: ma_fence::counter"][::core::mem::offset_of!(ma_fence, counter) - 96usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_fence_init(pFence: *mut ma_fence) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fence_uninit(pFence: *mut ma_fence); ++} ++unsafe extern "C" { ++ pub fn ma_fence_acquire(pFence: *mut ma_fence) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fence_release(pFence: *mut ma_fence) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fence_wait(pFence: *mut ma_fence) -> ma_result; ++} ++pub type ma_async_notification = core::ffi::c_void; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_async_notification_callbacks { ++ pub onSignal: ++ ::core::option::Option, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_async_notification_callbacks"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_async_notification_callbacks"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_async_notification_callbacks::onSignal"] ++ [::core::mem::offset_of!(ma_async_notification_callbacks, onSignal) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_async_notification_signal(pNotification: *mut ma_async_notification) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_async_notification_poll { ++ pub cb: ma_async_notification_callbacks, ++ pub signalled: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_async_notification_poll"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_async_notification_poll"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_async_notification_poll::cb"] ++ [::core::mem::offset_of!(ma_async_notification_poll, cb) - 0usize]; ++ ["Offset of field: ma_async_notification_poll::signalled"] ++ [::core::mem::offset_of!(ma_async_notification_poll, signalled) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_async_notification_poll_init( ++ pNotificationPoll: *mut ma_async_notification_poll, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_async_notification_poll_is_signalled( ++ pNotificationPoll: *const ma_async_notification_poll, ++ ) -> ma_bool32; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_async_notification_event { ++ pub cb: ma_async_notification_callbacks, ++ pub e: ma_event, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_async_notification_event"] ++ [::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_async_notification_event"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_async_notification_event::cb"] ++ [::core::mem::offset_of!(ma_async_notification_event, cb) - 0usize]; ++ ["Offset of field: ma_async_notification_event::e"] ++ [::core::mem::offset_of!(ma_async_notification_event, e) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_async_notification_event_init( ++ pNotificationEvent: *mut ma_async_notification_event, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_async_notification_event_uninit( ++ pNotificationEvent: *mut ma_async_notification_event, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_async_notification_event_wait( ++ pNotificationEvent: *mut ma_async_notification_event, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_async_notification_event_signal( ++ pNotificationEvent: *mut ma_async_notification_event, ++ ) -> ma_result; ++} ++#[doc = "Job Queue"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_slot_allocator_config { ++ pub capacity: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_slot_allocator_config"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_slot_allocator_config"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_slot_allocator_config::capacity"] ++ [::core::mem::offset_of!(ma_slot_allocator_config, capacity) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_slot_allocator_config_init(capacity: ma_uint32) -> ma_slot_allocator_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_slot_allocator_group { ++ pub bitfield: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_slot_allocator_group"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_slot_allocator_group"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_slot_allocator_group::bitfield"] ++ [::core::mem::offset_of!(ma_slot_allocator_group, bitfield) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_slot_allocator { ++ pub pGroups: *mut ma_slot_allocator_group, ++ pub pSlots: *mut ma_uint32, ++ pub count: ma_uint32, ++ pub capacity: ma_uint32, ++ pub _ownsHeap: ma_bool32, ++ pub _pHeap: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_slot_allocator"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_slot_allocator"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_slot_allocator::pGroups"] ++ [::core::mem::offset_of!(ma_slot_allocator, pGroups) - 0usize]; ++ ["Offset of field: ma_slot_allocator::pSlots"] ++ [::core::mem::offset_of!(ma_slot_allocator, pSlots) - 8usize]; ++ ["Offset of field: ma_slot_allocator::count"] ++ [::core::mem::offset_of!(ma_slot_allocator, count) - 16usize]; ++ ["Offset of field: ma_slot_allocator::capacity"] ++ [::core::mem::offset_of!(ma_slot_allocator, capacity) - 20usize]; ++ ["Offset of field: ma_slot_allocator::_ownsHeap"] ++ [::core::mem::offset_of!(ma_slot_allocator, _ownsHeap) - 24usize]; ++ ["Offset of field: ma_slot_allocator::_pHeap"] ++ [::core::mem::offset_of!(ma_slot_allocator, _pHeap) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_slot_allocator_get_heap_size( ++ pConfig: *const ma_slot_allocator_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_init_preallocated( ++ pConfig: *const ma_slot_allocator_config, ++ pHeap: *mut core::ffi::c_void, ++ pAllocator: *mut ma_slot_allocator, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_init( ++ pConfig: *const ma_slot_allocator_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pAllocator: *mut ma_slot_allocator, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_uninit( ++ pAllocator: *mut ma_slot_allocator, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_alloc( ++ pAllocator: *mut ma_slot_allocator, ++ pSlot: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_free(pAllocator: *mut ma_slot_allocator, slot: ma_uint64) ++ -> ma_result; ++} ++pub type ma_job_proc = ::core::option::Option ma_result>; ++pub const ma_job_type_MA_JOB_TYPE_QUIT: ma_job_type = 0; ++pub const ma_job_type_MA_JOB_TYPE_CUSTOM: ma_job_type = 1; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER_NODE: ma_job_type = 2; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER_NODE: ma_job_type = 3; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE: ma_job_type = 4; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER: ma_job_type = 5; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER: ma_job_type = 6; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_STREAM: ma_job_type = 7; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_STREAM: ma_job_type = 8; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_STREAM: ma_job_type = 9; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_SEEK_DATA_STREAM: ma_job_type = 10; ++pub const ma_job_type_MA_JOB_TYPE_DEVICE_AAUDIO_REROUTE: ma_job_type = 11; ++pub const ma_job_type_MA_JOB_TYPE_COUNT: ma_job_type = 12; ++pub type ma_job_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_job { ++ pub toc: ma_job__bindgen_ty_1, ++ pub next: ma_uint64, ++ pub order: ma_uint32, ++ pub data: ma_job__bindgen_ty_2, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_1 { ++ pub breakup: ma_job__bindgen_ty_1__bindgen_ty_1, ++ pub allocation: ma_uint64, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_1__bindgen_ty_1 { ++ pub code: ma_uint16, ++ pub slot: ma_uint16, ++ pub refcount: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_job__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_job__bindgen_ty_1__bindgen_ty_1::code"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1__bindgen_ty_1, code) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_1__bindgen_ty_1::slot"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1__bindgen_ty_1, slot) - 2usize]; ++ ["Offset of field: ma_job__bindgen_ty_1__bindgen_ty_1::refcount"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1__bindgen_ty_1, refcount) - 4usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_1"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_job__bindgen_ty_1"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_1::breakup"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1, breakup) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_1::allocation"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1, allocation) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_2 { ++ pub custom: ma_job__bindgen_ty_2__bindgen_ty_1, ++ pub resourceManager: ma_job__bindgen_ty_2__bindgen_ty_2, ++ pub device: ma_job__bindgen_ty_2__bindgen_ty_3, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_1 { ++ pub proc_: ma_job_proc, ++ pub data0: ma_uintptr, ++ pub data1: ma_uintptr, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_1::proc_"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_1, proc_) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_1::data0"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_1, data0) - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_1::data1"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_1, data1) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_2__bindgen_ty_2 { ++ pub loadDataBufferNode: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pub freeDataBufferNode: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pub pageDataBufferNode: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pub loadDataBuffer: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pub freeDataBuffer: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5, ++ pub loadDataStream: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pub freeDataStream: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7, ++ pub pageDataStream: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8, ++ pub seekDataStream: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1 { ++ pub pResourceManager: *mut core::ffi::c_void, ++ pub pDataBufferNode: *mut core::ffi::c_void, ++ pub pFilePath: *mut core::ffi::c_char, ++ pub pFilePathW: *mut wchar_t, ++ pub flags: ma_uint32, ++ pub pInitNotification: *mut ma_async_notification, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pInitFence: *mut ma_fence, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pResourceManager"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pResourceManager ++ ) ++ - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pDataBufferNode"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pDataBufferNode ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pFilePath"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pFilePath ++ ) - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pFilePathW"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pFilePathW ++ ) - 24usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::flags"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ flags ++ ) - 32usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pInitNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pInitNotification ++ ) ++ - 40usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pDoneNotification ++ ) ++ - 48usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pInitFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pInitFence ++ ) - 56usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pDoneFence ++ ) - 64usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2 { ++ pub pResourceManager: *mut core::ffi::c_void, ++ pub pDataBufferNode: *mut core::ffi::c_void, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2::pResourceManager"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pResourceManager ++ ) ++ - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2::pDataBufferNode"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pDataBufferNode ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pDoneNotification ++ ) ++ - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pDoneFence ++ ) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3 { ++ pub pResourceManager: *mut core::ffi::c_void, ++ pub pDataBufferNode: *mut core::ffi::c_void, ++ pub pDecoder: *mut core::ffi::c_void, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pResourceManager"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pResourceManager ++ ) ++ - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pDataBufferNode"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pDataBufferNode ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pDecoder"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pDecoder ++ ) - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pDoneNotification ++ ) ++ - 24usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pDoneFence ++ ) - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4 { ++ pub pDataBuffer: *mut core::ffi::c_void, ++ pub pInitNotification: *mut ma_async_notification, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pInitFence: *mut ma_fence, ++ pub pDoneFence: *mut ma_fence, ++ pub rangeBegInPCMFrames: ma_uint64, ++ pub rangeEndInPCMFrames: ma_uint64, ++ pub loopPointBegInPCMFrames: ma_uint64, ++ pub loopPointEndInPCMFrames: ma_uint64, ++ pub isLooping: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4"] ++ [::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pDataBuffer"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pDataBuffer ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pInitNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pInitNotification ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pDoneNotification ++ ) ++ - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pInitFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pInitFence ++ ) - 24usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pDoneFence ++ ) - 32usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::rangeBegInPCMFrames"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ rangeBegInPCMFrames ++ ) ++ - 40usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::rangeEndInPCMFrames"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ rangeEndInPCMFrames ++ ) ++ - 48usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::loopPointBegInPCMFrames"] ++ [::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ loopPointBegInPCMFrames ++ ) - 56usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::loopPointEndInPCMFrames"] ++ [::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ loopPointEndInPCMFrames ++ ) - 64usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::isLooping"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ isLooping ++ ) - 72usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5 { ++ pub pDataBuffer: *mut core::ffi::c_void, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5::pDataBuffer"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5, ++ pDataBuffer ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5, ++ pDoneNotification ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5, ++ pDoneFence ++ ) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6 { ++ pub pDataStream: *mut core::ffi::c_void, ++ pub pFilePath: *mut core::ffi::c_char, ++ pub pFilePathW: *mut wchar_t, ++ pub initialSeekPoint: ma_uint64, ++ pub pInitNotification: *mut ma_async_notification, ++ pub pInitFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pDataStream"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pDataStream ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pFilePath"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pFilePath ++ ) - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pFilePathW"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pFilePathW ++ ) - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::initialSeekPoint"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ initialSeekPoint ++ ) ++ - 24usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pInitNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pInitNotification ++ ) ++ - 32usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pInitFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pInitFence ++ ) - 40usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7 { ++ pub pDataStream: *mut core::ffi::c_void, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7::pDataStream"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7, ++ pDataStream ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7, ++ pDoneNotification ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7, ++ pDoneFence ++ ) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8 { ++ pub pDataStream: *mut core::ffi::c_void, ++ pub pageIndex: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8::pDataStream"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8, ++ pDataStream ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8::pageIndex"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8, ++ pageIndex ++ ) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9 { ++ pub pDataStream: *mut core::ffi::c_void, ++ pub frameIndex: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9::pDataStream"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9, ++ pDataStream ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9::frameIndex"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9, ++ frameIndex ++ ) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2"] ++ [::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::loadDataBufferNode"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, loadDataBufferNode) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::freeDataBufferNode"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, freeDataBufferNode) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::pageDataBufferNode"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, pageDataBufferNode) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::loadDataBuffer"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, loadDataBuffer) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::freeDataBuffer"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, freeDataBuffer) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::loadDataStream"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, loadDataStream) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::freeDataStream"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, freeDataStream) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::pageDataStream"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, pageDataStream) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::seekDataStream"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, seekDataStream) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_2__bindgen_ty_3 { ++ pub aaudio: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1 { ++ pub reroute: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1 { ++ pub pDevice: *mut core::ffi::c_void, ++ pub deviceType: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1"][::core::mem::size_of::< ++ ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1, ++ >() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1::pDevice"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1, ++ pDevice ++ ) ++ - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1::deviceType"] ++ [::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1, ++ deviceType ++ ) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1::reroute"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1, ++ reroute ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_3"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_3::aaudio"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_3, aaudio) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_job__bindgen_ty_2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2::custom"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2, custom) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2::resourceManager"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2, resourceManager) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2::device"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2, device) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job"][::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_job"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job::toc"][::core::mem::offset_of!(ma_job, toc) - 0usize]; ++ ["Offset of field: ma_job::next"][::core::mem::offset_of!(ma_job, next) - 8usize]; ++ ["Offset of field: ma_job::order"][::core::mem::offset_of!(ma_job, order) - 16usize]; ++ ["Offset of field: ma_job::data"][::core::mem::offset_of!(ma_job, data) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_job_init(code: ma_uint16) -> ma_job; ++} ++unsafe extern "C" { ++ pub fn ma_job_process(pJob: *mut ma_job) -> ma_result; ++} ++pub const ma_job_queue_flags_MA_JOB_QUEUE_FLAG_NON_BLOCKING: ma_job_queue_flags = 1; ++pub type ma_job_queue_flags = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job_queue_config { ++ pub flags: ma_uint32, ++ pub capacity: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job_queue_config"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_job_queue_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_job_queue_config::flags"] ++ [::core::mem::offset_of!(ma_job_queue_config, flags) - 0usize]; ++ ["Offset of field: ma_job_queue_config::capacity"] ++ [::core::mem::offset_of!(ma_job_queue_config, capacity) - 4usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_job_queue_config_init(flags: ma_uint32, capacity: ma_uint32) -> ma_job_queue_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_job_queue { ++ pub flags: ma_uint32, ++ pub capacity: ma_uint32, ++ pub head: ma_uint64, ++ pub tail: ma_uint64, ++ pub sem: ma_semaphore, ++ pub allocator: ma_slot_allocator, ++ pub pJobs: *mut ma_job, ++ pub lock: ma_spinlock, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job_queue"][::core::mem::size_of::() - 192usize]; ++ ["Alignment of ma_job_queue"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job_queue::flags"][::core::mem::offset_of!(ma_job_queue, flags) - 0usize]; ++ ["Offset of field: ma_job_queue::capacity"] ++ [::core::mem::offset_of!(ma_job_queue, capacity) - 4usize]; ++ ["Offset of field: ma_job_queue::head"][::core::mem::offset_of!(ma_job_queue, head) - 8usize]; ++ ["Offset of field: ma_job_queue::tail"][::core::mem::offset_of!(ma_job_queue, tail) - 16usize]; ++ ["Offset of field: ma_job_queue::sem"][::core::mem::offset_of!(ma_job_queue, sem) - 24usize]; ++ ["Offset of field: ma_job_queue::allocator"] ++ [::core::mem::offset_of!(ma_job_queue, allocator) - 120usize]; ++ ["Offset of field: ma_job_queue::pJobs"] ++ [::core::mem::offset_of!(ma_job_queue, pJobs) - 160usize]; ++ ["Offset of field: ma_job_queue::lock"][::core::mem::offset_of!(ma_job_queue, lock) - 168usize]; ++ ["Offset of field: ma_job_queue::_pHeap"] ++ [::core::mem::offset_of!(ma_job_queue, _pHeap) - 176usize]; ++ ["Offset of field: ma_job_queue::_ownsHeap"] ++ [::core::mem::offset_of!(ma_job_queue, _ownsHeap) - 184usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_job_queue_get_heap_size( ++ pConfig: *const ma_job_queue_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_init_preallocated( ++ pConfig: *const ma_job_queue_config, ++ pHeap: *mut core::ffi::c_void, ++ pQueue: *mut ma_job_queue, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_init( ++ pConfig: *const ma_job_queue_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pQueue: *mut ma_job_queue, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_uninit( ++ pQueue: *mut ma_job_queue, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_post(pQueue: *mut ma_job_queue, pJob: *const ma_job) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_next(pQueue: *mut ma_job_queue, pJob: *mut ma_job) -> ma_result; ++} ++pub const ma_device_state_ma_device_state_uninitialized: ma_device_state = 0; ++pub const ma_device_state_ma_device_state_stopped: ma_device_state = 1; ++pub const ma_device_state_ma_device_state_started: ma_device_state = 2; ++pub const ma_device_state_ma_device_state_starting: ma_device_state = 3; ++pub const ma_device_state_ma_device_state_stopping: ma_device_state = 4; ++pub type ma_device_state = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_device_state { ++ pub value: ma_device_state, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_device_state"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_device_state"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_device_state::value"] ++ [::core::mem::offset_of!(ma_atomic_device_state, value) - 0usize]; ++}; ++pub const ma_backend_ma_backend_wasapi: ma_backend = 0; ++pub const ma_backend_ma_backend_dsound: ma_backend = 1; ++pub const ma_backend_ma_backend_winmm: ma_backend = 2; ++pub const ma_backend_ma_backend_coreaudio: ma_backend = 3; ++pub const ma_backend_ma_backend_sndio: ma_backend = 4; ++pub const ma_backend_ma_backend_audio4: ma_backend = 5; ++pub const ma_backend_ma_backend_oss: ma_backend = 6; ++pub const ma_backend_ma_backend_pulseaudio: ma_backend = 7; ++pub const ma_backend_ma_backend_alsa: ma_backend = 8; ++pub const ma_backend_ma_backend_jack: ma_backend = 9; ++pub const ma_backend_ma_backend_aaudio: ma_backend = 10; ++pub const ma_backend_ma_backend_opensl: ma_backend = 11; ++pub const ma_backend_ma_backend_webaudio: ma_backend = 12; ++pub const ma_backend_ma_backend_custom: ma_backend = 13; ++pub const ma_backend_ma_backend_null: ma_backend = 14; ++pub type ma_backend = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_job_thread_config { ++ pub noThread: ma_bool32, ++ pub jobQueueCapacity: ma_uint32, ++ pub jobQueueFlags: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_job_thread_config"] ++ [::core::mem::size_of::() - 12usize]; ++ ["Alignment of ma_device_job_thread_config"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_job_thread_config::noThread"] ++ [::core::mem::offset_of!(ma_device_job_thread_config, noThread) - 0usize]; ++ ["Offset of field: ma_device_job_thread_config::jobQueueCapacity"] ++ [::core::mem::offset_of!(ma_device_job_thread_config, jobQueueCapacity) - 4usize]; ++ ["Offset of field: ma_device_job_thread_config::jobQueueFlags"] ++ [::core::mem::offset_of!(ma_device_job_thread_config, jobQueueFlags) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_device_job_thread_config_init() -> ma_device_job_thread_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device_job_thread { ++ pub thread: ma_thread, ++ pub jobQueue: ma_job_queue, ++ pub _hasThread: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_job_thread"][::core::mem::size_of::() - 208usize]; ++ ["Alignment of ma_device_job_thread"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_job_thread::thread"] ++ [::core::mem::offset_of!(ma_device_job_thread, thread) - 0usize]; ++ ["Offset of field: ma_device_job_thread::jobQueue"] ++ [::core::mem::offset_of!(ma_device_job_thread, jobQueue) - 8usize]; ++ ["Offset of field: ma_device_job_thread::_hasThread"] ++ [::core::mem::offset_of!(ma_device_job_thread, _hasThread) - 200usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_device_job_thread_init( ++ pConfig: *const ma_device_job_thread_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pJobThread: *mut ma_device_job_thread, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_job_thread_uninit( ++ pJobThread: *mut ma_device_job_thread, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_device_job_thread_post( ++ pJobThread: *mut ma_device_job_thread, ++ pJob: *const ma_job, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_job_thread_next( ++ pJobThread: *mut ma_device_job_thread, ++ pJob: *mut ma_job, ++ ) -> ma_result; ++} ++pub const ma_device_notification_type_ma_device_notification_type_started: ++ ma_device_notification_type = 0; ++pub const ma_device_notification_type_ma_device_notification_type_stopped: ++ ma_device_notification_type = 1; ++pub const ma_device_notification_type_ma_device_notification_type_rerouted: ++ ma_device_notification_type = 2; ++pub const ma_device_notification_type_ma_device_notification_type_interruption_began: ++ ma_device_notification_type = 3; ++pub const ma_device_notification_type_ma_device_notification_type_interruption_ended: ++ ma_device_notification_type = 4; ++pub const ma_device_notification_type_ma_device_notification_type_unlocked: ++ ma_device_notification_type = 5; ++pub type ma_device_notification_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device_notification { ++ pub pDevice: *mut ma_device, ++ pub type_: ma_device_notification_type, ++ pub data: ma_device_notification__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_device_notification__bindgen_ty_1 { ++ pub started: ma_device_notification__bindgen_ty_1__bindgen_ty_1, ++ pub stopped: ma_device_notification__bindgen_ty_1__bindgen_ty_2, ++ pub rerouted: ma_device_notification__bindgen_ty_1__bindgen_ty_3, ++ pub interruption: ma_device_notification__bindgen_ty_1__bindgen_ty_4, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_notification__bindgen_ty_1__bindgen_ty_1 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1__bindgen_ty_1::_unused"][::core::mem::offset_of!( ++ ma_device_notification__bindgen_ty_1__bindgen_ty_1, ++ _unused ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_notification__bindgen_ty_1__bindgen_ty_2 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1__bindgen_ty_2::_unused"][::core::mem::offset_of!( ++ ma_device_notification__bindgen_ty_1__bindgen_ty_2, ++ _unused ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_notification__bindgen_ty_1__bindgen_ty_3 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1__bindgen_ty_3::_unused"][::core::mem::offset_of!( ++ ma_device_notification__bindgen_ty_1__bindgen_ty_3, ++ _unused ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_notification__bindgen_ty_1__bindgen_ty_4 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1__bindgen_ty_4"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1__bindgen_ty_4"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1__bindgen_ty_4::_unused"][::core::mem::offset_of!( ++ ma_device_notification__bindgen_ty_1__bindgen_ty_4, ++ _unused ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1::started"] ++ [::core::mem::offset_of!(ma_device_notification__bindgen_ty_1, started) - 0usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1::stopped"] ++ [::core::mem::offset_of!(ma_device_notification__bindgen_ty_1, stopped) - 0usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1::rerouted"] ++ [::core::mem::offset_of!(ma_device_notification__bindgen_ty_1, rerouted) - 0usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1::interruption"] ++ [::core::mem::offset_of!(ma_device_notification__bindgen_ty_1, interruption) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_device_notification"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_notification::pDevice"] ++ [::core::mem::offset_of!(ma_device_notification, pDevice) - 0usize]; ++ ["Offset of field: ma_device_notification::type_"] ++ [::core::mem::offset_of!(ma_device_notification, type_) - 8usize]; ++ ["Offset of field: ma_device_notification::data"] ++ [::core::mem::offset_of!(ma_device_notification, data) - 12usize]; ++}; ++pub type ma_device_notification_proc = ++ ::core::option::Option; ++pub type ma_device_data_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ pOutput: *mut core::ffi::c_void, ++ pInput: *const core::ffi::c_void, ++ frameCount: ma_uint32, ++ ), ++>; ++pub type ma_stop_proc = ::core::option::Option; ++pub const ma_device_type_ma_device_type_playback: ma_device_type = 1; ++pub const ma_device_type_ma_device_type_capture: ma_device_type = 2; ++pub const ma_device_type_ma_device_type_duplex: ma_device_type = 3; ++pub const ma_device_type_ma_device_type_loopback: ma_device_type = 4; ++pub type ma_device_type = core::ffi::c_uint; ++pub const ma_share_mode_ma_share_mode_shared: ma_share_mode = 0; ++pub const ma_share_mode_ma_share_mode_exclusive: ma_share_mode = 1; ++pub type ma_share_mode = core::ffi::c_uint; ++pub const ma_ios_session_category_ma_ios_session_category_default: ma_ios_session_category = 0; ++pub const ma_ios_session_category_ma_ios_session_category_none: ma_ios_session_category = 1; ++pub const ma_ios_session_category_ma_ios_session_category_ambient: ma_ios_session_category = 2; ++pub const ma_ios_session_category_ma_ios_session_category_solo_ambient: ma_ios_session_category = 3; ++pub const ma_ios_session_category_ma_ios_session_category_playback: ma_ios_session_category = 4; ++pub const ma_ios_session_category_ma_ios_session_category_record: ma_ios_session_category = 5; ++pub const ma_ios_session_category_ma_ios_session_category_play_and_record: ma_ios_session_category = ++ 6; ++pub const ma_ios_session_category_ma_ios_session_category_multi_route: ma_ios_session_category = 7; ++pub type ma_ios_session_category = core::ffi::c_uint; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_mix_with_others: ++ ma_ios_session_category_option = 1; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_duck_others: ++ ma_ios_session_category_option = 2; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_allow_bluetooth: ++ ma_ios_session_category_option = 4; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_default_to_speaker: ++ ma_ios_session_category_option = 8; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_interrupt_spoken_audio_and_mix_with_others : ma_ios_session_category_option = 17 ; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_allow_bluetooth_a2dp: ++ ma_ios_session_category_option = 32; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_allow_air_play: ++ ma_ios_session_category_option = 64; ++pub type ma_ios_session_category_option = core::ffi::c_uint; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_default: ma_opensl_stream_type = 0; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_voice: ma_opensl_stream_type = 1; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_system: ma_opensl_stream_type = 2; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_ring: ma_opensl_stream_type = 3; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_media: ma_opensl_stream_type = 4; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_alarm: ma_opensl_stream_type = 5; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_notification: ma_opensl_stream_type = 6; ++pub type ma_opensl_stream_type = core::ffi::c_uint; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_default: ++ ma_opensl_recording_preset = 0; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_generic: ++ ma_opensl_recording_preset = 1; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_camcorder: ++ ma_opensl_recording_preset = 2; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_voice_recognition: ++ ma_opensl_recording_preset = 3; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_voice_communication: ++ ma_opensl_recording_preset = 4; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_voice_unprocessed: ++ ma_opensl_recording_preset = 5; ++pub type ma_opensl_recording_preset = core::ffi::c_uint; ++pub const ma_wasapi_usage_ma_wasapi_usage_default: ma_wasapi_usage = 0; ++pub const ma_wasapi_usage_ma_wasapi_usage_games: ma_wasapi_usage = 1; ++pub const ma_wasapi_usage_ma_wasapi_usage_pro_audio: ma_wasapi_usage = 2; ++pub type ma_wasapi_usage = core::ffi::c_uint; ++pub const ma_aaudio_usage_ma_aaudio_usage_default: ma_aaudio_usage = 0; ++pub const ma_aaudio_usage_ma_aaudio_usage_media: ma_aaudio_usage = 1; ++pub const ma_aaudio_usage_ma_aaudio_usage_voice_communication: ma_aaudio_usage = 2; ++pub const ma_aaudio_usage_ma_aaudio_usage_voice_communication_signalling: ma_aaudio_usage = 3; ++pub const ma_aaudio_usage_ma_aaudio_usage_alarm: ma_aaudio_usage = 4; ++pub const ma_aaudio_usage_ma_aaudio_usage_notification: ma_aaudio_usage = 5; ++pub const ma_aaudio_usage_ma_aaudio_usage_notification_ringtone: ma_aaudio_usage = 6; ++pub const ma_aaudio_usage_ma_aaudio_usage_notification_event: ma_aaudio_usage = 7; ++pub const ma_aaudio_usage_ma_aaudio_usage_assistance_accessibility: ma_aaudio_usage = 8; ++pub const ma_aaudio_usage_ma_aaudio_usage_assistance_navigation_guidance: ma_aaudio_usage = 9; ++pub const ma_aaudio_usage_ma_aaudio_usage_assistance_sonification: ma_aaudio_usage = 10; ++pub const ma_aaudio_usage_ma_aaudio_usage_game: ma_aaudio_usage = 11; ++pub const ma_aaudio_usage_ma_aaudio_usage_assitant: ma_aaudio_usage = 12; ++pub const ma_aaudio_usage_ma_aaudio_usage_emergency: ma_aaudio_usage = 13; ++pub const ma_aaudio_usage_ma_aaudio_usage_safety: ma_aaudio_usage = 14; ++pub const ma_aaudio_usage_ma_aaudio_usage_vehicle_status: ma_aaudio_usage = 15; ++pub const ma_aaudio_usage_ma_aaudio_usage_announcement: ma_aaudio_usage = 16; ++pub type ma_aaudio_usage = core::ffi::c_uint; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_default: ma_aaudio_content_type = 0; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_speech: ma_aaudio_content_type = 1; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_music: ma_aaudio_content_type = 2; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_movie: ma_aaudio_content_type = 3; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_sonification: ma_aaudio_content_type = 4; ++pub type ma_aaudio_content_type = core::ffi::c_uint; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_default: ma_aaudio_input_preset = 0; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_generic: ma_aaudio_input_preset = 1; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_camcorder: ma_aaudio_input_preset = 2; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_voice_recognition: ma_aaudio_input_preset = ++ 3; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_voice_communication: ++ ma_aaudio_input_preset = 4; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_unprocessed: ma_aaudio_input_preset = 5; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_voice_performance: ma_aaudio_input_preset = ++ 6; ++pub type ma_aaudio_input_preset = core::ffi::c_uint; ++pub const ma_aaudio_allowed_capture_policy_ma_aaudio_allow_capture_default: ++ ma_aaudio_allowed_capture_policy = 0; ++pub const ma_aaudio_allowed_capture_policy_ma_aaudio_allow_capture_by_all: ++ ma_aaudio_allowed_capture_policy = 1; ++pub const ma_aaudio_allowed_capture_policy_ma_aaudio_allow_capture_by_system: ++ ma_aaudio_allowed_capture_policy = 2; ++pub const ma_aaudio_allowed_capture_policy_ma_aaudio_allow_capture_by_none: ++ ma_aaudio_allowed_capture_policy = 3; ++pub type ma_aaudio_allowed_capture_policy = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_timer { ++ pub counter: ma_int64, ++ pub counterD: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_timer"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_timer"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_timer::counter"][::core::mem::offset_of!(ma_timer, counter) - 0usize]; ++ ["Offset of field: ma_timer::counterD"][::core::mem::offset_of!(ma_timer, counterD) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_device_id { ++ pub wasapi: [ma_wchar_win32; 64usize], ++ pub dsound: [ma_uint8; 16usize], ++ pub winmm: ma_uint32, ++ pub alsa: [core::ffi::c_char; 256usize], ++ pub pulse: [core::ffi::c_char; 256usize], ++ pub jack: core::ffi::c_int, ++ pub coreaudio: [core::ffi::c_char; 256usize], ++ pub sndio: [core::ffi::c_char; 256usize], ++ pub audio4: [core::ffi::c_char; 256usize], ++ pub oss: [core::ffi::c_char; 64usize], ++ pub aaudio: ma_int32, ++ pub opensl: ma_uint32, ++ pub webaudio: [core::ffi::c_char; 32usize], ++ pub custom: ma_device_id__bindgen_ty_1, ++ pub nullbackend: core::ffi::c_int, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_device_id__bindgen_ty_1 { ++ pub i: core::ffi::c_int, ++ pub s: [core::ffi::c_char; 256usize], ++ pub p: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_id__bindgen_ty_1"] ++ [::core::mem::size_of::() - 256usize]; ++ ["Alignment of ma_device_id__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_id__bindgen_ty_1::i"] ++ [::core::mem::offset_of!(ma_device_id__bindgen_ty_1, i) - 0usize]; ++ ["Offset of field: ma_device_id__bindgen_ty_1::s"] ++ [::core::mem::offset_of!(ma_device_id__bindgen_ty_1, s) - 0usize]; ++ ["Offset of field: ma_device_id__bindgen_ty_1::p"] ++ [::core::mem::offset_of!(ma_device_id__bindgen_ty_1, p) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_id"][::core::mem::size_of::() - 256usize]; ++ ["Alignment of ma_device_id"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_id::wasapi"] ++ [::core::mem::offset_of!(ma_device_id, wasapi) - 0usize]; ++ ["Offset of field: ma_device_id::dsound"] ++ [::core::mem::offset_of!(ma_device_id, dsound) - 0usize]; ++ ["Offset of field: ma_device_id::winmm"][::core::mem::offset_of!(ma_device_id, winmm) - 0usize]; ++ ["Offset of field: ma_device_id::alsa"][::core::mem::offset_of!(ma_device_id, alsa) - 0usize]; ++ ["Offset of field: ma_device_id::pulse"][::core::mem::offset_of!(ma_device_id, pulse) - 0usize]; ++ ["Offset of field: ma_device_id::jack"][::core::mem::offset_of!(ma_device_id, jack) - 0usize]; ++ ["Offset of field: ma_device_id::coreaudio"] ++ [::core::mem::offset_of!(ma_device_id, coreaudio) - 0usize]; ++ ["Offset of field: ma_device_id::sndio"][::core::mem::offset_of!(ma_device_id, sndio) - 0usize]; ++ ["Offset of field: ma_device_id::audio4"] ++ [::core::mem::offset_of!(ma_device_id, audio4) - 0usize]; ++ ["Offset of field: ma_device_id::oss"][::core::mem::offset_of!(ma_device_id, oss) - 0usize]; ++ ["Offset of field: ma_device_id::aaudio"] ++ [::core::mem::offset_of!(ma_device_id, aaudio) - 0usize]; ++ ["Offset of field: ma_device_id::opensl"] ++ [::core::mem::offset_of!(ma_device_id, opensl) - 0usize]; ++ ["Offset of field: ma_device_id::webaudio"] ++ [::core::mem::offset_of!(ma_device_id, webaudio) - 0usize]; ++ ["Offset of field: ma_device_id::custom"] ++ [::core::mem::offset_of!(ma_device_id, custom) - 0usize]; ++ ["Offset of field: ma_device_id::nullbackend"] ++ [::core::mem::offset_of!(ma_device_id, nullbackend) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_device_id_equal(pA: *const ma_device_id, pB: *const ma_device_id) -> ma_bool32; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device_info { ++ pub id: ma_device_id, ++ pub name: [core::ffi::c_char; 256usize], ++ pub isDefault: ma_bool32, ++ pub nativeDataFormatCount: ma_uint32, ++ pub nativeDataFormats: [ma_device_info__bindgen_ty_1; 64usize], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_info__bindgen_ty_1 { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub flags: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_info__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_device_info__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_info__bindgen_ty_1::format"] ++ [::core::mem::offset_of!(ma_device_info__bindgen_ty_1, format) - 0usize]; ++ ["Offset of field: ma_device_info__bindgen_ty_1::channels"] ++ [::core::mem::offset_of!(ma_device_info__bindgen_ty_1, channels) - 4usize]; ++ ["Offset of field: ma_device_info__bindgen_ty_1::sampleRate"] ++ [::core::mem::offset_of!(ma_device_info__bindgen_ty_1, sampleRate) - 8usize]; ++ ["Offset of field: ma_device_info__bindgen_ty_1::flags"] ++ [::core::mem::offset_of!(ma_device_info__bindgen_ty_1, flags) - 12usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_info"][::core::mem::size_of::() - 1544usize]; ++ ["Alignment of ma_device_info"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_info::id"][::core::mem::offset_of!(ma_device_info, id) - 0usize]; ++ ["Offset of field: ma_device_info::name"] ++ [::core::mem::offset_of!(ma_device_info, name) - 256usize]; ++ ["Offset of field: ma_device_info::isDefault"] ++ [::core::mem::offset_of!(ma_device_info, isDefault) - 512usize]; ++ ["Offset of field: ma_device_info::nativeDataFormatCount"] ++ [::core::mem::offset_of!(ma_device_info, nativeDataFormatCount) - 516usize]; ++ ["Offset of field: ma_device_info::nativeDataFormats"] ++ [::core::mem::offset_of!(ma_device_info, nativeDataFormats) - 520usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config { ++ pub deviceType: ma_device_type, ++ pub sampleRate: ma_uint32, ++ pub periodSizeInFrames: ma_uint32, ++ pub periodSizeInMilliseconds: ma_uint32, ++ pub periods: ma_uint32, ++ pub performanceProfile: ma_performance_profile, ++ pub noPreSilencedOutputBuffer: ma_bool8, ++ pub noClip: ma_bool8, ++ pub noDisableDenormals: ma_bool8, ++ pub noFixedSizedCallback: ma_bool8, ++ pub dataCallback: ma_device_data_proc, ++ pub notificationCallback: ma_device_notification_proc, ++ pub stopCallback: ma_stop_proc, ++ pub pUserData: *mut core::ffi::c_void, ++ pub resampling: ma_resampler_config, ++ pub playback: ma_device_config__bindgen_ty_1, ++ pub capture: ma_device_config__bindgen_ty_2, ++ pub wasapi: ma_device_config__bindgen_ty_3, ++ pub alsa: ma_device_config__bindgen_ty_4, ++ pub pulse: ma_device_config__bindgen_ty_5, ++ pub coreaudio: ma_device_config__bindgen_ty_6, ++ pub opensl: ma_device_config__bindgen_ty_7, ++ pub aaudio: ma_device_config__bindgen_ty_8, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_1 { ++ pub pDeviceID: *const ma_device_id, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub pChannelMap: *mut ma_channel, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub shareMode: ma_share_mode, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_1"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_device_config__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::pDeviceID"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, pDeviceID) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::format"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, format) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::channels"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, channels) - 12usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::pChannelMap"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, pChannelMap) - 16usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::channelMixMode"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, channelMixMode) - 24usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_1, ++ calculateLFEFromSpatialChannels ++ ) ++ - 28usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::shareMode"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, shareMode) - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_2 { ++ pub pDeviceID: *const ma_device_id, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub pChannelMap: *mut ma_channel, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub shareMode: ma_share_mode, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_2"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_device_config__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::pDeviceID"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, pDeviceID) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::format"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, format) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::channels"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, channels) - 12usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::pChannelMap"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, pChannelMap) - 16usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::channelMixMode"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, channelMixMode) - 24usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_2, ++ calculateLFEFromSpatialChannels ++ ) ++ - 28usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::shareMode"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, shareMode) - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_3 { ++ pub usage: ma_wasapi_usage, ++ pub noAutoConvertSRC: ma_bool8, ++ pub noDefaultQualitySRC: ma_bool8, ++ pub noAutoStreamRouting: ma_bool8, ++ pub noHardwareOffloading: ma_bool8, ++ pub loopbackProcessID: ma_uint32, ++ pub loopbackProcessExclude: ma_bool8, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_3"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_device_config__bindgen_ty_3"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::usage"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, usage) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::noAutoConvertSRC"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, noAutoConvertSRC) - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::noDefaultQualitySRC"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, noDefaultQualitySRC) - 5usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::noAutoStreamRouting"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, noAutoStreamRouting) - 6usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::noHardwareOffloading"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, noHardwareOffloading) - 7usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::loopbackProcessID"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, loopbackProcessID) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::loopbackProcessExclude"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, loopbackProcessExclude) - 12usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_4 { ++ pub noMMap: ma_bool32, ++ pub noAutoFormat: ma_bool32, ++ pub noAutoChannels: ma_bool32, ++ pub noAutoResample: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_4"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_device_config__bindgen_ty_4"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_4::noMMap"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_4, noMMap) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_4::noAutoFormat"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_4, noAutoFormat) - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_4::noAutoChannels"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_4, noAutoChannels) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_4::noAutoResample"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_4, noAutoResample) - 12usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_5 { ++ pub pStreamNamePlayback: *const core::ffi::c_char, ++ pub pStreamNameCapture: *const core::ffi::c_char, ++ pub channelMap: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_5"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_device_config__bindgen_ty_5"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_5::pStreamNamePlayback"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_5, pStreamNamePlayback) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_5::pStreamNameCapture"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_5, pStreamNameCapture) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_5::channelMap"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_5, channelMap) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_6 { ++ pub allowNominalSampleRateChange: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_6"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_config__bindgen_ty_6"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_6::allowNominalSampleRateChange"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_6, ++ allowNominalSampleRateChange ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_7 { ++ pub streamType: ma_opensl_stream_type, ++ pub recordingPreset: ma_opensl_recording_preset, ++ pub enableCompatibilityWorkarounds: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_7"] ++ [::core::mem::size_of::() - 12usize]; ++ ["Alignment of ma_device_config__bindgen_ty_7"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_7::streamType"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_7, streamType) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_7::recordingPreset"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_7, recordingPreset) - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_7::enableCompatibilityWorkarounds"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_7, ++ enableCompatibilityWorkarounds ++ ) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_8 { ++ pub usage: ma_aaudio_usage, ++ pub contentType: ma_aaudio_content_type, ++ pub inputPreset: ma_aaudio_input_preset, ++ pub allowedCapturePolicy: ma_aaudio_allowed_capture_policy, ++ pub noAutoStartAfterReroute: ma_bool32, ++ pub enableCompatibilityWorkarounds: ma_bool32, ++ pub allowSetBufferCapacity: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_8"] ++ [::core::mem::size_of::() - 28usize]; ++ ["Alignment of ma_device_config__bindgen_ty_8"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::usage"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, usage) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::contentType"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, contentType) - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::inputPreset"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, inputPreset) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::allowedCapturePolicy"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, allowedCapturePolicy) - 12usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::noAutoStartAfterReroute"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_8, ++ noAutoStartAfterReroute ++ ) - 16usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::enableCompatibilityWorkarounds"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_8, ++ enableCompatibilityWorkarounds ++ ) ++ - 20usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::allowSetBufferCapacity"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, allowSetBufferCapacity) - 24usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config"][::core::mem::size_of::() - 296usize]; ++ ["Alignment of ma_device_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_config::deviceType"] ++ [::core::mem::offset_of!(ma_device_config, deviceType) - 0usize]; ++ ["Offset of field: ma_device_config::sampleRate"] ++ [::core::mem::offset_of!(ma_device_config, sampleRate) - 4usize]; ++ ["Offset of field: ma_device_config::periodSizeInFrames"] ++ [::core::mem::offset_of!(ma_device_config, periodSizeInFrames) - 8usize]; ++ ["Offset of field: ma_device_config::periodSizeInMilliseconds"] ++ [::core::mem::offset_of!(ma_device_config, periodSizeInMilliseconds) - 12usize]; ++ ["Offset of field: ma_device_config::periods"] ++ [::core::mem::offset_of!(ma_device_config, periods) - 16usize]; ++ ["Offset of field: ma_device_config::performanceProfile"] ++ [::core::mem::offset_of!(ma_device_config, performanceProfile) - 20usize]; ++ ["Offset of field: ma_device_config::noPreSilencedOutputBuffer"] ++ [::core::mem::offset_of!(ma_device_config, noPreSilencedOutputBuffer) - 24usize]; ++ ["Offset of field: ma_device_config::noClip"] ++ [::core::mem::offset_of!(ma_device_config, noClip) - 25usize]; ++ ["Offset of field: ma_device_config::noDisableDenormals"] ++ [::core::mem::offset_of!(ma_device_config, noDisableDenormals) - 26usize]; ++ ["Offset of field: ma_device_config::noFixedSizedCallback"] ++ [::core::mem::offset_of!(ma_device_config, noFixedSizedCallback) - 27usize]; ++ ["Offset of field: ma_device_config::dataCallback"] ++ [::core::mem::offset_of!(ma_device_config, dataCallback) - 32usize]; ++ ["Offset of field: ma_device_config::notificationCallback"] ++ [::core::mem::offset_of!(ma_device_config, notificationCallback) - 40usize]; ++ ["Offset of field: ma_device_config::stopCallback"] ++ [::core::mem::offset_of!(ma_device_config, stopCallback) - 48usize]; ++ ["Offset of field: ma_device_config::pUserData"] ++ [::core::mem::offset_of!(ma_device_config, pUserData) - 56usize]; ++ ["Offset of field: ma_device_config::resampling"] ++ [::core::mem::offset_of!(ma_device_config, resampling) - 64usize]; ++ ["Offset of field: ma_device_config::playback"] ++ [::core::mem::offset_of!(ma_device_config, playback) - 112usize]; ++ ["Offset of field: ma_device_config::capture"] ++ [::core::mem::offset_of!(ma_device_config, capture) - 152usize]; ++ ["Offset of field: ma_device_config::wasapi"] ++ [::core::mem::offset_of!(ma_device_config, wasapi) - 192usize]; ++ ["Offset of field: ma_device_config::alsa"] ++ [::core::mem::offset_of!(ma_device_config, alsa) - 208usize]; ++ ["Offset of field: ma_device_config::pulse"] ++ [::core::mem::offset_of!(ma_device_config, pulse) - 224usize]; ++ ["Offset of field: ma_device_config::coreaudio"] ++ [::core::mem::offset_of!(ma_device_config, coreaudio) - 248usize]; ++ ["Offset of field: ma_device_config::opensl"] ++ [::core::mem::offset_of!(ma_device_config, opensl) - 252usize]; ++ ["Offset of field: ma_device_config::aaudio"] ++ [::core::mem::offset_of!(ma_device_config, aaudio) - 264usize]; ++}; ++pub type ma_enum_devices_callback_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pContext: *mut ma_context, ++ deviceType: ma_device_type, ++ pInfo: *const ma_device_info, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_bool32, ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_descriptor { ++ pub pDeviceID: *const ma_device_id, ++ pub shareMode: ma_share_mode, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub channelMap: [ma_channel; 254usize], ++ pub periodSizeInFrames: ma_uint32, ++ pub periodSizeInMilliseconds: ma_uint32, ++ pub periodCount: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_descriptor"][::core::mem::size_of::() - 296usize]; ++ ["Alignment of ma_device_descriptor"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_descriptor::pDeviceID"] ++ [::core::mem::offset_of!(ma_device_descriptor, pDeviceID) - 0usize]; ++ ["Offset of field: ma_device_descriptor::shareMode"] ++ [::core::mem::offset_of!(ma_device_descriptor, shareMode) - 8usize]; ++ ["Offset of field: ma_device_descriptor::format"] ++ [::core::mem::offset_of!(ma_device_descriptor, format) - 12usize]; ++ ["Offset of field: ma_device_descriptor::channels"] ++ [::core::mem::offset_of!(ma_device_descriptor, channels) - 16usize]; ++ ["Offset of field: ma_device_descriptor::sampleRate"] ++ [::core::mem::offset_of!(ma_device_descriptor, sampleRate) - 20usize]; ++ ["Offset of field: ma_device_descriptor::channelMap"] ++ [::core::mem::offset_of!(ma_device_descriptor, channelMap) - 24usize]; ++ ["Offset of field: ma_device_descriptor::periodSizeInFrames"] ++ [::core::mem::offset_of!(ma_device_descriptor, periodSizeInFrames) - 280usize]; ++ ["Offset of field: ma_device_descriptor::periodSizeInMilliseconds"] ++ [::core::mem::offset_of!(ma_device_descriptor, periodSizeInMilliseconds) - 284usize]; ++ ["Offset of field: ma_device_descriptor::periodCount"] ++ [::core::mem::offset_of!(ma_device_descriptor, periodCount) - 288usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_backend_callbacks { ++ pub onContextInit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pContext: *mut ma_context, ++ pConfig: *const ma_context_config, ++ pCallbacks: *mut ma_backend_callbacks, ++ ) -> ma_result, ++ >, ++ pub onContextUninit: ++ ::core::option::Option ma_result>, ++ pub onContextEnumerateDevices: ::core::option::Option< ++ unsafe extern "C" fn( ++ pContext: *mut ma_context, ++ callback: ma_enum_devices_callback_proc, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_result, ++ >, ++ pub onContextGetDeviceInfo: ::core::option::Option< ++ unsafe extern "C" fn( ++ pContext: *mut ma_context, ++ deviceType: ma_device_type, ++ pDeviceID: *const ma_device_id, ++ pDeviceInfo: *mut ma_device_info, ++ ) -> ma_result, ++ >, ++ pub onDeviceInit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ pConfig: *const ma_device_config, ++ pDescriptorPlayback: *mut ma_device_descriptor, ++ pDescriptorCapture: *mut ma_device_descriptor, ++ ) -> ma_result, ++ >, ++ pub onDeviceUninit: ++ ::core::option::Option ma_result>, ++ pub onDeviceStart: ++ ::core::option::Option ma_result>, ++ pub onDeviceStop: ++ ::core::option::Option ma_result>, ++ pub onDeviceRead: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ pFrames: *mut core::ffi::c_void, ++ frameCount: ma_uint32, ++ pFramesRead: *mut ma_uint32, ++ ) -> ma_result, ++ >, ++ pub onDeviceWrite: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ pFrames: *const core::ffi::c_void, ++ frameCount: ma_uint32, ++ pFramesWritten: *mut ma_uint32, ++ ) -> ma_result, ++ >, ++ pub onDeviceDataLoop: ++ ::core::option::Option ma_result>, ++ pub onDeviceDataLoopWakeup: ++ ::core::option::Option ma_result>, ++ pub onDeviceGetInfo: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ type_: ma_device_type, ++ pDeviceInfo: *mut ma_device_info, ++ ) -> ma_result, ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_backend_callbacks"][::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_backend_callbacks"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_backend_callbacks::onContextInit"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onContextInit) - 0usize]; ++ ["Offset of field: ma_backend_callbacks::onContextUninit"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onContextUninit) - 8usize]; ++ ["Offset of field: ma_backend_callbacks::onContextEnumerateDevices"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onContextEnumerateDevices) - 16usize]; ++ ["Offset of field: ma_backend_callbacks::onContextGetDeviceInfo"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onContextGetDeviceInfo) - 24usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceInit"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceInit) - 32usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceUninit"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceUninit) - 40usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceStart"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceStart) - 48usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceStop"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceStop) - 56usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceRead"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceRead) - 64usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceWrite"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceWrite) - 72usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceDataLoop"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceDataLoop) - 80usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceDataLoopWakeup"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceDataLoopWakeup) - 88usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceGetInfo"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceGetInfo) - 96usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config { ++ pub pLog: *mut ma_log, ++ pub threadPriority: ma_thread_priority, ++ pub threadStackSize: usize, ++ pub pUserData: *mut core::ffi::c_void, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub dsound: ma_context_config__bindgen_ty_1, ++ pub alsa: ma_context_config__bindgen_ty_2, ++ pub pulse: ma_context_config__bindgen_ty_3, ++ pub coreaudio: ma_context_config__bindgen_ty_4, ++ pub jack: ma_context_config__bindgen_ty_5, ++ pub custom: ma_backend_callbacks, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_1 { ++ pub hWnd: ma_handle, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_1"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_context_config__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_1::hWnd"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_1, hWnd) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_2 { ++ pub useVerboseDeviceEnumeration: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_2"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context_config__bindgen_ty_2"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_2::useVerboseDeviceEnumeration"][::core::mem::offset_of!( ++ ma_context_config__bindgen_ty_2, ++ useVerboseDeviceEnumeration ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_3 { ++ pub pApplicationName: *const core::ffi::c_char, ++ pub pServerName: *const core::ffi::c_char, ++ pub tryAutoSpawn: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_3"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_context_config__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_3::pApplicationName"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_3, pApplicationName) - 0usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_3::pServerName"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_3, pServerName) - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_3::tryAutoSpawn"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_3, tryAutoSpawn) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_4 { ++ pub sessionCategory: ma_ios_session_category, ++ pub sessionCategoryOptions: ma_uint32, ++ pub noAudioSessionActivate: ma_bool32, ++ pub noAudioSessionDeactivate: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_4"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_context_config__bindgen_ty_4"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_4::sessionCategory"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_4, sessionCategory) - 0usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_4::sessionCategoryOptions"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_4, sessionCategoryOptions) - 4usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_4::noAudioSessionActivate"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_4, noAudioSessionActivate) - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_4::noAudioSessionDeactivate"][::core::mem::offset_of!( ++ ma_context_config__bindgen_ty_4, ++ noAudioSessionDeactivate ++ ) - 12usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_5 { ++ pub pClientName: *const core::ffi::c_char, ++ pub tryStartServer: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_5"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_context_config__bindgen_ty_5"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_5::pClientName"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_5, pClientName) - 0usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_5::tryStartServer"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_5, tryStartServer) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config"][::core::mem::size_of::() - 240usize]; ++ ["Alignment of ma_context_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_config::pLog"] ++ [::core::mem::offset_of!(ma_context_config, pLog) - 0usize]; ++ ["Offset of field: ma_context_config::threadPriority"] ++ [::core::mem::offset_of!(ma_context_config, threadPriority) - 8usize]; ++ ["Offset of field: ma_context_config::threadStackSize"] ++ [::core::mem::offset_of!(ma_context_config, threadStackSize) - 16usize]; ++ ["Offset of field: ma_context_config::pUserData"] ++ [::core::mem::offset_of!(ma_context_config, pUserData) - 24usize]; ++ ["Offset of field: ma_context_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_context_config, allocationCallbacks) - 32usize]; ++ ["Offset of field: ma_context_config::dsound"] ++ [::core::mem::offset_of!(ma_context_config, dsound) - 64usize]; ++ ["Offset of field: ma_context_config::alsa"] ++ [::core::mem::offset_of!(ma_context_config, alsa) - 72usize]; ++ ["Offset of field: ma_context_config::pulse"] ++ [::core::mem::offset_of!(ma_context_config, pulse) - 80usize]; ++ ["Offset of field: ma_context_config::coreaudio"] ++ [::core::mem::offset_of!(ma_context_config, coreaudio) - 104usize]; ++ ["Offset of field: ma_context_config::jack"] ++ [::core::mem::offset_of!(ma_context_config, jack) - 120usize]; ++ ["Offset of field: ma_context_config::custom"] ++ [::core::mem::offset_of!(ma_context_config, custom) - 136usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_context_command__wasapi { ++ pub code: core::ffi::c_int, ++ pub pEvent: *mut ma_event, ++ pub data: ma_context_command__wasapi__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_context_command__wasapi__bindgen_ty_1 { ++ pub quit: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1, ++ pub createAudioClient: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ pub releaseAudioClient: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1"][::core::mem::align_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1, ++ >() - 4usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1::_unused"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1, ++ _unused ++ ) ++ - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2 { ++ pub deviceType: ma_device_type, ++ pub pAudioClient: *mut core::ffi::c_void, ++ pub ppAudioClientService: *mut *mut core::ffi::c_void, ++ pub pResult: *mut ma_result, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2"][::core::mem::size_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ >() - 32usize]; ++ ["Alignment of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2"][::core::mem::align_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ >() - 8usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2::deviceType"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ deviceType ++ ) ++ - 0usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2::pAudioClient"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ pAudioClient ++ ) ++ - 8usize]; ++ [ ++ "Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2::ppAudioClientService", ++ ][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ ppAudioClientService ++ ) - 16usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2::pResult"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ pResult ++ ) ++ - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3 { ++ pub pDevice: *mut ma_device, ++ pub deviceType: ma_device_type, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3"][::core::mem::size_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++ >() - 16usize]; ++ ["Alignment of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3"][::core::mem::align_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++ >() - 8usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3::pDevice"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++ pDevice ++ ) ++ - 0usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3::deviceType"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++ deviceType ++ ) ++ - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi__bindgen_ty_1"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_context_command__wasapi__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1::quit"] ++ [::core::mem::offset_of!(ma_context_command__wasapi__bindgen_ty_1, quit) - 0usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1::createAudioClient"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1, ++ createAudioClient ++ ) - 0usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1::releaseAudioClient"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1, ++ releaseAudioClient ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_context_command__wasapi"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_command__wasapi::code"] ++ [::core::mem::offset_of!(ma_context_command__wasapi, code) - 0usize]; ++ ["Offset of field: ma_context_command__wasapi::pEvent"] ++ [::core::mem::offset_of!(ma_context_command__wasapi, pEvent) - 8usize]; ++ ["Offset of field: ma_context_command__wasapi::data"] ++ [::core::mem::offset_of!(ma_context_command__wasapi, data) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_context { ++ pub callbacks: ma_backend_callbacks, ++ pub backend: ma_backend, ++ pub pLog: *mut ma_log, ++ pub log: ma_log, ++ pub threadPriority: ma_thread_priority, ++ pub threadStackSize: usize, ++ pub pUserData: *mut core::ffi::c_void, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub deviceEnumLock: ma_mutex, ++ pub deviceInfoLock: ma_mutex, ++ pub deviceInfoCapacity: ma_uint32, ++ pub playbackDeviceInfoCount: ma_uint32, ++ pub captureDeviceInfoCount: ma_uint32, ++ pub pDeviceInfos: *mut ma_device_info, ++ pub __bindgen_anon_1: ma_context__bindgen_ty_1, ++ pub __bindgen_anon_2: ma_context__bindgen_ty_2, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_context__bindgen_ty_1 { ++ pub alsa: ma_context__bindgen_ty_1__bindgen_ty_1, ++ pub pulse: ma_context__bindgen_ty_1__bindgen_ty_2, ++ pub jack: ma_context__bindgen_ty_1__bindgen_ty_3, ++ pub null_backend: ma_context__bindgen_ty_1__bindgen_ty_4, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_context__bindgen_ty_1__bindgen_ty_1 { ++ pub asoundSO: ma_handle, ++ pub snd_pcm_open: ma_proc, ++ pub snd_pcm_close: ma_proc, ++ pub snd_pcm_hw_params_sizeof: ma_proc, ++ pub snd_pcm_hw_params_any: ma_proc, ++ pub snd_pcm_hw_params_set_format: ma_proc, ++ pub snd_pcm_hw_params_set_format_first: ma_proc, ++ pub snd_pcm_hw_params_get_format_mask: ma_proc, ++ pub snd_pcm_hw_params_set_channels: ma_proc, ++ pub snd_pcm_hw_params_set_channels_near: ma_proc, ++ pub snd_pcm_hw_params_set_channels_minmax: ma_proc, ++ pub snd_pcm_hw_params_set_rate_resample: ma_proc, ++ pub snd_pcm_hw_params_set_rate: ma_proc, ++ pub snd_pcm_hw_params_set_rate_near: ma_proc, ++ pub snd_pcm_hw_params_set_rate_minmax: ma_proc, ++ pub snd_pcm_hw_params_set_buffer_size_near: ma_proc, ++ pub snd_pcm_hw_params_set_periods_near: ma_proc, ++ pub snd_pcm_hw_params_set_access: ma_proc, ++ pub snd_pcm_hw_params_get_format: ma_proc, ++ pub snd_pcm_hw_params_get_channels: ma_proc, ++ pub snd_pcm_hw_params_get_channels_min: ma_proc, ++ pub snd_pcm_hw_params_get_channels_max: ma_proc, ++ pub snd_pcm_hw_params_get_rate: ma_proc, ++ pub snd_pcm_hw_params_get_rate_min: ma_proc, ++ pub snd_pcm_hw_params_get_rate_max: ma_proc, ++ pub snd_pcm_hw_params_get_buffer_size: ma_proc, ++ pub snd_pcm_hw_params_get_periods: ma_proc, ++ pub snd_pcm_hw_params_get_access: ma_proc, ++ pub snd_pcm_hw_params_test_format: ma_proc, ++ pub snd_pcm_hw_params_test_channels: ma_proc, ++ pub snd_pcm_hw_params_test_rate: ma_proc, ++ pub snd_pcm_hw_params: ma_proc, ++ pub snd_pcm_sw_params_sizeof: ma_proc, ++ pub snd_pcm_sw_params_current: ma_proc, ++ pub snd_pcm_sw_params_get_boundary: ma_proc, ++ pub snd_pcm_sw_params_set_avail_min: ma_proc, ++ pub snd_pcm_sw_params_set_start_threshold: ma_proc, ++ pub snd_pcm_sw_params_set_stop_threshold: ma_proc, ++ pub snd_pcm_sw_params: ma_proc, ++ pub snd_pcm_format_mask_sizeof: ma_proc, ++ pub snd_pcm_format_mask_test: ma_proc, ++ pub snd_pcm_get_chmap: ma_proc, ++ pub snd_pcm_state: ma_proc, ++ pub snd_pcm_prepare: ma_proc, ++ pub snd_pcm_start: ma_proc, ++ pub snd_pcm_drop: ma_proc, ++ pub snd_pcm_drain: ma_proc, ++ pub snd_pcm_reset: ma_proc, ++ pub snd_device_name_hint: ma_proc, ++ pub snd_device_name_get_hint: ma_proc, ++ pub snd_card_get_index: ma_proc, ++ pub snd_device_name_free_hint: ma_proc, ++ pub snd_pcm_mmap_begin: ma_proc, ++ pub snd_pcm_mmap_commit: ma_proc, ++ pub snd_pcm_recover: ma_proc, ++ pub snd_pcm_readi: ma_proc, ++ pub snd_pcm_writei: ma_proc, ++ pub snd_pcm_avail: ma_proc, ++ pub snd_pcm_avail_update: ma_proc, ++ pub snd_pcm_wait: ma_proc, ++ pub snd_pcm_nonblock: ma_proc, ++ pub snd_pcm_info: ma_proc, ++ pub snd_pcm_info_sizeof: ma_proc, ++ pub snd_pcm_info_get_name: ma_proc, ++ pub snd_pcm_poll_descriptors: ma_proc, ++ pub snd_pcm_poll_descriptors_count: ma_proc, ++ pub snd_pcm_poll_descriptors_revents: ma_proc, ++ pub snd_config_update_free_global: ma_proc, ++ pub internalDeviceEnumLock: ma_mutex, ++ pub useVerboseDeviceEnumeration: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 592usize]; ++ ["Alignment of ma_context__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::asoundSO"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, asoundSO) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_open"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_open) - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_close"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_close) - 16usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_sizeof"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_sizeof ++ ) ++ - 24usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_any"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_any ++ ) - 32usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_format"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_format ++ ) ++ - 40usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_format_first"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_format_first ++ ) - 48usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_format_mask"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_format_mask ++ ) - 56usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_channels"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_channels ++ ) ++ - 64usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_channels_near", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_channels_near ++ ) - 72usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_channels_minmax", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_channels_minmax ++ ) - 80usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_rate_resample", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_rate_resample ++ ) - 88usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_rate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_rate ++ ) ++ - 96usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_rate_near"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_rate_near ++ ) ++ - 104usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_rate_minmax"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_rate_minmax ++ ) - 112usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_buffer_size_near", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_buffer_size_near ++ ) - 120usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_periods_near"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_periods_near ++ ) - 128usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_access"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_access ++ ) ++ - 136usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_format"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_format ++ ) ++ - 144usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_channels"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_channels ++ ) ++ - 152usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_channels_min"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_channels_min ++ ) - 160usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_channels_max"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_channels_max ++ ) - 168usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_rate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_rate ++ ) ++ - 176usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_rate_min"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_rate_min ++ ) ++ - 184usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_rate_max"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_rate_max ++ ) ++ - 192usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_buffer_size"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_buffer_size ++ ) - 200usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_periods"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_periods ++ ) ++ - 208usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_access"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_access ++ ) ++ - 216usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_test_format"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_test_format ++ ) ++ - 224usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_test_channels"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_test_channels ++ ) ++ - 232usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_test_rate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_test_rate ++ ) ++ - 240usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params ++ ) - 248usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_sizeof"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_sizeof ++ ) ++ - 256usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_current"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_current ++ ) ++ - 264usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_get_boundary"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_get_boundary ++ ) ++ - 272usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_set_avail_min"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_set_avail_min ++ ) ++ - 280usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_set_start_threshold", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_set_start_threshold ++ ) - 288usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_set_stop_threshold", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_set_stop_threshold ++ ) - 296usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params ++ ) - 304usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_format_mask_sizeof"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_format_mask_sizeof ++ ) ++ - 312usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_format_mask_test"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_format_mask_test ++ ) ++ - 320usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_get_chmap"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_get_chmap ++ ) - 328usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_state"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_state) - 336usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_prepare"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_prepare ++ ) - 344usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_start"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_start) - 352usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_drop"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_drop) - 360usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_drain"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_drain) - 368usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_reset"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_reset) - 376usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_device_name_hint"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_device_name_hint ++ ) - 384usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_device_name_get_hint"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_device_name_get_hint ++ ) ++ - 392usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_card_get_index"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_card_get_index ++ ) - 400usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_device_name_free_hint"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_device_name_free_hint ++ ) ++ - 408usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_mmap_begin"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_mmap_begin ++ ) - 416usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_mmap_commit"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_mmap_commit ++ ) - 424usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_recover"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_recover ++ ) - 432usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_readi"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_readi) - 440usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_writei"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_writei ++ ) - 448usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_avail"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_avail) - 456usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_avail_update"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_avail_update ++ ) - 464usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_wait"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_wait) - 472usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_nonblock"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_nonblock ++ ) - 480usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_info"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_info) - 488usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_info_sizeof"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_info_sizeof ++ ) - 496usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_info_get_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_info_get_name ++ ) ++ - 504usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_poll_descriptors"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_poll_descriptors ++ ) ++ - 512usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_poll_descriptors_count"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_poll_descriptors_count ++ ) ++ - 520usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_poll_descriptors_revents"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_poll_descriptors_revents ++ ) ++ - 528usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_config_update_free_global"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_config_update_free_global ++ ) ++ - 536usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::internalDeviceEnumLock"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ internalDeviceEnumLock ++ ) ++ - 544usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::useVerboseDeviceEnumeration"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ useVerboseDeviceEnumeration ++ ) ++ - 584usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context__bindgen_ty_1__bindgen_ty_2 { ++ pub pulseSO: ma_handle, ++ pub pa_mainloop_new: ma_proc, ++ pub pa_mainloop_free: ma_proc, ++ pub pa_mainloop_quit: ma_proc, ++ pub pa_mainloop_get_api: ma_proc, ++ pub pa_mainloop_iterate: ma_proc, ++ pub pa_mainloop_wakeup: ma_proc, ++ pub pa_threaded_mainloop_new: ma_proc, ++ pub pa_threaded_mainloop_free: ma_proc, ++ pub pa_threaded_mainloop_start: ma_proc, ++ pub pa_threaded_mainloop_stop: ma_proc, ++ pub pa_threaded_mainloop_lock: ma_proc, ++ pub pa_threaded_mainloop_unlock: ma_proc, ++ pub pa_threaded_mainloop_wait: ma_proc, ++ pub pa_threaded_mainloop_signal: ma_proc, ++ pub pa_threaded_mainloop_accept: ma_proc, ++ pub pa_threaded_mainloop_get_retval: ma_proc, ++ pub pa_threaded_mainloop_get_api: ma_proc, ++ pub pa_threaded_mainloop_in_thread: ma_proc, ++ pub pa_threaded_mainloop_set_name: ma_proc, ++ pub pa_context_new: ma_proc, ++ pub pa_context_unref: ma_proc, ++ pub pa_context_connect: ma_proc, ++ pub pa_context_disconnect: ma_proc, ++ pub pa_context_set_state_callback: ma_proc, ++ pub pa_context_get_state: ma_proc, ++ pub pa_context_get_sink_info_list: ma_proc, ++ pub pa_context_get_source_info_list: ma_proc, ++ pub pa_context_get_sink_info_by_name: ma_proc, ++ pub pa_context_get_source_info_by_name: ma_proc, ++ pub pa_operation_unref: ma_proc, ++ pub pa_operation_get_state: ma_proc, ++ pub pa_channel_map_init_extend: ma_proc, ++ pub pa_channel_map_valid: ma_proc, ++ pub pa_channel_map_compatible: ma_proc, ++ pub pa_stream_new: ma_proc, ++ pub pa_stream_unref: ma_proc, ++ pub pa_stream_connect_playback: ma_proc, ++ pub pa_stream_connect_record: ma_proc, ++ pub pa_stream_disconnect: ma_proc, ++ pub pa_stream_get_state: ma_proc, ++ pub pa_stream_get_sample_spec: ma_proc, ++ pub pa_stream_get_channel_map: ma_proc, ++ pub pa_stream_get_buffer_attr: ma_proc, ++ pub pa_stream_set_buffer_attr: ma_proc, ++ pub pa_stream_get_device_name: ma_proc, ++ pub pa_stream_set_write_callback: ma_proc, ++ pub pa_stream_set_read_callback: ma_proc, ++ pub pa_stream_set_suspended_callback: ma_proc, ++ pub pa_stream_set_moved_callback: ma_proc, ++ pub pa_stream_is_suspended: ma_proc, ++ pub pa_stream_flush: ma_proc, ++ pub pa_stream_drain: ma_proc, ++ pub pa_stream_is_corked: ma_proc, ++ pub pa_stream_cork: ma_proc, ++ pub pa_stream_trigger: ma_proc, ++ pub pa_stream_begin_write: ma_proc, ++ pub pa_stream_write: ma_proc, ++ pub pa_stream_peek: ma_proc, ++ pub pa_stream_drop: ma_proc, ++ pub pa_stream_writable_size: ma_proc, ++ pub pa_stream_readable_size: ma_proc, ++ pub pMainLoop: ma_ptr, ++ pub pPulseContext: ma_ptr, ++ pub pApplicationName: *mut core::ffi::c_char, ++ pub pServerName: *mut core::ffi::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::size_of::() - 528usize]; ++ ["Alignment of ma_context__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pulseSO"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pulseSO) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_new"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pa_mainloop_new) - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_free"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_free ++ ) - 16usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_quit"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_quit ++ ) - 24usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_get_api"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_get_api ++ ) - 32usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_iterate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_iterate ++ ) - 40usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_wakeup"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_wakeup ++ ) - 48usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_new"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_new ++ ) ++ - 56usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_free"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_free ++ ) ++ - 64usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_start"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_start ++ ) ++ - 72usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_stop"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_stop ++ ) ++ - 80usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_lock"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_lock ++ ) ++ - 88usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_unlock"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_unlock ++ ) ++ - 96usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_wait"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_wait ++ ) ++ - 104usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_signal"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_signal ++ ) ++ - 112usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_accept"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_accept ++ ) ++ - 120usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_get_retval"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_get_retval ++ ) ++ - 128usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_get_api"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_get_api ++ ) ++ - 136usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_in_thread"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_in_thread ++ ) ++ - 144usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_set_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_set_name ++ ) ++ - 152usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_new"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_new ++ ) - 160usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_unref"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_unref ++ ) - 168usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_connect"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_connect ++ ) - 176usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_disconnect"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_disconnect ++ ) ++ - 184usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_set_state_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_set_state_callback ++ ) ++ - 192usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_state"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_state ++ ) - 200usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_sink_info_list"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_sink_info_list ++ ) ++ - 208usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_source_info_list"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_source_info_list ++ ) ++ - 216usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_sink_info_by_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_sink_info_by_name ++ ) ++ - 224usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_source_info_by_name"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_source_info_by_name ++ ) - 232usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_operation_unref"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_operation_unref ++ ) - 240usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_operation_get_state"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_operation_get_state ++ ) ++ - 248usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_channel_map_init_extend"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_channel_map_init_extend ++ ) ++ - 256usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_channel_map_valid"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_channel_map_valid ++ ) - 264usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_channel_map_compatible"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_channel_map_compatible ++ ) ++ - 272usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_new"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pa_stream_new) - 280usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_unref"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_unref ++ ) - 288usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_connect_playback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_connect_playback ++ ) ++ - 296usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_connect_record"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_connect_record ++ ) ++ - 304usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_disconnect"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_disconnect ++ ) - 312usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_state"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_state ++ ) - 320usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_sample_spec"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_sample_spec ++ ) ++ - 328usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_channel_map"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_channel_map ++ ) ++ - 336usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_buffer_attr"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_buffer_attr ++ ) ++ - 344usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_buffer_attr"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_buffer_attr ++ ) ++ - 352usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_device_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_device_name ++ ) ++ - 360usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_write_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_write_callback ++ ) ++ - 368usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_read_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_read_callback ++ ) ++ - 376usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_suspended_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_suspended_callback ++ ) ++ - 384usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_moved_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_moved_callback ++ ) ++ - 392usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_is_suspended"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_is_suspended ++ ) ++ - 400usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_flush"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_flush ++ ) - 408usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_drain"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_drain ++ ) - 416usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_is_corked"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_is_corked ++ ) - 424usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_cork"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_cork ++ ) - 432usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_trigger"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_trigger ++ ) - 440usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_begin_write"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_begin_write ++ ) ++ - 448usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_write"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_write ++ ) - 456usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_peek"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_peek ++ ) - 464usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_drop"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_drop ++ ) - 472usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_writable_size"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_writable_size ++ ) ++ - 480usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_readable_size"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_readable_size ++ ) ++ - 488usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pMainLoop"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pMainLoop) - 496usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pPulseContext"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pPulseContext) - 504usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pApplicationName"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pApplicationName ++ ) - 512usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pServerName"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pServerName) - 520usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context__bindgen_ty_1__bindgen_ty_3 { ++ pub jackSO: ma_handle, ++ pub jack_client_open: ma_proc, ++ pub jack_client_close: ma_proc, ++ pub jack_client_name_size: ma_proc, ++ pub jack_set_process_callback: ma_proc, ++ pub jack_set_buffer_size_callback: ma_proc, ++ pub jack_on_shutdown: ma_proc, ++ pub jack_get_sample_rate: ma_proc, ++ pub jack_get_buffer_size: ma_proc, ++ pub jack_get_ports: ma_proc, ++ pub jack_activate: ma_proc, ++ pub jack_deactivate: ma_proc, ++ pub jack_connect: ma_proc, ++ pub jack_port_register: ma_proc, ++ pub jack_port_name: ma_proc, ++ pub jack_port_get_buffer: ma_proc, ++ pub jack_free: ma_proc, ++ pub pClientName: *mut core::ffi::c_char, ++ pub tryStartServer: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_context__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jackSO"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jackSO) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_client_open"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_client_open ++ ) - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_client_close"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_client_close ++ ) - 16usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_client_name_size"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_client_name_size ++ ) - 24usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_set_process_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_set_process_callback ++ ) ++ - 32usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_set_buffer_size_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_set_buffer_size_callback ++ ) ++ - 40usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_on_shutdown"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_on_shutdown ++ ) - 48usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_get_sample_rate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_get_sample_rate ++ ) - 56usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_get_buffer_size"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_get_buffer_size ++ ) - 64usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_get_ports"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jack_get_ports) - 72usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_activate"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jack_activate) - 80usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_deactivate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_deactivate ++ ) - 88usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_connect"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jack_connect) - 96usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_port_register"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_port_register ++ ) - 104usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_port_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_port_name ++ ) - 112usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_port_get_buffer"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_port_get_buffer ++ ) - 120usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_free"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jack_free) - 128usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::pClientName"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, pClientName) - 136usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::tryStartServer"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ tryStartServer ++ ) - 144usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context__bindgen_ty_1__bindgen_ty_4 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1__bindgen_ty_4"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context__bindgen_ty_1__bindgen_ty_4"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_4::_unused"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_4, _unused) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1"] ++ [::core::mem::size_of::() - 592usize]; ++ ["Alignment of ma_context__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1::alsa"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1, alsa) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1::pulse"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1, pulse) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1::jack"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1, jack) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1::null_backend"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1, null_backend) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_context__bindgen_ty_2 { ++ pub posix: ma_context__bindgen_ty_2__bindgen_ty_1, ++ pub _unused: core::ffi::c_int, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context__bindgen_ty_2__bindgen_ty_1 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context__bindgen_ty_2__bindgen_ty_1::_unused"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_2__bindgen_ty_1, _unused) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_2"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context__bindgen_ty_2"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context__bindgen_ty_2::posix"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_2, posix) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_2::_unused"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_2, _unused) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context"][::core::mem::size_of::() - 1024usize]; ++ ["Alignment of ma_context"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context::callbacks"] ++ [::core::mem::offset_of!(ma_context, callbacks) - 0usize]; ++ ["Offset of field: ma_context::backend"] ++ [::core::mem::offset_of!(ma_context, backend) - 104usize]; ++ ["Offset of field: ma_context::pLog"][::core::mem::offset_of!(ma_context, pLog) - 112usize]; ++ ["Offset of field: ma_context::log"][::core::mem::offset_of!(ma_context, log) - 120usize]; ++ ["Offset of field: ma_context::threadPriority"] ++ [::core::mem::offset_of!(ma_context, threadPriority) - 264usize]; ++ ["Offset of field: ma_context::threadStackSize"] ++ [::core::mem::offset_of!(ma_context, threadStackSize) - 272usize]; ++ ["Offset of field: ma_context::pUserData"] ++ [::core::mem::offset_of!(ma_context, pUserData) - 280usize]; ++ ["Offset of field: ma_context::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_context, allocationCallbacks) - 288usize]; ++ ["Offset of field: ma_context::deviceEnumLock"] ++ [::core::mem::offset_of!(ma_context, deviceEnumLock) - 320usize]; ++ ["Offset of field: ma_context::deviceInfoLock"] ++ [::core::mem::offset_of!(ma_context, deviceInfoLock) - 360usize]; ++ ["Offset of field: ma_context::deviceInfoCapacity"] ++ [::core::mem::offset_of!(ma_context, deviceInfoCapacity) - 400usize]; ++ ["Offset of field: ma_context::playbackDeviceInfoCount"] ++ [::core::mem::offset_of!(ma_context, playbackDeviceInfoCount) - 404usize]; ++ ["Offset of field: ma_context::captureDeviceInfoCount"] ++ [::core::mem::offset_of!(ma_context, captureDeviceInfoCount) - 408usize]; ++ ["Offset of field: ma_context::pDeviceInfos"] ++ [::core::mem::offset_of!(ma_context, pDeviceInfos) - 416usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device { ++ pub pContext: *mut ma_context, ++ pub type_: ma_device_type, ++ pub sampleRate: ma_uint32, ++ pub state: ma_atomic_device_state, ++ pub onData: ma_device_data_proc, ++ pub onNotification: ma_device_notification_proc, ++ pub onStop: ma_stop_proc, ++ pub pUserData: *mut core::ffi::c_void, ++ pub startStopLock: ma_mutex, ++ pub wakeupEvent: ma_event, ++ pub startEvent: ma_event, ++ pub stopEvent: ma_event, ++ pub thread: ma_thread, ++ pub workResult: ma_result, ++ pub isOwnerOfContext: ma_bool8, ++ pub noPreSilencedOutputBuffer: ma_bool8, ++ pub noClip: ma_bool8, ++ pub noDisableDenormals: ma_bool8, ++ pub noFixedSizedCallback: ma_bool8, ++ pub masterVolumeFactor: ma_atomic_float, ++ pub duplexRB: ma_duplex_rb, ++ pub resampling: ma_device__bindgen_ty_1, ++ pub playback: ma_device__bindgen_ty_2, ++ pub capture: ma_device__bindgen_ty_3, ++ pub __bindgen_anon_1: ma_device__bindgen_ty_4, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_1 { ++ pub algorithm: ma_resample_algorithm, ++ pub pBackendVTable: *mut ma_resampling_backend_vtable, ++ pub pBackendUserData: *mut core::ffi::c_void, ++ pub linear: ma_device__bindgen_ty_1__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_1__bindgen_ty_1 { ++ pub lpfOrder: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device__bindgen_ty_1__bindgen_ty_1::lpfOrder"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1__bindgen_ty_1, lpfOrder) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_1"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_device__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_1::algorithm"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1, algorithm) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_1::pBackendVTable"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1, pBackendVTable) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_1::pBackendUserData"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1, pBackendUserData) - 16usize]; ++ ["Offset of field: ma_device__bindgen_ty_1::linear"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1, linear) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device__bindgen_ty_2 { ++ pub pID: *mut ma_device_id, ++ pub id: ma_device_id, ++ pub name: [core::ffi::c_char; 256usize], ++ pub shareMode: ma_share_mode, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub channelMap: [ma_channel; 254usize], ++ pub internalFormat: ma_format, ++ pub internalChannels: ma_uint32, ++ pub internalSampleRate: ma_uint32, ++ pub internalChannelMap: [ma_channel; 254usize], ++ pub internalPeriodSizeInFrames: ma_uint32, ++ pub internalPeriods: ma_uint32, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub converter: ma_data_converter, ++ pub pIntermediaryBuffer: *mut core::ffi::c_void, ++ pub intermediaryBufferCap: ma_uint32, ++ pub intermediaryBufferLen: ma_uint32, ++ pub pInputCache: *mut core::ffi::c_void, ++ pub inputCacheCap: ma_uint64, ++ pub inputCacheConsumed: ma_uint64, ++ pub inputCacheRemaining: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_2"] ++ [::core::mem::size_of::() - 1432usize]; ++ ["Alignment of ma_device__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::pID"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, pID) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::id"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, id) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::name"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, name) - 264usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::shareMode"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, shareMode) - 520usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::format"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, format) - 524usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::channels"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, channels) - 528usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::channelMap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, channelMap) - 532usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalFormat"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalFormat) - 788usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalChannels"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalChannels) - 792usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalSampleRate"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalSampleRate) - 796usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalChannelMap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalChannelMap) - 800usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalPeriodSizeInFrames"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalPeriodSizeInFrames) - 1056usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalPeriods"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalPeriods) - 1060usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::channelMixMode"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, channelMixMode) - 1064usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_2, ++ calculateLFEFromSpatialChannels ++ ) - 1068usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::converter"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, converter) - 1072usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::pIntermediaryBuffer"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, pIntermediaryBuffer) - 1384usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::intermediaryBufferCap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, intermediaryBufferCap) - 1392usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::intermediaryBufferLen"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, intermediaryBufferLen) - 1396usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::pInputCache"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, pInputCache) - 1400usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::inputCacheCap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, inputCacheCap) - 1408usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::inputCacheConsumed"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, inputCacheConsumed) - 1416usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::inputCacheRemaining"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, inputCacheRemaining) - 1424usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device__bindgen_ty_3 { ++ pub pID: *mut ma_device_id, ++ pub id: ma_device_id, ++ pub name: [core::ffi::c_char; 256usize], ++ pub shareMode: ma_share_mode, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub channelMap: [ma_channel; 254usize], ++ pub internalFormat: ma_format, ++ pub internalChannels: ma_uint32, ++ pub internalSampleRate: ma_uint32, ++ pub internalChannelMap: [ma_channel; 254usize], ++ pub internalPeriodSizeInFrames: ma_uint32, ++ pub internalPeriods: ma_uint32, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub converter: ma_data_converter, ++ pub pIntermediaryBuffer: *mut core::ffi::c_void, ++ pub intermediaryBufferCap: ma_uint32, ++ pub intermediaryBufferLen: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_3"] ++ [::core::mem::size_of::() - 1400usize]; ++ ["Alignment of ma_device__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::pID"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, pID) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::id"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, id) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::name"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, name) - 264usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::shareMode"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, shareMode) - 520usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::format"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, format) - 524usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::channels"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, channels) - 528usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::channelMap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, channelMap) - 532usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalFormat"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalFormat) - 788usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalChannels"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalChannels) - 792usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalSampleRate"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalSampleRate) - 796usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalChannelMap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalChannelMap) - 800usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalPeriodSizeInFrames"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalPeriodSizeInFrames) - 1056usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalPeriods"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalPeriods) - 1060usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::channelMixMode"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, channelMixMode) - 1064usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_3, ++ calculateLFEFromSpatialChannels ++ ) - 1068usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::converter"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, converter) - 1072usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::pIntermediaryBuffer"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, pIntermediaryBuffer) - 1384usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::intermediaryBufferCap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, intermediaryBufferCap) - 1392usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::intermediaryBufferLen"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, intermediaryBufferLen) - 1396usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_device__bindgen_ty_4 { ++ pub alsa: ma_device__bindgen_ty_4__bindgen_ty_1, ++ pub pulse: ma_device__bindgen_ty_4__bindgen_ty_2, ++ pub jack: ma_device__bindgen_ty_4__bindgen_ty_3, ++ pub null_device: ma_device__bindgen_ty_4__bindgen_ty_4, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_4__bindgen_ty_1 { ++ pub pPCMPlayback: ma_ptr, ++ pub pPCMCapture: ma_ptr, ++ pub pPollDescriptorsPlayback: *mut core::ffi::c_void, ++ pub pPollDescriptorsCapture: *mut core::ffi::c_void, ++ pub pollDescriptorCountPlayback: core::ffi::c_int, ++ pub pollDescriptorCountCapture: core::ffi::c_int, ++ pub wakeupfdPlayback: core::ffi::c_int, ++ pub wakeupfdCapture: core::ffi::c_int, ++ pub isUsingMMapPlayback: ma_bool8, ++ pub isUsingMMapCapture: ma_bool8, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4__bindgen_ty_1"] ++ [::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_device__bindgen_ty_4__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pPCMPlayback"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_1, pPCMPlayback) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pPCMCapture"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_1, pPCMCapture) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pPollDescriptorsPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ pPollDescriptorsPlayback ++ ) ++ - 16usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pPollDescriptorsCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ pPollDescriptorsCapture ++ ) ++ - 24usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pollDescriptorCountPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ pollDescriptorCountPlayback ++ ) ++ - 32usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pollDescriptorCountCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ pollDescriptorCountCapture ++ ) ++ - 36usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::wakeupfdPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ wakeupfdPlayback ++ ) - 40usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::wakeupfdCapture"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_1, wakeupfdCapture) - 44usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::isUsingMMapPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ isUsingMMapPlayback ++ ) - 48usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::isUsingMMapCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ isUsingMMapCapture ++ ) - 49usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_4__bindgen_ty_2 { ++ pub pMainLoop: ma_ptr, ++ pub pPulseContext: ma_ptr, ++ pub pStreamPlayback: ma_ptr, ++ pub pStreamCapture: ma_ptr, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4__bindgen_ty_2"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_device__bindgen_ty_4__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_2::pMainLoop"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_2, pMainLoop) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_2::pPulseContext"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_2, pPulseContext) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_2::pStreamPlayback"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_2, pStreamPlayback) - 16usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_2::pStreamCapture"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_2, pStreamCapture) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_4__bindgen_ty_3 { ++ pub pClient: ma_ptr, ++ pub ppPortsPlayback: *mut ma_ptr, ++ pub ppPortsCapture: *mut ma_ptr, ++ pub pIntermediaryBufferPlayback: *mut f32, ++ pub pIntermediaryBufferCapture: *mut f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4__bindgen_ty_3"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_device__bindgen_ty_4__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::pClient"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_3, pClient) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::ppPortsPlayback"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_3, ppPortsPlayback) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::ppPortsCapture"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_3, ppPortsCapture) - 16usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::pIntermediaryBufferPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_3, ++ pIntermediaryBufferPlayback ++ ) ++ - 24usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::pIntermediaryBufferCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_3, ++ pIntermediaryBufferCapture ++ ) ++ - 32usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device__bindgen_ty_4__bindgen_ty_4 { ++ pub deviceThread: ma_thread, ++ pub operationEvent: ma_event, ++ pub operationCompletionEvent: ma_event, ++ pub operationSemaphore: ma_semaphore, ++ pub operation: ma_uint32, ++ pub operationResult: ma_result, ++ pub timer: ma_timer, ++ pub priorRunTime: f64, ++ pub currentPeriodFramesRemainingPlayback: ma_uint32, ++ pub currentPeriodFramesRemainingCapture: ma_uint32, ++ pub lastProcessedFramePlayback: ma_uint64, ++ pub lastProcessedFrameCapture: ma_uint64, ++ pub isStarted: ma_atomic_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4__bindgen_ty_4"] ++ [::core::mem::size_of::() - 352usize]; ++ ["Alignment of ma_device__bindgen_ty_4__bindgen_ty_4"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::deviceThread"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, deviceThread) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operationEvent"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, operationEvent) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operationCompletionEvent"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ operationCompletionEvent ++ ) ++ - 104usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operationSemaphore"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ operationSemaphore ++ ) - 200usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operation"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, operation) - 296usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operationResult"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ operationResult ++ ) - 300usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::timer"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, timer) - 304usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::priorRunTime"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, priorRunTime) - 312usize]; ++ [ ++ "Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::currentPeriodFramesRemainingPlayback", ++ ][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ currentPeriodFramesRemainingPlayback ++ ) - 320usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::currentPeriodFramesRemainingCapture"] ++ [::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ currentPeriodFramesRemainingCapture ++ ) - 324usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::lastProcessedFramePlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ lastProcessedFramePlayback ++ ) ++ - 328usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::lastProcessedFrameCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ lastProcessedFrameCapture ++ ) ++ - 336usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::isStarted"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, isStarted) - 344usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4"] ++ [::core::mem::size_of::() - 352usize]; ++ ["Alignment of ma_device__bindgen_ty_4"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4::alsa"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4, alsa) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4::pulse"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4, pulse) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4::jack"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4, jack) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4::null_device"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4, null_device) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device"][::core::mem::size_of::() - 3776usize]; ++ ["Alignment of ma_device"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device::pContext"][::core::mem::offset_of!(ma_device, pContext) - 0usize]; ++ ["Offset of field: ma_device::type_"][::core::mem::offset_of!(ma_device, type_) - 8usize]; ++ ["Offset of field: ma_device::sampleRate"] ++ [::core::mem::offset_of!(ma_device, sampleRate) - 12usize]; ++ ["Offset of field: ma_device::state"][::core::mem::offset_of!(ma_device, state) - 16usize]; ++ ["Offset of field: ma_device::onData"][::core::mem::offset_of!(ma_device, onData) - 24usize]; ++ ["Offset of field: ma_device::onNotification"] ++ [::core::mem::offset_of!(ma_device, onNotification) - 32usize]; ++ ["Offset of field: ma_device::onStop"][::core::mem::offset_of!(ma_device, onStop) - 40usize]; ++ ["Offset of field: ma_device::pUserData"] ++ [::core::mem::offset_of!(ma_device, pUserData) - 48usize]; ++ ["Offset of field: ma_device::startStopLock"] ++ [::core::mem::offset_of!(ma_device, startStopLock) - 56usize]; ++ ["Offset of field: ma_device::wakeupEvent"] ++ [::core::mem::offset_of!(ma_device, wakeupEvent) - 96usize]; ++ ["Offset of field: ma_device::startEvent"] ++ [::core::mem::offset_of!(ma_device, startEvent) - 192usize]; ++ ["Offset of field: ma_device::stopEvent"] ++ [::core::mem::offset_of!(ma_device, stopEvent) - 288usize]; ++ ["Offset of field: ma_device::thread"][::core::mem::offset_of!(ma_device, thread) - 384usize]; ++ ["Offset of field: ma_device::workResult"] ++ [::core::mem::offset_of!(ma_device, workResult) - 392usize]; ++ ["Offset of field: ma_device::isOwnerOfContext"] ++ [::core::mem::offset_of!(ma_device, isOwnerOfContext) - 396usize]; ++ ["Offset of field: ma_device::noPreSilencedOutputBuffer"] ++ [::core::mem::offset_of!(ma_device, noPreSilencedOutputBuffer) - 397usize]; ++ ["Offset of field: ma_device::noClip"][::core::mem::offset_of!(ma_device, noClip) - 398usize]; ++ ["Offset of field: ma_device::noDisableDenormals"] ++ [::core::mem::offset_of!(ma_device, noDisableDenormals) - 399usize]; ++ ["Offset of field: ma_device::noFixedSizedCallback"] ++ [::core::mem::offset_of!(ma_device, noFixedSizedCallback) - 400usize]; ++ ["Offset of field: ma_device::masterVolumeFactor"] ++ [::core::mem::offset_of!(ma_device, masterVolumeFactor) - 404usize]; ++ ["Offset of field: ma_device::duplexRB"] ++ [::core::mem::offset_of!(ma_device, duplexRB) - 408usize]; ++ ["Offset of field: ma_device::resampling"] ++ [::core::mem::offset_of!(ma_device, resampling) - 560usize]; ++ ["Offset of field: ma_device::playback"] ++ [::core::mem::offset_of!(ma_device, playback) - 592usize]; ++ ["Offset of field: ma_device::capture"] ++ [::core::mem::offset_of!(ma_device, capture) - 2024usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_context_config_init() -> ma_context_config; ++} ++unsafe extern "C" { ++ pub fn ma_context_init( ++ backends: *const ma_backend, ++ backendCount: ma_uint32, ++ pConfig: *const ma_context_config, ++ pContext: *mut ma_context, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_uninit(pContext: *mut ma_context) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_sizeof() -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_context_get_log(pContext: *mut ma_context) -> *mut ma_log; ++} ++unsafe extern "C" { ++ pub fn ma_context_enumerate_devices( ++ pContext: *mut ma_context, ++ callback: ma_enum_devices_callback_proc, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_get_devices( ++ pContext: *mut ma_context, ++ ppPlaybackDeviceInfos: *mut *mut ma_device_info, ++ pPlaybackDeviceCount: *mut ma_uint32, ++ ppCaptureDeviceInfos: *mut *mut ma_device_info, ++ pCaptureDeviceCount: *mut ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_get_device_info( ++ pContext: *mut ma_context, ++ deviceType: ma_device_type, ++ pDeviceID: *const ma_device_id, ++ pDeviceInfo: *mut ma_device_info, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_is_loopback_supported(pContext: *mut ma_context) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_device_config_init(deviceType: ma_device_type) -> ma_device_config; ++} ++unsafe extern "C" { ++ pub fn ma_device_init( ++ pContext: *mut ma_context, ++ pConfig: *const ma_device_config, ++ pDevice: *mut ma_device, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_init_ex( ++ backends: *const ma_backend, ++ backendCount: ma_uint32, ++ pContextConfig: *const ma_context_config, ++ pConfig: *const ma_device_config, ++ pDevice: *mut ma_device, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_uninit(pDevice: *mut ma_device); ++} ++unsafe extern "C" { ++ pub fn ma_device_get_context(pDevice: *mut ma_device) -> *mut ma_context; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_log(pDevice: *mut ma_device) -> *mut ma_log; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_info( ++ pDevice: *mut ma_device, ++ type_: ma_device_type, ++ pDeviceInfo: *mut ma_device_info, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_name( ++ pDevice: *mut ma_device, ++ type_: ma_device_type, ++ pName: *mut core::ffi::c_char, ++ nameCap: usize, ++ pLengthNotIncludingNullTerminator: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_start(pDevice: *mut ma_device) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_stop(pDevice: *mut ma_device) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_is_started(pDevice: *const ma_device) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_state(pDevice: *const ma_device) -> ma_device_state; ++} ++unsafe extern "C" { ++ pub fn ma_device_post_init( ++ pDevice: *mut ma_device, ++ deviceType: ma_device_type, ++ pPlaybackDescriptor: *const ma_device_descriptor, ++ pCaptureDescriptor: *const ma_device_descriptor, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_set_master_volume(pDevice: *mut ma_device, volume: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_master_volume(pDevice: *mut ma_device, pVolume: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_set_master_volume_db(pDevice: *mut ma_device, gainDB: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_master_volume_db(pDevice: *mut ma_device, pGainDB: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_handle_backend_data_callback( ++ pDevice: *mut ma_device, ++ pOutput: *mut core::ffi::c_void, ++ pInput: *const core::ffi::c_void, ++ frameCount: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_calculate_buffer_size_in_frames_from_descriptor( ++ pDescriptor: *const ma_device_descriptor, ++ nativeSampleRate: ma_uint32, ++ performanceProfile: ma_performance_profile, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_get_backend_name(backend: ma_backend) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ma_get_backend_from_name( ++ pBackendName: *const core::ffi::c_char, ++ pBackend: *mut ma_backend, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_is_backend_enabled(backend: ma_backend) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_get_enabled_backends( ++ pBackends: *mut ma_backend, ++ backendCap: usize, ++ pBackendCount: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_is_loopback_supported(backend: ma_backend) -> ma_bool32; ++} ++unsafe extern "C" { ++ #[doc = "Utilities"] ++ pub fn ma_calculate_buffer_size_in_milliseconds_from_frames( ++ bufferSizeInFrames: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_calculate_buffer_size_in_frames_from_milliseconds( ++ bufferSizeInMilliseconds: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_copy_pcm_frames( ++ dst: *mut core::ffi::c_void, ++ src: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_silence_pcm_frames( ++ p: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_offset_pcm_frames_ptr( ++ p: *mut core::ffi::c_void, ++ offsetInFrames: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_offset_pcm_frames_const_ptr( ++ p: *const core::ffi::c_void, ++ offsetInFrames: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ) -> *const core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_u8(pDst: *mut ma_uint8, pSrc: *const ma_int16, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_s16(pDst: *mut ma_int16, pSrc: *const ma_int32, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_s24(pDst: *mut ma_uint8, pSrc: *const ma_int64, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_s32(pDst: *mut ma_int32, pSrc: *const ma_int64, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_f32(pDst: *mut f32, pSrc: *const f32, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_pcm_frames( ++ pDst: *mut core::ffi::c_void, ++ pSrc: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_u8( ++ pSamplesOut: *mut ma_uint8, ++ pSamplesIn: *const ma_uint8, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_s16( ++ pSamplesOut: *mut ma_int16, ++ pSamplesIn: *const ma_int16, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_s24( ++ pSamplesOut: *mut core::ffi::c_void, ++ pSamplesIn: *const core::ffi::c_void, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_s32( ++ pSamplesOut: *mut ma_int32, ++ pSamplesIn: *const ma_int32, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_f32( ++ pSamplesOut: *mut f32, ++ pSamplesIn: *const f32, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_u8(pSamples: *mut ma_uint8, sampleCount: ma_uint64, factor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_s16(pSamples: *mut ma_int16, sampleCount: ma_uint64, factor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_s24( ++ pSamples: *mut core::ffi::c_void, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_s32(pSamples: *mut ma_int32, sampleCount: ma_uint64, factor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_f32(pSamples: *mut f32, sampleCount: ma_uint64, factor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_u8( ++ pFramesOut: *mut ma_uint8, ++ pFramesIn: *const ma_uint8, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_s16( ++ pFramesOut: *mut ma_int16, ++ pFramesIn: *const ma_int16, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_s24( ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_s32( ++ pFramesOut: *mut ma_int32, ++ pFramesIn: *const ma_int32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_f32( ++ pFramesOut: *mut f32, ++ pFramesIn: *const f32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames( ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_u8( ++ pFrames: *mut ma_uint8, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_s16( ++ pFrames: *mut ma_int16, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_s24( ++ pFrames: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_s32( ++ pFrames: *mut ma_int32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_f32( ++ pFrames: *mut f32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames( ++ pFrames: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_per_channel_f32( ++ pFramesOut: *mut f32, ++ pFramesIn: *const f32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ pChannelGains: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_u8( ++ pDst: *mut ma_uint8, ++ pSrc: *const ma_int16, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_s16( ++ pDst: *mut ma_int16, ++ pSrc: *const ma_int32, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_s24( ++ pDst: *mut ma_uint8, ++ pSrc: *const ma_int64, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_s32( ++ pDst: *mut ma_int32, ++ pSrc: *const ma_int64, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_f32( ++ pDst: *mut f32, ++ pSrc: *const f32, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_pcm_frames( ++ pDst: *mut core::ffi::c_void, ++ pSrc: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_volume_linear_to_db(factor: f32) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_volume_db_to_linear(gain: f32) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_mix_pcm_frames_f32( ++ pDst: *mut f32, ++ pSrc: *const f32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ volume: f32, ++ ) -> ma_result; ++} ++#[doc = "VFS\n===\n\nThe VFS object (virtual file system) is what's used to customize file access. This is useful in cases where stdio FILE* based APIs may not be entirely\nappropriate for a given situation."] ++pub type ma_vfs = core::ffi::c_void; ++pub type ma_vfs_file = ma_handle; ++pub const ma_open_mode_flags_MA_OPEN_MODE_READ: ma_open_mode_flags = 1; ++pub const ma_open_mode_flags_MA_OPEN_MODE_WRITE: ma_open_mode_flags = 2; ++pub type ma_open_mode_flags = core::ffi::c_uint; ++pub const ma_seek_origin_ma_seek_origin_start: ma_seek_origin = 0; ++pub const ma_seek_origin_ma_seek_origin_current: ma_seek_origin = 1; ++pub const ma_seek_origin_ma_seek_origin_end: ma_seek_origin = 2; ++pub type ma_seek_origin = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_file_info { ++ pub sizeInBytes: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_file_info"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_file_info"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_file_info::sizeInBytes"] ++ [::core::mem::offset_of!(ma_file_info, sizeInBytes) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_vfs_callbacks { ++ pub onOpen: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ openMode: ma_uint32, ++ pFile: *mut ma_vfs_file, ++ ) -> ma_result, ++ >, ++ pub onOpenW: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const wchar_t, ++ openMode: ma_uint32, ++ pFile: *mut ma_vfs_file, ++ ) -> ma_result, ++ >, ++ pub onClose: ::core::option::Option< ++ unsafe extern "C" fn(pVFS: *mut ma_vfs, file: ma_vfs_file) -> ma_result, ++ >, ++ pub onRead: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pDst: *mut core::ffi::c_void, ++ sizeInBytes: usize, ++ pBytesRead: *mut usize, ++ ) -> ma_result, ++ >, ++ pub onWrite: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pSrc: *const core::ffi::c_void, ++ sizeInBytes: usize, ++ pBytesWritten: *mut usize, ++ ) -> ma_result, ++ >, ++ pub onSeek: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ offset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result, ++ >, ++ pub onTell: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pCursor: *mut ma_int64, ++ ) -> ma_result, ++ >, ++ pub onInfo: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pInfo: *mut ma_file_info, ++ ) -> ma_result, ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_vfs_callbacks"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_vfs_callbacks"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_vfs_callbacks::onOpen"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onOpen) - 0usize]; ++ ["Offset of field: ma_vfs_callbacks::onOpenW"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onOpenW) - 8usize]; ++ ["Offset of field: ma_vfs_callbacks::onClose"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onClose) - 16usize]; ++ ["Offset of field: ma_vfs_callbacks::onRead"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onRead) - 24usize]; ++ ["Offset of field: ma_vfs_callbacks::onWrite"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onWrite) - 32usize]; ++ ["Offset of field: ma_vfs_callbacks::onSeek"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onSeek) - 40usize]; ++ ["Offset of field: ma_vfs_callbacks::onTell"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onTell) - 48usize]; ++ ["Offset of field: ma_vfs_callbacks::onInfo"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onInfo) - 56usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_vfs_open( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ openMode: ma_uint32, ++ pFile: *mut ma_vfs_file, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_open_w( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const wchar_t, ++ openMode: ma_uint32, ++ pFile: *mut ma_vfs_file, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_close(pVFS: *mut ma_vfs, file: ma_vfs_file) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_read( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pDst: *mut core::ffi::c_void, ++ sizeInBytes: usize, ++ pBytesRead: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_write( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pSrc: *const core::ffi::c_void, ++ sizeInBytes: usize, ++ pBytesWritten: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_seek( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ offset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_tell(pVFS: *mut ma_vfs, file: ma_vfs_file, pCursor: *mut ma_int64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_info(pVFS: *mut ma_vfs, file: ma_vfs_file, pInfo: *mut ma_file_info) ++ -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_open_and_read_file( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ ppData: *mut *mut core::ffi::c_void, ++ pSize: *mut usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_default_vfs { ++ pub cb: ma_vfs_callbacks, ++ pub allocationCallbacks: ma_allocation_callbacks, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_default_vfs"][::core::mem::size_of::() - 96usize]; ++ ["Alignment of ma_default_vfs"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_default_vfs::cb"][::core::mem::offset_of!(ma_default_vfs, cb) - 0usize]; ++ ["Offset of field: ma_default_vfs::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_default_vfs, allocationCallbacks) - 64usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_default_vfs_init( ++ pVFS: *mut ma_default_vfs, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_result; ++} ++pub type ma_read_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBufferOut: *mut core::ffi::c_void, ++ bytesToRead: usize, ++ pBytesRead: *mut usize, ++ ) -> ma_result, ++>; ++pub type ma_seek_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ offset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result, ++>; ++pub type ma_tell_proc = ::core::option::Option< ++ unsafe extern "C" fn(pUserData: *mut core::ffi::c_void, pCursor: *mut ma_int64) -> ma_result, ++>; ++pub const ma_encoding_format_ma_encoding_format_unknown: ma_encoding_format = 0; ++pub const ma_encoding_format_ma_encoding_format_wav: ma_encoding_format = 1; ++pub const ma_encoding_format_ma_encoding_format_flac: ma_encoding_format = 2; ++pub const ma_encoding_format_ma_encoding_format_mp3: ma_encoding_format = 3; ++pub const ma_encoding_format_ma_encoding_format_vorbis: ma_encoding_format = 4; ++pub type ma_encoding_format = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoding_backend_config { ++ pub preferredFormat: ma_format, ++ pub seekPointCount: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoding_backend_config"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_decoding_backend_config"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_decoding_backend_config::preferredFormat"] ++ [::core::mem::offset_of!(ma_decoding_backend_config, preferredFormat) - 0usize]; ++ ["Offset of field: ma_decoding_backend_config::seekPointCount"] ++ [::core::mem::offset_of!(ma_decoding_backend_config, seekPointCount) - 4usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_decoding_backend_config_init( ++ preferredFormat: ma_format, ++ seekPointCount: ma_uint32, ++ ) -> ma_decoding_backend_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoding_backend_vtable { ++ pub onInit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ onRead: ma_read_proc, ++ onSeek: ma_seek_proc, ++ onTell: ma_tell_proc, ++ pReadSeekTellUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_decoding_backend_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppBackend: *mut *mut ma_data_source, ++ ) -> ma_result, ++ >, ++ pub onInitFile: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_decoding_backend_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppBackend: *mut *mut ma_data_source, ++ ) -> ma_result, ++ >, ++ pub onInitFileW: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_decoding_backend_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppBackend: *mut *mut ma_data_source, ++ ) -> ma_result, ++ >, ++ pub onInitMemory: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pData: *const core::ffi::c_void, ++ dataSize: usize, ++ pConfig: *const ma_decoding_backend_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppBackend: *mut *mut ma_data_source, ++ ) -> ma_result, ++ >, ++ pub onUninit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_data_source, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ), ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoding_backend_vtable"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_decoding_backend_vtable"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onInit"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onInit) - 0usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onInitFile"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onInitFile) - 8usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onInitFileW"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onInitFileW) - 16usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onInitMemory"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onInitMemory) - 24usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onUninit"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onUninit) - 32usize]; ++}; ++pub type ma_decoder_read_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pDecoder: *mut ma_decoder, ++ pBufferOut: *mut core::ffi::c_void, ++ bytesToRead: usize, ++ pBytesRead: *mut usize, ++ ) -> ma_result, ++>; ++pub type ma_decoder_seek_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pDecoder: *mut ma_decoder, ++ byteOffset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result, ++>; ++pub type ma_decoder_tell_proc = ::core::option::Option< ++ unsafe extern "C" fn(pDecoder: *mut ma_decoder, pCursor: *mut ma_int64) -> ma_result, ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoder_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub pChannelMap: *mut ma_channel, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub ditherMode: ma_dither_mode, ++ pub resampling: ma_resampler_config, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub encodingFormat: ma_encoding_format, ++ pub seekPointCount: ma_uint32, ++ pub ppCustomBackendVTables: *mut *mut ma_decoding_backend_vtable, ++ pub customBackendCount: ma_uint32, ++ pub pCustomBackendUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder_config"][::core::mem::size_of::() - 144usize]; ++ ["Alignment of ma_decoder_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder_config::format"] ++ [::core::mem::offset_of!(ma_decoder_config, format) - 0usize]; ++ ["Offset of field: ma_decoder_config::channels"] ++ [::core::mem::offset_of!(ma_decoder_config, channels) - 4usize]; ++ ["Offset of field: ma_decoder_config::sampleRate"] ++ [::core::mem::offset_of!(ma_decoder_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_decoder_config::pChannelMap"] ++ [::core::mem::offset_of!(ma_decoder_config, pChannelMap) - 16usize]; ++ ["Offset of field: ma_decoder_config::channelMixMode"] ++ [::core::mem::offset_of!(ma_decoder_config, channelMixMode) - 24usize]; ++ ["Offset of field: ma_decoder_config::ditherMode"] ++ [::core::mem::offset_of!(ma_decoder_config, ditherMode) - 28usize]; ++ ["Offset of field: ma_decoder_config::resampling"] ++ [::core::mem::offset_of!(ma_decoder_config, resampling) - 32usize]; ++ ["Offset of field: ma_decoder_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_decoder_config, allocationCallbacks) - 80usize]; ++ ["Offset of field: ma_decoder_config::encodingFormat"] ++ [::core::mem::offset_of!(ma_decoder_config, encodingFormat) - 112usize]; ++ ["Offset of field: ma_decoder_config::seekPointCount"] ++ [::core::mem::offset_of!(ma_decoder_config, seekPointCount) - 116usize]; ++ ["Offset of field: ma_decoder_config::ppCustomBackendVTables"] ++ [::core::mem::offset_of!(ma_decoder_config, ppCustomBackendVTables) - 120usize]; ++ ["Offset of field: ma_decoder_config::customBackendCount"] ++ [::core::mem::offset_of!(ma_decoder_config, customBackendCount) - 128usize]; ++ ["Offset of field: ma_decoder_config::pCustomBackendUserData"] ++ [::core::mem::offset_of!(ma_decoder_config, pCustomBackendUserData) - 136usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_decoder { ++ pub ds: ma_data_source_base, ++ pub pBackend: *mut ma_data_source, ++ pub pBackendVTable: *const ma_decoding_backend_vtable, ++ pub pBackendUserData: *mut core::ffi::c_void, ++ pub onRead: ma_decoder_read_proc, ++ pub onSeek: ma_decoder_seek_proc, ++ pub onTell: ma_decoder_tell_proc, ++ pub pUserData: *mut core::ffi::c_void, ++ pub readPointerInPCMFrames: ma_uint64, ++ pub outputFormat: ma_format, ++ pub outputChannels: ma_uint32, ++ pub outputSampleRate: ma_uint32, ++ pub converter: ma_data_converter, ++ pub pInputCache: *mut core::ffi::c_void, ++ pub inputCacheCap: ma_uint64, ++ pub inputCacheConsumed: ma_uint64, ++ pub inputCacheRemaining: ma_uint64, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub data: ma_decoder__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_decoder__bindgen_ty_1 { ++ pub vfs: ma_decoder__bindgen_ty_1__bindgen_ty_1, ++ pub memory: ma_decoder__bindgen_ty_1__bindgen_ty_2, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoder__bindgen_ty_1__bindgen_ty_1 { ++ pub pVFS: *mut ma_vfs, ++ pub file: ma_vfs_file, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_decoder__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_1::pVFS"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_1, pVFS) - 0usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_1::file"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_1, file) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoder__bindgen_ty_1__bindgen_ty_2 { ++ pub pData: *const ma_uint8, ++ pub dataSize: usize, ++ pub currentReadPos: usize, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_decoder__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_2::pData"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_2, pData) - 0usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_2::dataSize"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_2, dataSize) - 8usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_2::currentReadPos"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_2, currentReadPos) - 16usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder__bindgen_ty_1"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_decoder__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1::vfs"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1, vfs) - 0usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1::memory"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1, memory) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder"][::core::mem::size_of::() - 552usize]; ++ ["Alignment of ma_decoder"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder::ds"][::core::mem::offset_of!(ma_decoder, ds) - 0usize]; ++ ["Offset of field: ma_decoder::pBackend"] ++ [::core::mem::offset_of!(ma_decoder, pBackend) - 72usize]; ++ ["Offset of field: ma_decoder::pBackendVTable"] ++ [::core::mem::offset_of!(ma_decoder, pBackendVTable) - 80usize]; ++ ["Offset of field: ma_decoder::pBackendUserData"] ++ [::core::mem::offset_of!(ma_decoder, pBackendUserData) - 88usize]; ++ ["Offset of field: ma_decoder::onRead"][::core::mem::offset_of!(ma_decoder, onRead) - 96usize]; ++ ["Offset of field: ma_decoder::onSeek"][::core::mem::offset_of!(ma_decoder, onSeek) - 104usize]; ++ ["Offset of field: ma_decoder::onTell"][::core::mem::offset_of!(ma_decoder, onTell) - 112usize]; ++ ["Offset of field: ma_decoder::pUserData"] ++ [::core::mem::offset_of!(ma_decoder, pUserData) - 120usize]; ++ ["Offset of field: ma_decoder::readPointerInPCMFrames"] ++ [::core::mem::offset_of!(ma_decoder, readPointerInPCMFrames) - 128usize]; ++ ["Offset of field: ma_decoder::outputFormat"] ++ [::core::mem::offset_of!(ma_decoder, outputFormat) - 136usize]; ++ ["Offset of field: ma_decoder::outputChannels"] ++ [::core::mem::offset_of!(ma_decoder, outputChannels) - 140usize]; ++ ["Offset of field: ma_decoder::outputSampleRate"] ++ [::core::mem::offset_of!(ma_decoder, outputSampleRate) - 144usize]; ++ ["Offset of field: ma_decoder::converter"] ++ [::core::mem::offset_of!(ma_decoder, converter) - 152usize]; ++ ["Offset of field: ma_decoder::pInputCache"] ++ [::core::mem::offset_of!(ma_decoder, pInputCache) - 464usize]; ++ ["Offset of field: ma_decoder::inputCacheCap"] ++ [::core::mem::offset_of!(ma_decoder, inputCacheCap) - 472usize]; ++ ["Offset of field: ma_decoder::inputCacheConsumed"] ++ [::core::mem::offset_of!(ma_decoder, inputCacheConsumed) - 480usize]; ++ ["Offset of field: ma_decoder::inputCacheRemaining"] ++ [::core::mem::offset_of!(ma_decoder, inputCacheRemaining) - 488usize]; ++ ["Offset of field: ma_decoder::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_decoder, allocationCallbacks) - 496usize]; ++ ["Offset of field: ma_decoder::data"][::core::mem::offset_of!(ma_decoder, data) - 528usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_decoder_config_init( ++ outputFormat: ma_format, ++ outputChannels: ma_uint32, ++ outputSampleRate: ma_uint32, ++ ) -> ma_decoder_config; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_config_init_default() -> ma_decoder_config; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init( ++ onRead: ma_decoder_read_proc, ++ onSeek: ma_decoder_seek_proc, ++ pUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_memory( ++ pData: *const core::ffi::c_void, ++ dataSize: usize, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_vfs( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_vfs_w( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_file( ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_file_w( ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_uninit(pDecoder: *mut ma_decoder) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_read_pcm_frames( ++ pDecoder: *mut ma_decoder, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_seek_to_pcm_frame( ++ pDecoder: *mut ma_decoder, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_get_data_format( ++ pDecoder: *mut ma_decoder, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_get_cursor_in_pcm_frames( ++ pDecoder: *mut ma_decoder, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_get_length_in_pcm_frames( ++ pDecoder: *mut ma_decoder, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_get_available_frames( ++ pDecoder: *mut ma_decoder, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decode_from_vfs( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *mut ma_decoder_config, ++ pFrameCountOut: *mut ma_uint64, ++ ppPCMFramesOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decode_file( ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *mut ma_decoder_config, ++ pFrameCountOut: *mut ma_uint64, ++ ppPCMFramesOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decode_memory( ++ pData: *const core::ffi::c_void, ++ dataSize: usize, ++ pConfig: *mut ma_decoder_config, ++ pFrameCountOut: *mut ma_uint64, ++ ppPCMFramesOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++pub type ma_encoder_write_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pEncoder: *mut ma_encoder, ++ pBufferIn: *const core::ffi::c_void, ++ bytesToWrite: usize, ++ pBytesWritten: *mut usize, ++ ) -> ma_result, ++>; ++pub type ma_encoder_seek_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pEncoder: *mut ma_encoder, ++ offset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result, ++>; ++pub type ma_encoder_init_proc = ++ ::core::option::Option ma_result>; ++pub type ma_encoder_uninit_proc = ++ ::core::option::Option; ++pub type ma_encoder_write_pcm_frames_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pEncoder: *mut ma_encoder, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesWritten: *mut ma_uint64, ++ ) -> ma_result, ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_encoder_config { ++ pub encodingFormat: ma_encoding_format, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub allocationCallbacks: ma_allocation_callbacks, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_encoder_config"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_encoder_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_encoder_config::encodingFormat"] ++ [::core::mem::offset_of!(ma_encoder_config, encodingFormat) - 0usize]; ++ ["Offset of field: ma_encoder_config::format"] ++ [::core::mem::offset_of!(ma_encoder_config, format) - 4usize]; ++ ["Offset of field: ma_encoder_config::channels"] ++ [::core::mem::offset_of!(ma_encoder_config, channels) - 8usize]; ++ ["Offset of field: ma_encoder_config::sampleRate"] ++ [::core::mem::offset_of!(ma_encoder_config, sampleRate) - 12usize]; ++ ["Offset of field: ma_encoder_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_encoder_config, allocationCallbacks) - 16usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_encoder_config_init( ++ encodingFormat: ma_encoding_format, ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_encoder_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_encoder { ++ pub config: ma_encoder_config, ++ pub onWrite: ma_encoder_write_proc, ++ pub onSeek: ma_encoder_seek_proc, ++ pub onInit: ma_encoder_init_proc, ++ pub onUninit: ma_encoder_uninit_proc, ++ pub onWritePCMFrames: ma_encoder_write_pcm_frames_proc, ++ pub pUserData: *mut core::ffi::c_void, ++ pub pInternalEncoder: *mut core::ffi::c_void, ++ pub data: ma_encoder__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_encoder__bindgen_ty_1 { ++ pub vfs: ma_encoder__bindgen_ty_1__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_encoder__bindgen_ty_1__bindgen_ty_1 { ++ pub pVFS: *mut ma_vfs, ++ pub file: ma_vfs_file, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_encoder__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_encoder__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_encoder__bindgen_ty_1__bindgen_ty_1::pVFS"] ++ [::core::mem::offset_of!(ma_encoder__bindgen_ty_1__bindgen_ty_1, pVFS) - 0usize]; ++ ["Offset of field: ma_encoder__bindgen_ty_1__bindgen_ty_1::file"] ++ [::core::mem::offset_of!(ma_encoder__bindgen_ty_1__bindgen_ty_1, file) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_encoder__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_encoder__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_encoder__bindgen_ty_1::vfs"] ++ [::core::mem::offset_of!(ma_encoder__bindgen_ty_1, vfs) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_encoder"][::core::mem::size_of::() - 120usize]; ++ ["Alignment of ma_encoder"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_encoder::config"][::core::mem::offset_of!(ma_encoder, config) - 0usize]; ++ ["Offset of field: ma_encoder::onWrite"] ++ [::core::mem::offset_of!(ma_encoder, onWrite) - 48usize]; ++ ["Offset of field: ma_encoder::onSeek"][::core::mem::offset_of!(ma_encoder, onSeek) - 56usize]; ++ ["Offset of field: ma_encoder::onInit"][::core::mem::offset_of!(ma_encoder, onInit) - 64usize]; ++ ["Offset of field: ma_encoder::onUninit"] ++ [::core::mem::offset_of!(ma_encoder, onUninit) - 72usize]; ++ ["Offset of field: ma_encoder::onWritePCMFrames"] ++ [::core::mem::offset_of!(ma_encoder, onWritePCMFrames) - 80usize]; ++ ["Offset of field: ma_encoder::pUserData"] ++ [::core::mem::offset_of!(ma_encoder, pUserData) - 88usize]; ++ ["Offset of field: ma_encoder::pInternalEncoder"] ++ [::core::mem::offset_of!(ma_encoder, pInternalEncoder) - 96usize]; ++ ["Offset of field: ma_encoder::data"][::core::mem::offset_of!(ma_encoder, data) - 104usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_encoder_init( ++ onWrite: ma_encoder_write_proc, ++ onSeek: ma_encoder_seek_proc, ++ pUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_init_vfs( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_init_vfs_w( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_init_file( ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_init_file_w( ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_uninit(pEncoder: *mut ma_encoder); ++} ++unsafe extern "C" { ++ pub fn ma_encoder_write_pcm_frames( ++ pEncoder: *mut ma_encoder, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesWritten: *mut ma_uint64, ++ ) -> ma_result; ++} ++pub const ma_waveform_type_ma_waveform_type_sine: ma_waveform_type = 0; ++pub const ma_waveform_type_ma_waveform_type_square: ma_waveform_type = 1; ++pub const ma_waveform_type_ma_waveform_type_triangle: ma_waveform_type = 2; ++pub const ma_waveform_type_ma_waveform_type_sawtooth: ma_waveform_type = 3; ++pub type ma_waveform_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_waveform_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub type_: ma_waveform_type, ++ pub amplitude: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_waveform_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_waveform_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_waveform_config::format"] ++ [::core::mem::offset_of!(ma_waveform_config, format) - 0usize]; ++ ["Offset of field: ma_waveform_config::channels"] ++ [::core::mem::offset_of!(ma_waveform_config, channels) - 4usize]; ++ ["Offset of field: ma_waveform_config::sampleRate"] ++ [::core::mem::offset_of!(ma_waveform_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_waveform_config::type_"] ++ [::core::mem::offset_of!(ma_waveform_config, type_) - 12usize]; ++ ["Offset of field: ma_waveform_config::amplitude"] ++ [::core::mem::offset_of!(ma_waveform_config, amplitude) - 16usize]; ++ ["Offset of field: ma_waveform_config::frequency"] ++ [::core::mem::offset_of!(ma_waveform_config, frequency) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_waveform_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ type_: ma_waveform_type, ++ amplitude: f64, ++ frequency: f64, ++ ) -> ma_waveform_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_waveform { ++ pub ds: ma_data_source_base, ++ pub config: ma_waveform_config, ++ pub advance: f64, ++ pub time: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_waveform"][::core::mem::size_of::() - 120usize]; ++ ["Alignment of ma_waveform"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_waveform::ds"][::core::mem::offset_of!(ma_waveform, ds) - 0usize]; ++ ["Offset of field: ma_waveform::config"] ++ [::core::mem::offset_of!(ma_waveform, config) - 72usize]; ++ ["Offset of field: ma_waveform::advance"] ++ [::core::mem::offset_of!(ma_waveform, advance) - 104usize]; ++ ["Offset of field: ma_waveform::time"][::core::mem::offset_of!(ma_waveform, time) - 112usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_waveform_init( ++ pConfig: *const ma_waveform_config, ++ pWaveform: *mut ma_waveform, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_uninit(pWaveform: *mut ma_waveform); ++} ++unsafe extern "C" { ++ pub fn ma_waveform_read_pcm_frames( ++ pWaveform: *mut ma_waveform, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_seek_to_pcm_frame( ++ pWaveform: *mut ma_waveform, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_set_amplitude(pWaveform: *mut ma_waveform, amplitude: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_set_frequency(pWaveform: *mut ma_waveform, frequency: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_set_type(pWaveform: *mut ma_waveform, type_: ma_waveform_type) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_set_sample_rate( ++ pWaveform: *mut ma_waveform, ++ sampleRate: ma_uint32, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_pulsewave_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub dutyCycle: f64, ++ pub amplitude: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_pulsewave_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_pulsewave_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_pulsewave_config::format"] ++ [::core::mem::offset_of!(ma_pulsewave_config, format) - 0usize]; ++ ["Offset of field: ma_pulsewave_config::channels"] ++ [::core::mem::offset_of!(ma_pulsewave_config, channels) - 4usize]; ++ ["Offset of field: ma_pulsewave_config::sampleRate"] ++ [::core::mem::offset_of!(ma_pulsewave_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_pulsewave_config::dutyCycle"] ++ [::core::mem::offset_of!(ma_pulsewave_config, dutyCycle) - 16usize]; ++ ["Offset of field: ma_pulsewave_config::amplitude"] ++ [::core::mem::offset_of!(ma_pulsewave_config, amplitude) - 24usize]; ++ ["Offset of field: ma_pulsewave_config::frequency"] ++ [::core::mem::offset_of!(ma_pulsewave_config, frequency) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_pulsewave_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ dutyCycle: f64, ++ amplitude: f64, ++ frequency: f64, ++ ) -> ma_pulsewave_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_pulsewave { ++ pub waveform: ma_waveform, ++ pub config: ma_pulsewave_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_pulsewave"][::core::mem::size_of::() - 160usize]; ++ ["Alignment of ma_pulsewave"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_pulsewave::waveform"] ++ [::core::mem::offset_of!(ma_pulsewave, waveform) - 0usize]; ++ ["Offset of field: ma_pulsewave::config"] ++ [::core::mem::offset_of!(ma_pulsewave, config) - 120usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_pulsewave_init( ++ pConfig: *const ma_pulsewave_config, ++ pWaveform: *mut ma_pulsewave, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_uninit(pWaveform: *mut ma_pulsewave); ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_read_pcm_frames( ++ pWaveform: *mut ma_pulsewave, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_seek_to_pcm_frame( ++ pWaveform: *mut ma_pulsewave, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_set_amplitude(pWaveform: *mut ma_pulsewave, amplitude: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_set_frequency(pWaveform: *mut ma_pulsewave, frequency: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_set_sample_rate( ++ pWaveform: *mut ma_pulsewave, ++ sampleRate: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_set_duty_cycle(pWaveform: *mut ma_pulsewave, dutyCycle: f64) -> ma_result; ++} ++pub const ma_noise_type_ma_noise_type_white: ma_noise_type = 0; ++pub const ma_noise_type_ma_noise_type_pink: ma_noise_type = 1; ++pub const ma_noise_type_ma_noise_type_brownian: ma_noise_type = 2; ++pub type ma_noise_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_noise_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub type_: ma_noise_type, ++ pub seed: ma_int32, ++ pub amplitude: f64, ++ pub duplicateChannels: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_noise_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise_config::format"] ++ [::core::mem::offset_of!(ma_noise_config, format) - 0usize]; ++ ["Offset of field: ma_noise_config::channels"] ++ [::core::mem::offset_of!(ma_noise_config, channels) - 4usize]; ++ ["Offset of field: ma_noise_config::type_"] ++ [::core::mem::offset_of!(ma_noise_config, type_) - 8usize]; ++ ["Offset of field: ma_noise_config::seed"] ++ [::core::mem::offset_of!(ma_noise_config, seed) - 12usize]; ++ ["Offset of field: ma_noise_config::amplitude"] ++ [::core::mem::offset_of!(ma_noise_config, amplitude) - 16usize]; ++ ["Offset of field: ma_noise_config::duplicateChannels"] ++ [::core::mem::offset_of!(ma_noise_config, duplicateChannels) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_noise_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ type_: ma_noise_type, ++ seed: ma_int32, ++ amplitude: f64, ++ ) -> ma_noise_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_noise { ++ pub ds: ma_data_source_base, ++ pub config: ma_noise_config, ++ pub lcg: ma_lcg, ++ pub state: ma_noise__bindgen_ty_1, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_noise__bindgen_ty_1 { ++ pub pink: ma_noise__bindgen_ty_1__bindgen_ty_1, ++ pub brownian: ma_noise__bindgen_ty_1__bindgen_ty_2, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_noise__bindgen_ty_1__bindgen_ty_1 { ++ pub bin: *mut *mut f64, ++ pub accumulation: *mut f64, ++ pub counter: *mut ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_noise__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1__bindgen_ty_1::bin"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1__bindgen_ty_1, bin) - 0usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1__bindgen_ty_1::accumulation"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1__bindgen_ty_1, accumulation) - 8usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1__bindgen_ty_1::counter"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1__bindgen_ty_1, counter) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_noise__bindgen_ty_1__bindgen_ty_2 { ++ pub accumulation: *mut f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_noise__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1__bindgen_ty_2::accumulation"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1__bindgen_ty_2, accumulation) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise__bindgen_ty_1"][::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_noise__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1::pink"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1, pink) - 0usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1::brownian"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1, brownian) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise"][::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_noise"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise::ds"][::core::mem::offset_of!(ma_noise, ds) - 0usize]; ++ ["Offset of field: ma_noise::config"][::core::mem::offset_of!(ma_noise, config) - 72usize]; ++ ["Offset of field: ma_noise::lcg"][::core::mem::offset_of!(ma_noise, lcg) - 104usize]; ++ ["Offset of field: ma_noise::state"][::core::mem::offset_of!(ma_noise, state) - 112usize]; ++ ["Offset of field: ma_noise::_pHeap"][::core::mem::offset_of!(ma_noise, _pHeap) - 136usize]; ++ ["Offset of field: ma_noise::_ownsHeap"] ++ [::core::mem::offset_of!(ma_noise, _ownsHeap) - 144usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_noise_get_heap_size( ++ pConfig: *const ma_noise_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_init_preallocated( ++ pConfig: *const ma_noise_config, ++ pHeap: *mut core::ffi::c_void, ++ pNoise: *mut ma_noise, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_init( ++ pConfig: *const ma_noise_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNoise: *mut ma_noise, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_uninit( ++ pNoise: *mut ma_noise, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_noise_read_pcm_frames( ++ pNoise: *mut ma_noise, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_set_amplitude(pNoise: *mut ma_noise, amplitude: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_set_seed(pNoise: *mut ma_noise, seed: ma_int32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_set_type(pNoise: *mut ma_noise, type_: ma_noise_type) -> ma_result; ++} ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM: ++ ma_resource_manager_data_source_flags = 1; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE: ++ ma_resource_manager_data_source_flags = 2; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC: ++ ma_resource_manager_data_source_flags = 4; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT: ++ ma_resource_manager_data_source_flags = 8; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH : ma_resource_manager_data_source_flags = 16 ; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING: ++ ma_resource_manager_data_source_flags = 32; ++pub type ma_resource_manager_data_source_flags = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_pipeline_stage_notification { ++ pub pNotification: *mut ma_async_notification, ++ pub pFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_pipeline_stage_notification"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_resource_manager_pipeline_stage_notification"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_pipeline_stage_notification::pNotification"][::core::mem::offset_of!( ++ ma_resource_manager_pipeline_stage_notification, ++ pNotification ++ ) - 0usize]; ++ ["Offset of field: ma_resource_manager_pipeline_stage_notification::pFence"] ++ [::core::mem::offset_of!(ma_resource_manager_pipeline_stage_notification, pFence) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_pipeline_notifications { ++ pub init: ma_resource_manager_pipeline_stage_notification, ++ pub done: ma_resource_manager_pipeline_stage_notification, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_pipeline_notifications"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_resource_manager_pipeline_notifications"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_pipeline_notifications::init"] ++ [::core::mem::offset_of!(ma_resource_manager_pipeline_notifications, init) - 0usize]; ++ ["Offset of field: ma_resource_manager_pipeline_notifications::done"] ++ [::core::mem::offset_of!(ma_resource_manager_pipeline_notifications, done) - 16usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resource_manager_pipeline_notifications_init() ++ -> ma_resource_manager_pipeline_notifications; ++} ++pub const ma_resource_manager_flags_MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING: ++ ma_resource_manager_flags = 1; ++pub const ma_resource_manager_flags_MA_RESOURCE_MANAGER_FLAG_NO_THREADING: ++ ma_resource_manager_flags = 2; ++pub type ma_resource_manager_flags = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_data_source_config { ++ pub pFilePath: *const core::ffi::c_char, ++ pub pFilePathW: *const wchar_t, ++ pub pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pub initialSeekPointInPCMFrames: ma_uint64, ++ pub rangeBegInPCMFrames: ma_uint64, ++ pub rangeEndInPCMFrames: ma_uint64, ++ pub loopPointBegInPCMFrames: ma_uint64, ++ pub loopPointEndInPCMFrames: ma_uint64, ++ pub flags: ma_uint32, ++ pub isLooping: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_source_config"] ++ [::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_resource_manager_data_source_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::pFilePath"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, pFilePath) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::pFilePathW"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, pFilePathW) - 8usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::pNotifications"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, pNotifications) - 16usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::initialSeekPointInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ initialSeekPointInPCMFrames ++ ) ++ - 24usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::rangeBegInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ rangeBegInPCMFrames ++ ) - 32usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::rangeEndInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ rangeEndInPCMFrames ++ ) - 40usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::loopPointBegInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ loopPointBegInPCMFrames ++ ) ++ - 48usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::loopPointEndInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ loopPointEndInPCMFrames ++ ) ++ - 56usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, flags) - 64usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::isLooping"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, isLooping) - 68usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_config_init() -> ma_resource_manager_data_source_config; ++} ++pub const ma_resource_manager_data_supply_type_ma_resource_manager_data_supply_type_unknown: ++ ma_resource_manager_data_supply_type = 0; ++pub const ma_resource_manager_data_supply_type_ma_resource_manager_data_supply_type_encoded: ++ ma_resource_manager_data_supply_type = 1; ++pub const ma_resource_manager_data_supply_type_ma_resource_manager_data_supply_type_decoded: ++ ma_resource_manager_data_supply_type = 2; ++pub const ma_resource_manager_data_supply_type_ma_resource_manager_data_supply_type_decoded_paged : ma_resource_manager_data_supply_type = 3 ; ++pub type ma_resource_manager_data_supply_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_supply { ++ pub type_: ma_resource_manager_data_supply_type, ++ pub backend: ma_resource_manager_data_supply__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_resource_manager_data_supply__bindgen_ty_1 { ++ pub encoded: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1, ++ pub decoded: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ pub decodedPaged: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1 { ++ pub pData: *const core::ffi::c_void, ++ pub sizeInBytes: usize, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1"][::core::mem::size_of::< ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1, ++ >() - 16usize]; ++ ["Alignment of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() ++ - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1::pData"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1, ++ pData ++ ) ++ - 0usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1::sizeInBytes"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1, ++ sizeInBytes ++ ) ++ - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2 { ++ pub pData: *const core::ffi::c_void, ++ pub totalFrameCount: ma_uint64, ++ pub decodedFrameCount: ma_uint64, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2"][::core::mem::size_of::< ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ >() - 40usize]; ++ ["Alignment of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() ++ - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::pData"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ pData ++ ) ++ - 0usize]; ++ [ ++ "Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::totalFrameCount", ++ ][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ totalFrameCount ++ ) - 8usize]; ++ [ ++ "Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::decodedFrameCount", ++ ][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ decodedFrameCount ++ ) - 16usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::format"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ format ++ ) ++ - 24usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::channels"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ channels ++ ) ++ - 28usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::sampleRate"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ sampleRate ++ ) ++ - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3 { ++ pub data: ma_paged_audio_buffer_data, ++ pub decodedFrameCount: ma_uint64, ++ pub sampleRate: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3"][::core::mem::size_of::< ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++ >() - 56usize]; ++ ["Alignment of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::align_of::() ++ - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3::data"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++ data ++ ) ++ - 0usize]; ++ [ ++ "Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3::decodedFrameCount", ++ ][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++ decodedFrameCount ++ ) - 40usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3::sampleRate"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++ sampleRate ++ ) ++ - 48usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply__bindgen_ty_1"] ++ [::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_resource_manager_data_supply__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1::encoded"] ++ [::core::mem::offset_of!(ma_resource_manager_data_supply__bindgen_ty_1, encoded) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1::decoded"] ++ [::core::mem::offset_of!(ma_resource_manager_data_supply__bindgen_ty_1, decoded) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1::decodedPaged"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1, ++ decodedPaged ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply"] ++ [::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_resource_manager_data_supply"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply::type_"] ++ [::core::mem::offset_of!(ma_resource_manager_data_supply, type_) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_supply::backend"] ++ [::core::mem::offset_of!(ma_resource_manager_data_supply, backend) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_buffer_node { ++ pub hashedName32: ma_uint32, ++ pub refCount: ma_uint32, ++ pub result: ma_result, ++ pub executionCounter: ma_uint32, ++ pub executionPointer: ma_uint32, ++ pub isDataOwnedByResourceManager: ma_bool32, ++ pub data: ma_resource_manager_data_supply, ++ pub pParent: *mut ma_resource_manager_data_buffer_node, ++ pub pChildLo: *mut ma_resource_manager_data_buffer_node, ++ pub pChildHi: *mut ma_resource_manager_data_buffer_node, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_buffer_node"] ++ [::core::mem::size_of::() - 112usize]; ++ ["Alignment of ma_resource_manager_data_buffer_node"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::hashedName32"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, hashedName32) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::refCount"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, refCount) - 4usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::result"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, result) - 8usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::executionCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, executionCounter) - 12usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::executionPointer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, executionPointer) - 16usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::isDataOwnedByResourceManager"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer_node, ++ isDataOwnedByResourceManager ++ ) ++ - 20usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::data"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, data) - 24usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::pParent"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, pParent) - 88usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::pChildLo"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, pChildLo) - 96usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::pChildHi"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, pChildHi) - 104usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_buffer { ++ pub ds: ma_data_source_base, ++ pub pResourceManager: *mut ma_resource_manager, ++ pub pNode: *mut ma_resource_manager_data_buffer_node, ++ pub flags: ma_uint32, ++ pub executionCounter: ma_uint32, ++ pub executionPointer: ma_uint32, ++ pub seekTargetInPCMFrames: ma_uint64, ++ pub seekToCursorOnNextRead: ma_bool32, ++ pub result: ma_result, ++ pub isLooping: ma_bool32, ++ pub isConnectorInitialized: ma_atomic_bool32, ++ pub connector: ma_resource_manager_data_buffer__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_resource_manager_data_buffer__bindgen_ty_1 { ++ pub decoder: ma_decoder, ++ pub buffer: ma_audio_buffer, ++ pub pagedBuffer: ma_paged_audio_buffer, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_buffer__bindgen_ty_1"] ++ [::core::mem::size_of::() - 552usize]; ++ ["Alignment of ma_resource_manager_data_buffer__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_buffer__bindgen_ty_1::decoder"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer__bindgen_ty_1, decoder) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_buffer__bindgen_ty_1::buffer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer__bindgen_ty_1, buffer) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_buffer__bindgen_ty_1::pagedBuffer"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer__bindgen_ty_1, ++ pagedBuffer ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_buffer"] ++ [::core::mem::size_of::() - 680usize]; ++ ["Alignment of ma_resource_manager_data_buffer"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::ds"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, ds) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::pResourceManager"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, pResourceManager) - 72usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::pNode"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, pNode) - 80usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, flags) - 88usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::executionCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, executionCounter) - 92usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::executionPointer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, executionPointer) - 96usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::seekTargetInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer, ++ seekTargetInPCMFrames ++ ) - 104usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::seekToCursorOnNextRead"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer, ++ seekToCursorOnNextRead ++ ) - 112usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::result"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, result) - 116usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::isLooping"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, isLooping) - 120usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::isConnectorInitialized"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer, ++ isConnectorInitialized ++ ) - 124usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::connector"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, connector) - 128usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_stream { ++ pub ds: ma_data_source_base, ++ pub pResourceManager: *mut ma_resource_manager, ++ pub flags: ma_uint32, ++ pub decoder: ma_decoder, ++ pub isDecoderInitialized: ma_bool32, ++ pub totalLengthInPCMFrames: ma_uint64, ++ pub relativeCursor: ma_uint32, ++ pub absoluteCursor: ma_uint64, ++ pub currentPageIndex: ma_uint32, ++ pub executionCounter: ma_uint32, ++ pub executionPointer: ma_uint32, ++ pub isLooping: ma_bool32, ++ pub pPageData: *mut core::ffi::c_void, ++ pub pageFrameCount: [ma_uint32; 2usize], ++ pub result: ma_result, ++ pub isDecoderAtEnd: ma_bool32, ++ pub isPageValid: [ma_bool32; 2usize], ++ pub seekCounter: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_stream"] ++ [::core::mem::size_of::() - 728usize]; ++ ["Alignment of ma_resource_manager_data_stream"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_stream::ds"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, ds) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_stream::pResourceManager"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, pResourceManager) - 72usize]; ++ ["Offset of field: ma_resource_manager_data_stream::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, flags) - 80usize]; ++ ["Offset of field: ma_resource_manager_data_stream::decoder"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, decoder) - 88usize]; ++ ["Offset of field: ma_resource_manager_data_stream::isDecoderInitialized"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, isDecoderInitialized) - 640usize]; ++ ["Offset of field: ma_resource_manager_data_stream::totalLengthInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_stream, ++ totalLengthInPCMFrames ++ ) - 648usize]; ++ ["Offset of field: ma_resource_manager_data_stream::relativeCursor"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, relativeCursor) - 656usize]; ++ ["Offset of field: ma_resource_manager_data_stream::absoluteCursor"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, absoluteCursor) - 664usize]; ++ ["Offset of field: ma_resource_manager_data_stream::currentPageIndex"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, currentPageIndex) - 672usize]; ++ ["Offset of field: ma_resource_manager_data_stream::executionCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, executionCounter) - 676usize]; ++ ["Offset of field: ma_resource_manager_data_stream::executionPointer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, executionPointer) - 680usize]; ++ ["Offset of field: ma_resource_manager_data_stream::isLooping"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, isLooping) - 684usize]; ++ ["Offset of field: ma_resource_manager_data_stream::pPageData"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, pPageData) - 688usize]; ++ ["Offset of field: ma_resource_manager_data_stream::pageFrameCount"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, pageFrameCount) - 696usize]; ++ ["Offset of field: ma_resource_manager_data_stream::result"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, result) - 704usize]; ++ ["Offset of field: ma_resource_manager_data_stream::isDecoderAtEnd"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, isDecoderAtEnd) - 708usize]; ++ ["Offset of field: ma_resource_manager_data_stream::isPageValid"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, isPageValid) - 712usize]; ++ ["Offset of field: ma_resource_manager_data_stream::seekCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, seekCounter) - 720usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_source { ++ pub backend: ma_resource_manager_data_source__bindgen_ty_1, ++ pub flags: ma_uint32, ++ pub executionCounter: ma_uint32, ++ pub executionPointer: ma_uint32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_resource_manager_data_source__bindgen_ty_1 { ++ pub buffer: ma_resource_manager_data_buffer, ++ pub stream: ma_resource_manager_data_stream, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_source__bindgen_ty_1"] ++ [::core::mem::size_of::() - 728usize]; ++ ["Alignment of ma_resource_manager_data_source__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_source__bindgen_ty_1::buffer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source__bindgen_ty_1, buffer) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_source__bindgen_ty_1::stream"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source__bindgen_ty_1, stream) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_source"] ++ [::core::mem::size_of::() - 744usize]; ++ ["Alignment of ma_resource_manager_data_source"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_source::backend"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source, backend) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_source::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source, flags) - 728usize]; ++ ["Offset of field: ma_resource_manager_data_source::executionCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source, executionCounter) - 732usize]; ++ ["Offset of field: ma_resource_manager_data_source::executionPointer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source, executionPointer) - 736usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_config { ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub pLog: *mut ma_log, ++ pub decodedFormat: ma_format, ++ pub decodedChannels: ma_uint32, ++ pub decodedSampleRate: ma_uint32, ++ pub jobThreadCount: ma_uint32, ++ pub jobThreadStackSize: usize, ++ pub jobQueueCapacity: ma_uint32, ++ pub flags: ma_uint32, ++ pub pVFS: *mut ma_vfs, ++ pub ppCustomDecodingBackendVTables: *mut *mut ma_decoding_backend_vtable, ++ pub customDecodingBackendCount: ma_uint32, ++ pub pCustomDecodingBackendUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_config"] ++ [::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_resource_manager_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_resource_manager_config, allocationCallbacks) - 0usize]; ++ ["Offset of field: ma_resource_manager_config::pLog"] ++ [::core::mem::offset_of!(ma_resource_manager_config, pLog) - 32usize]; ++ ["Offset of field: ma_resource_manager_config::decodedFormat"] ++ [::core::mem::offset_of!(ma_resource_manager_config, decodedFormat) - 40usize]; ++ ["Offset of field: ma_resource_manager_config::decodedChannels"] ++ [::core::mem::offset_of!(ma_resource_manager_config, decodedChannels) - 44usize]; ++ ["Offset of field: ma_resource_manager_config::decodedSampleRate"] ++ [::core::mem::offset_of!(ma_resource_manager_config, decodedSampleRate) - 48usize]; ++ ["Offset of field: ma_resource_manager_config::jobThreadCount"] ++ [::core::mem::offset_of!(ma_resource_manager_config, jobThreadCount) - 52usize]; ++ ["Offset of field: ma_resource_manager_config::jobThreadStackSize"] ++ [::core::mem::offset_of!(ma_resource_manager_config, jobThreadStackSize) - 56usize]; ++ ["Offset of field: ma_resource_manager_config::jobQueueCapacity"] ++ [::core::mem::offset_of!(ma_resource_manager_config, jobQueueCapacity) - 64usize]; ++ ["Offset of field: ma_resource_manager_config::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_config, flags) - 68usize]; ++ ["Offset of field: ma_resource_manager_config::pVFS"] ++ [::core::mem::offset_of!(ma_resource_manager_config, pVFS) - 72usize]; ++ ["Offset of field: ma_resource_manager_config::ppCustomDecodingBackendVTables"][::core::mem::offset_of!( ++ ma_resource_manager_config, ++ ppCustomDecodingBackendVTables ++ ) - 80usize]; ++ ["Offset of field: ma_resource_manager_config::customDecodingBackendCount"] ++ [::core::mem::offset_of!(ma_resource_manager_config, customDecodingBackendCount) - 88usize]; ++ ["Offset of field: ma_resource_manager_config::pCustomDecodingBackendUserData"][::core::mem::offset_of!( ++ ma_resource_manager_config, ++ pCustomDecodingBackendUserData ++ ) - 96usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resource_manager_config_init() -> ma_resource_manager_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager { ++ pub config: ma_resource_manager_config, ++ pub pRootDataBufferNode: *mut ma_resource_manager_data_buffer_node, ++ pub dataBufferBSTLock: ma_mutex, ++ pub jobThreads: [ma_thread; 64usize], ++ pub jobQueue: ma_job_queue, ++ pub defaultVFS: ma_default_vfs, ++ pub log: ma_log, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager"][::core::mem::size_of::() - 1096usize]; ++ ["Alignment of ma_resource_manager"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager::config"] ++ [::core::mem::offset_of!(ma_resource_manager, config) - 0usize]; ++ ["Offset of field: ma_resource_manager::pRootDataBufferNode"] ++ [::core::mem::offset_of!(ma_resource_manager, pRootDataBufferNode) - 104usize]; ++ ["Offset of field: ma_resource_manager::dataBufferBSTLock"] ++ [::core::mem::offset_of!(ma_resource_manager, dataBufferBSTLock) - 112usize]; ++ ["Offset of field: ma_resource_manager::jobThreads"] ++ [::core::mem::offset_of!(ma_resource_manager, jobThreads) - 152usize]; ++ ["Offset of field: ma_resource_manager::jobQueue"] ++ [::core::mem::offset_of!(ma_resource_manager, jobQueue) - 664usize]; ++ ["Offset of field: ma_resource_manager::defaultVFS"] ++ [::core::mem::offset_of!(ma_resource_manager, defaultVFS) - 856usize]; ++ ["Offset of field: ma_resource_manager::log"] ++ [::core::mem::offset_of!(ma_resource_manager, log) - 952usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resource_manager_init( ++ pConfig: *const ma_resource_manager_config, ++ pResourceManager: *mut ma_resource_manager, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_uninit(pResourceManager: *mut ma_resource_manager); ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_get_log(pResourceManager: *mut ma_resource_manager) -> *mut ma_log; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_file( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const core::ffi::c_char, ++ flags: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_file_w( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const wchar_t, ++ flags: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_decoded_data( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const core::ffi::c_char, ++ pData: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_decoded_data_w( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const wchar_t, ++ pData: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_encoded_data( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const core::ffi::c_char, ++ pData: *const core::ffi::c_void, ++ sizeInBytes: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_encoded_data_w( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const wchar_t, ++ pData: *const core::ffi::c_void, ++ sizeInBytes: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_unregister_file( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const core::ffi::c_char, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_unregister_file_w( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const wchar_t, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_unregister_data( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const core::ffi::c_char, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_unregister_data_w( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const wchar_t, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_init_ex( ++ pResourceManager: *mut ma_resource_manager, ++ pConfig: *const ma_resource_manager_data_source_config, ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_init( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const core::ffi::c_char, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_init_w( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const wchar_t, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_init_copy( ++ pResourceManager: *mut ma_resource_manager, ++ pExistingDataBuffer: *const ma_resource_manager_data_buffer, ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_uninit( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_read_pcm_frames( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_seek_to_pcm_frame( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_get_data_format( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_get_cursor_in_pcm_frames( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_get_length_in_pcm_frames( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_result( ++ pDataBuffer: *const ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_set_looping( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_is_looping( ++ pDataBuffer: *const ma_resource_manager_data_buffer, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_get_available_frames( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_init_ex( ++ pResourceManager: *mut ma_resource_manager, ++ pConfig: *const ma_resource_manager_data_source_config, ++ pDataStream: *mut ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_init( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const core::ffi::c_char, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataStream: *mut ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_init_w( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const wchar_t, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataStream: *mut ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_uninit( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_read_pcm_frames( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_seek_to_pcm_frame( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_get_data_format( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_get_cursor_in_pcm_frames( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_get_length_in_pcm_frames( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_result( ++ pDataStream: *const ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_set_looping( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_is_looping( ++ pDataStream: *const ma_resource_manager_data_stream, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_get_available_frames( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_init_ex( ++ pResourceManager: *mut ma_resource_manager, ++ pConfig: *const ma_resource_manager_data_source_config, ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_init( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const core::ffi::c_char, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_init_w( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const wchar_t, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_init_copy( ++ pResourceManager: *mut ma_resource_manager, ++ pExistingDataSource: *const ma_resource_manager_data_source, ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_uninit( ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_read_pcm_frames( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_seek_to_pcm_frame( ++ pDataSource: *mut ma_resource_manager_data_source, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_get_data_format( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_get_cursor_in_pcm_frames( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_get_length_in_pcm_frames( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_result( ++ pDataSource: *const ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_set_looping( ++ pDataSource: *mut ma_resource_manager_data_source, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_is_looping( ++ pDataSource: *const ma_resource_manager_data_source, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_get_available_frames( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_post_job( ++ pResourceManager: *mut ma_resource_manager, ++ pJob: *const ma_job, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_post_job_quit( ++ pResourceManager: *mut ma_resource_manager, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_next_job( ++ pResourceManager: *mut ma_resource_manager, ++ pJob: *mut ma_job, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_process_job( ++ pResourceManager: *mut ma_resource_manager, ++ pJob: *mut ma_job, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_process_next_job( ++ pResourceManager: *mut ma_resource_manager, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_stack { ++ pub offset: usize, ++ pub sizeInBytes: usize, ++ pub _data: [core::ffi::c_uchar; 1usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_stack"][::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_stack"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_stack::offset"][::core::mem::offset_of!(ma_stack, offset) - 0usize]; ++ ["Offset of field: ma_stack::sizeInBytes"] ++ [::core::mem::offset_of!(ma_stack, sizeInBytes) - 8usize]; ++ ["Offset of field: ma_stack::_data"][::core::mem::offset_of!(ma_stack, _data) - 16usize]; ++}; ++pub type ma_node = core::ffi::c_void; ++pub const ma_node_flags_MA_NODE_FLAG_PASSTHROUGH: ma_node_flags = 1; ++pub const ma_node_flags_MA_NODE_FLAG_CONTINUOUS_PROCESSING: ma_node_flags = 2; ++pub const ma_node_flags_MA_NODE_FLAG_ALLOW_NULL_INPUT: ma_node_flags = 4; ++pub const ma_node_flags_MA_NODE_FLAG_DIFFERENT_PROCESSING_RATES: ma_node_flags = 8; ++pub const ma_node_flags_MA_NODE_FLAG_SILENT_OUTPUT: ma_node_flags = 16; ++pub type ma_node_flags = core::ffi::c_uint; ++pub const ma_node_state_ma_node_state_started: ma_node_state = 0; ++pub const ma_node_state_ma_node_state_stopped: ma_node_state = 1; ++pub type ma_node_state = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_vtable { ++ pub onProcess: ::core::option::Option< ++ unsafe extern "C" fn( ++ pNode: *mut ma_node, ++ ppFramesIn: *mut *const f32, ++ pFrameCountIn: *mut ma_uint32, ++ ppFramesOut: *mut *mut f32, ++ pFrameCountOut: *mut ma_uint32, ++ ), ++ >, ++ pub onGetRequiredInputFrameCount: ::core::option::Option< ++ unsafe extern "C" fn( ++ pNode: *mut ma_node, ++ outputFrameCount: ma_uint32, ++ pInputFrameCount: *mut ma_uint32, ++ ) -> ma_result, ++ >, ++ pub inputBusCount: ma_uint8, ++ pub outputBusCount: ma_uint8, ++ pub flags: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_vtable"][::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_node_vtable"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_vtable::onProcess"] ++ [::core::mem::offset_of!(ma_node_vtable, onProcess) - 0usize]; ++ ["Offset of field: ma_node_vtable::onGetRequiredInputFrameCount"] ++ [::core::mem::offset_of!(ma_node_vtable, onGetRequiredInputFrameCount) - 8usize]; ++ ["Offset of field: ma_node_vtable::inputBusCount"] ++ [::core::mem::offset_of!(ma_node_vtable, inputBusCount) - 16usize]; ++ ["Offset of field: ma_node_vtable::outputBusCount"] ++ [::core::mem::offset_of!(ma_node_vtable, outputBusCount) - 17usize]; ++ ["Offset of field: ma_node_vtable::flags"] ++ [::core::mem::offset_of!(ma_node_vtable, flags) - 20usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_config { ++ pub vtable: *const ma_node_vtable, ++ pub initialState: ma_node_state, ++ pub inputBusCount: ma_uint32, ++ pub outputBusCount: ma_uint32, ++ pub pInputChannels: *const ma_uint32, ++ pub pOutputChannels: *const ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_config::vtable"] ++ [::core::mem::offset_of!(ma_node_config, vtable) - 0usize]; ++ ["Offset of field: ma_node_config::initialState"] ++ [::core::mem::offset_of!(ma_node_config, initialState) - 8usize]; ++ ["Offset of field: ma_node_config::inputBusCount"] ++ [::core::mem::offset_of!(ma_node_config, inputBusCount) - 12usize]; ++ ["Offset of field: ma_node_config::outputBusCount"] ++ [::core::mem::offset_of!(ma_node_config, outputBusCount) - 16usize]; ++ ["Offset of field: ma_node_config::pInputChannels"] ++ [::core::mem::offset_of!(ma_node_config, pInputChannels) - 24usize]; ++ ["Offset of field: ma_node_config::pOutputChannels"] ++ [::core::mem::offset_of!(ma_node_config, pOutputChannels) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_node_config_init() -> ma_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_output_bus { ++ pub pNode: *mut ma_node, ++ pub outputBusIndex: ma_uint8, ++ pub channels: ma_uint8, ++ pub inputNodeInputBusIndex: ma_uint8, ++ pub flags: ma_uint32, ++ pub refCount: ma_uint32, ++ pub isAttached: ma_bool32, ++ pub lock: ma_spinlock, ++ pub volume: f32, ++ pub pNext: *mut ma_node_output_bus, ++ pub pPrev: *mut ma_node_output_bus, ++ pub pInputNode: *mut ma_node, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_output_bus"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_node_output_bus"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_output_bus::pNode"] ++ [::core::mem::offset_of!(ma_node_output_bus, pNode) - 0usize]; ++ ["Offset of field: ma_node_output_bus::outputBusIndex"] ++ [::core::mem::offset_of!(ma_node_output_bus, outputBusIndex) - 8usize]; ++ ["Offset of field: ma_node_output_bus::channels"] ++ [::core::mem::offset_of!(ma_node_output_bus, channels) - 9usize]; ++ ["Offset of field: ma_node_output_bus::inputNodeInputBusIndex"] ++ [::core::mem::offset_of!(ma_node_output_bus, inputNodeInputBusIndex) - 10usize]; ++ ["Offset of field: ma_node_output_bus::flags"] ++ [::core::mem::offset_of!(ma_node_output_bus, flags) - 12usize]; ++ ["Offset of field: ma_node_output_bus::refCount"] ++ [::core::mem::offset_of!(ma_node_output_bus, refCount) - 16usize]; ++ ["Offset of field: ma_node_output_bus::isAttached"] ++ [::core::mem::offset_of!(ma_node_output_bus, isAttached) - 20usize]; ++ ["Offset of field: ma_node_output_bus::lock"] ++ [::core::mem::offset_of!(ma_node_output_bus, lock) - 24usize]; ++ ["Offset of field: ma_node_output_bus::volume"] ++ [::core::mem::offset_of!(ma_node_output_bus, volume) - 28usize]; ++ ["Offset of field: ma_node_output_bus::pNext"] ++ [::core::mem::offset_of!(ma_node_output_bus, pNext) - 32usize]; ++ ["Offset of field: ma_node_output_bus::pPrev"] ++ [::core::mem::offset_of!(ma_node_output_bus, pPrev) - 40usize]; ++ ["Offset of field: ma_node_output_bus::pInputNode"] ++ [::core::mem::offset_of!(ma_node_output_bus, pInputNode) - 48usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_input_bus { ++ pub head: ma_node_output_bus, ++ pub nextCounter: ma_uint32, ++ pub lock: ma_spinlock, ++ pub channels: ma_uint8, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_input_bus"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_node_input_bus"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_input_bus::head"] ++ [::core::mem::offset_of!(ma_node_input_bus, head) - 0usize]; ++ ["Offset of field: ma_node_input_bus::nextCounter"] ++ [::core::mem::offset_of!(ma_node_input_bus, nextCounter) - 56usize]; ++ ["Offset of field: ma_node_input_bus::lock"] ++ [::core::mem::offset_of!(ma_node_input_bus, lock) - 60usize]; ++ ["Offset of field: ma_node_input_bus::channels"] ++ [::core::mem::offset_of!(ma_node_input_bus, channels) - 64usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_base { ++ pub pNodeGraph: *mut ma_node_graph, ++ pub vtable: *const ma_node_vtable, ++ pub inputBusCount: ma_uint32, ++ pub outputBusCount: ma_uint32, ++ pub pInputBuses: *mut ma_node_input_bus, ++ pub pOutputBuses: *mut ma_node_output_bus, ++ pub pCachedData: *mut f32, ++ pub cachedDataCapInFramesPerBus: ma_uint16, ++ pub cachedFrameCountOut: ma_uint16, ++ pub cachedFrameCountIn: ma_uint16, ++ pub consumedFrameCountIn: ma_uint16, ++ pub state: ma_node_state, ++ pub stateTimes: [ma_uint64; 2usize], ++ pub localTime: ma_uint64, ++ pub _inputBuses: [ma_node_input_bus; 2usize], ++ pub _outputBuses: [ma_node_output_bus; 2usize], ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_base"][::core::mem::size_of::() - 360usize]; ++ ["Alignment of ma_node_base"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_base::pNodeGraph"] ++ [::core::mem::offset_of!(ma_node_base, pNodeGraph) - 0usize]; ++ ["Offset of field: ma_node_base::vtable"] ++ [::core::mem::offset_of!(ma_node_base, vtable) - 8usize]; ++ ["Offset of field: ma_node_base::inputBusCount"] ++ [::core::mem::offset_of!(ma_node_base, inputBusCount) - 16usize]; ++ ["Offset of field: ma_node_base::outputBusCount"] ++ [::core::mem::offset_of!(ma_node_base, outputBusCount) - 20usize]; ++ ["Offset of field: ma_node_base::pInputBuses"] ++ [::core::mem::offset_of!(ma_node_base, pInputBuses) - 24usize]; ++ ["Offset of field: ma_node_base::pOutputBuses"] ++ [::core::mem::offset_of!(ma_node_base, pOutputBuses) - 32usize]; ++ ["Offset of field: ma_node_base::pCachedData"] ++ [::core::mem::offset_of!(ma_node_base, pCachedData) - 40usize]; ++ ["Offset of field: ma_node_base::cachedDataCapInFramesPerBus"] ++ [::core::mem::offset_of!(ma_node_base, cachedDataCapInFramesPerBus) - 48usize]; ++ ["Offset of field: ma_node_base::cachedFrameCountOut"] ++ [::core::mem::offset_of!(ma_node_base, cachedFrameCountOut) - 50usize]; ++ ["Offset of field: ma_node_base::cachedFrameCountIn"] ++ [::core::mem::offset_of!(ma_node_base, cachedFrameCountIn) - 52usize]; ++ ["Offset of field: ma_node_base::consumedFrameCountIn"] ++ [::core::mem::offset_of!(ma_node_base, consumedFrameCountIn) - 54usize]; ++ ["Offset of field: ma_node_base::state"] ++ [::core::mem::offset_of!(ma_node_base, state) - 56usize]; ++ ["Offset of field: ma_node_base::stateTimes"] ++ [::core::mem::offset_of!(ma_node_base, stateTimes) - 64usize]; ++ ["Offset of field: ma_node_base::localTime"] ++ [::core::mem::offset_of!(ma_node_base, localTime) - 80usize]; ++ ["Offset of field: ma_node_base::_inputBuses"] ++ [::core::mem::offset_of!(ma_node_base, _inputBuses) - 88usize]; ++ ["Offset of field: ma_node_base::_outputBuses"] ++ [::core::mem::offset_of!(ma_node_base, _outputBuses) - 232usize]; ++ ["Offset of field: ma_node_base::_pHeap"] ++ [::core::mem::offset_of!(ma_node_base, _pHeap) - 344usize]; ++ ["Offset of field: ma_node_base::_ownsHeap"] ++ [::core::mem::offset_of!(ma_node_base, _ownsHeap) - 352usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_node_get_heap_size( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_node_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_init_preallocated( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_node_config, ++ pHeap: *mut core::ffi::c_void, ++ pNode: *mut ma_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_uninit( ++ pNode: *mut ma_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_node_get_node_graph(pNode: *const ma_node) -> *mut ma_node_graph; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_input_bus_count(pNode: *const ma_node) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_output_bus_count(pNode: *const ma_node) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_input_channels(pNode: *const ma_node, inputBusIndex: ma_uint32) ++ -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_output_channels( ++ pNode: *const ma_node, ++ outputBusIndex: ma_uint32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_attach_output_bus( ++ pNode: *mut ma_node, ++ outputBusIndex: ma_uint32, ++ pOtherNode: *mut ma_node, ++ otherNodeInputBusIndex: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_detach_output_bus(pNode: *mut ma_node, outputBusIndex: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_detach_all_output_buses(pNode: *mut ma_node) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_set_output_bus_volume( ++ pNode: *mut ma_node, ++ outputBusIndex: ma_uint32, ++ volume: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_output_bus_volume(pNode: *const ma_node, outputBusIndex: ma_uint32) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_node_set_state(pNode: *mut ma_node, state: ma_node_state) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_state(pNode: *const ma_node) -> ma_node_state; ++} ++unsafe extern "C" { ++ pub fn ma_node_set_state_time( ++ pNode: *mut ma_node, ++ state: ma_node_state, ++ globalTime: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_state_time(pNode: *const ma_node, state: ma_node_state) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_state_by_time(pNode: *const ma_node, globalTime: ma_uint64) ++ -> ma_node_state; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_state_by_time_range( ++ pNode: *const ma_node, ++ globalTimeBeg: ma_uint64, ++ globalTimeEnd: ma_uint64, ++ ) -> ma_node_state; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_time(pNode: *const ma_node) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_node_set_time(pNode: *mut ma_node, localTime: ma_uint64) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_graph_config { ++ pub channels: ma_uint32, ++ pub processingSizeInFrames: ma_uint32, ++ pub preMixStackSizeInBytes: usize, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_graph_config"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_node_graph_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_graph_config::channels"] ++ [::core::mem::offset_of!(ma_node_graph_config, channels) - 0usize]; ++ ["Offset of field: ma_node_graph_config::processingSizeInFrames"] ++ [::core::mem::offset_of!(ma_node_graph_config, processingSizeInFrames) - 4usize]; ++ ["Offset of field: ma_node_graph_config::preMixStackSizeInBytes"] ++ [::core::mem::offset_of!(ma_node_graph_config, preMixStackSizeInBytes) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_node_graph_config_init(channels: ma_uint32) -> ma_node_graph_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_graph { ++ pub base: ma_node_base, ++ pub endpoint: ma_node_base, ++ pub pProcessingCache: *mut f32, ++ pub processingCacheFramesRemaining: ma_uint32, ++ pub processingSizeInFrames: ma_uint32, ++ pub isReading: ma_bool32, ++ pub pPreMixStack: *mut ma_stack, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_graph"][::core::mem::size_of::() - 752usize]; ++ ["Alignment of ma_node_graph"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_graph::base"][::core::mem::offset_of!(ma_node_graph, base) - 0usize]; ++ ["Offset of field: ma_node_graph::endpoint"] ++ [::core::mem::offset_of!(ma_node_graph, endpoint) - 360usize]; ++ ["Offset of field: ma_node_graph::pProcessingCache"] ++ [::core::mem::offset_of!(ma_node_graph, pProcessingCache) - 720usize]; ++ ["Offset of field: ma_node_graph::processingCacheFramesRemaining"] ++ [::core::mem::offset_of!(ma_node_graph, processingCacheFramesRemaining) - 728usize]; ++ ["Offset of field: ma_node_graph::processingSizeInFrames"] ++ [::core::mem::offset_of!(ma_node_graph, processingSizeInFrames) - 732usize]; ++ ["Offset of field: ma_node_graph::isReading"] ++ [::core::mem::offset_of!(ma_node_graph, isReading) - 736usize]; ++ ["Offset of field: ma_node_graph::pPreMixStack"] ++ [::core::mem::offset_of!(ma_node_graph, pPreMixStack) - 744usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_node_graph_init( ++ pConfig: *const ma_node_graph_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNodeGraph: *mut ma_node_graph, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_uninit( ++ pNodeGraph: *mut ma_node_graph, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_get_endpoint(pNodeGraph: *mut ma_node_graph) -> *mut ma_node; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_read_pcm_frames( ++ pNodeGraph: *mut ma_node_graph, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_get_channels(pNodeGraph: *const ma_node_graph) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_get_time(pNodeGraph: *const ma_node_graph) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_set_time( ++ pNodeGraph: *mut ma_node_graph, ++ globalTime: ma_uint64, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_node_config { ++ pub nodeConfig: ma_node_config, ++ pub pDataSource: *mut ma_data_source, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_node_config"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_data_source_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_data_source_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_data_source_node_config::pDataSource"] ++ [::core::mem::offset_of!(ma_data_source_node_config, pDataSource) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_source_node_config_init( ++ pDataSource: *mut ma_data_source, ++ ) -> ma_data_source_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_node { ++ pub base: ma_node_base, ++ pub pDataSource: *mut ma_data_source, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_node"][::core::mem::size_of::() - 368usize]; ++ ["Alignment of ma_data_source_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_node::base"] ++ [::core::mem::offset_of!(ma_data_source_node, base) - 0usize]; ++ ["Offset of field: ma_data_source_node::pDataSource"] ++ [::core::mem::offset_of!(ma_data_source_node, pDataSource) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_source_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_data_source_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pDataSourceNode: *mut ma_data_source_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_node_uninit( ++ pDataSourceNode: *mut ma_data_source_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_data_source_node_set_looping( ++ pDataSourceNode: *mut ma_data_source_node, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_node_is_looping(pDataSourceNode: *mut ma_data_source_node) -> ma_bool32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_splitter_node_config { ++ pub nodeConfig: ma_node_config, ++ pub channels: ma_uint32, ++ pub outputBusCount: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_splitter_node_config"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_splitter_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_splitter_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_splitter_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_splitter_node_config::channels"] ++ [::core::mem::offset_of!(ma_splitter_node_config, channels) - 40usize]; ++ ["Offset of field: ma_splitter_node_config::outputBusCount"] ++ [::core::mem::offset_of!(ma_splitter_node_config, outputBusCount) - 44usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_splitter_node_config_init(channels: ma_uint32) -> ma_splitter_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_splitter_node { ++ pub base: ma_node_base, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_splitter_node"][::core::mem::size_of::() - 360usize]; ++ ["Alignment of ma_splitter_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_splitter_node::base"] ++ [::core::mem::offset_of!(ma_splitter_node, base) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_splitter_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_splitter_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pSplitterNode: *mut ma_splitter_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_splitter_node_uninit( ++ pSplitterNode: *mut ma_splitter_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_biquad_node_config { ++ pub nodeConfig: ma_node_config, ++ pub biquad: ma_biquad_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad_node_config"][::core::mem::size_of::() - 96usize]; ++ ["Alignment of ma_biquad_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_biquad_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_biquad_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_biquad_node_config::biquad"] ++ [::core::mem::offset_of!(ma_biquad_node_config, biquad) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_biquad_node_config_init( ++ channels: ma_uint32, ++ b0: f32, ++ b1: f32, ++ b2: f32, ++ a0: f32, ++ a1: f32, ++ a2: f32, ++ ) -> ma_biquad_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_biquad_node { ++ pub baseNode: ma_node_base, ++ pub biquad: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_biquad_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_biquad_node::baseNode"] ++ [::core::mem::offset_of!(ma_biquad_node, baseNode) - 0usize]; ++ ["Offset of field: ma_biquad_node::biquad"] ++ [::core::mem::offset_of!(ma_biquad_node, biquad) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_biquad_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_biquad_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_biquad_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_node_reinit( ++ pConfig: *const ma_biquad_config, ++ pNode: *mut ma_biquad_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_node_uninit( ++ pNode: *mut ma_biquad_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub lpf: ma_lpf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_lpf_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_lpf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_lpf_node_config::lpf"] ++ [::core::mem::offset_of!(ma_lpf_node_config, lpf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_lpf_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf_node { ++ pub baseNode: ma_node_base, ++ pub lpf: ma_lpf, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf_node"][::core::mem::size_of::() - 416usize]; ++ ["Alignment of ma_lpf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf_node::baseNode"] ++ [::core::mem::offset_of!(ma_lpf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_lpf_node::lpf"][::core::mem::offset_of!(ma_lpf_node, lpf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_lpf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_lpf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_node_reinit(pConfig: *const ma_lpf_config, pNode: *mut ma_lpf_node) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_node_uninit( ++ pNode: *mut ma_lpf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub hpf: ma_hpf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_hpf_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_hpf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_hpf_node_config::hpf"] ++ [::core::mem::offset_of!(ma_hpf_node_config, hpf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_hpf_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf_node { ++ pub baseNode: ma_node_base, ++ pub hpf: ma_hpf, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf_node"][::core::mem::size_of::() - 416usize]; ++ ["Alignment of ma_hpf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf_node::baseNode"] ++ [::core::mem::offset_of!(ma_hpf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_hpf_node::hpf"][::core::mem::offset_of!(ma_hpf_node, hpf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_hpf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_hpf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_node_reinit(pConfig: *const ma_hpf_config, pNode: *mut ma_hpf_node) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_node_uninit( ++ pNode: *mut ma_hpf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub bpf: ma_bpf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_bpf_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_bpf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_bpf_node_config::bpf"] ++ [::core::mem::offset_of!(ma_bpf_node_config, bpf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_bpf_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf_node { ++ pub baseNode: ma_node_base, ++ pub bpf: ma_bpf, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf_node"][::core::mem::size_of::() - 400usize]; ++ ["Alignment of ma_bpf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf_node::baseNode"] ++ [::core::mem::offset_of!(ma_bpf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_bpf_node::bpf"][::core::mem::offset_of!(ma_bpf_node, bpf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_bpf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_bpf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_node_reinit(pConfig: *const ma_bpf_config, pNode: *mut ma_bpf_node) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_node_uninit( ++ pNode: *mut ma_bpf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_notch_node_config { ++ pub nodeConfig: ma_node_config, ++ pub notch: ma_notch_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_notch_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_notch_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_notch_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_notch_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_notch_node_config::notch"] ++ [::core::mem::offset_of!(ma_notch_node_config, notch) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_notch_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ q: f64, ++ frequency: f64, ++ ) -> ma_notch_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_notch_node { ++ pub baseNode: ma_node_base, ++ pub notch: ma_notch2, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_notch_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_notch_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_notch_node::baseNode"] ++ [::core::mem::offset_of!(ma_notch_node, baseNode) - 0usize]; ++ ["Offset of field: ma_notch_node::notch"] ++ [::core::mem::offset_of!(ma_notch_node, notch) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_notch_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_notch_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_notch_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch_node_reinit( ++ pConfig: *const ma_notch_config, ++ pNode: *mut ma_notch_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch_node_uninit( ++ pNode: *mut ma_notch_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_peak_node_config { ++ pub nodeConfig: ma_node_config, ++ pub peak: ma_peak_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_peak_node_config"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_peak_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_peak_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_peak_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_peak_node_config::peak"] ++ [::core::mem::offset_of!(ma_peak_node_config, peak) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_peak_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ q: f64, ++ frequency: f64, ++ ) -> ma_peak_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_peak_node { ++ pub baseNode: ma_node_base, ++ pub peak: ma_peak2, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_peak_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_peak_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_peak_node::baseNode"] ++ [::core::mem::offset_of!(ma_peak_node, baseNode) - 0usize]; ++ ["Offset of field: ma_peak_node::peak"][::core::mem::offset_of!(ma_peak_node, peak) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_peak_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_peak_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_peak_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak_node_reinit( ++ pConfig: *const ma_peak_config, ++ pNode: *mut ma_peak_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak_node_uninit( ++ pNode: *mut ma_peak_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_loshelf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub loshelf: ma_loshelf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_loshelf_node_config"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_loshelf_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_loshelf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_loshelf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_loshelf_node_config::loshelf"] ++ [::core::mem::offset_of!(ma_loshelf_node_config, loshelf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_loshelf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ q: f64, ++ frequency: f64, ++ ) -> ma_loshelf_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_loshelf_node { ++ pub baseNode: ma_node_base, ++ pub loshelf: ma_loshelf2, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_loshelf_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_loshelf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_loshelf_node::baseNode"] ++ [::core::mem::offset_of!(ma_loshelf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_loshelf_node::loshelf"] ++ [::core::mem::offset_of!(ma_loshelf_node, loshelf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_loshelf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_loshelf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_loshelf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf_node_reinit( ++ pConfig: *const ma_loshelf_config, ++ pNode: *mut ma_loshelf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf_node_uninit( ++ pNode: *mut ma_loshelf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hishelf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub hishelf: ma_hishelf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hishelf_node_config"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_hishelf_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hishelf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_hishelf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_hishelf_node_config::hishelf"] ++ [::core::mem::offset_of!(ma_hishelf_node_config, hishelf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hishelf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ q: f64, ++ frequency: f64, ++ ) -> ma_hishelf_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_hishelf_node { ++ pub baseNode: ma_node_base, ++ pub hishelf: ma_hishelf2, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hishelf_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_hishelf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hishelf_node::baseNode"] ++ [::core::mem::offset_of!(ma_hishelf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_hishelf_node::hishelf"] ++ [::core::mem::offset_of!(ma_hishelf_node, hishelf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hishelf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_hishelf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_hishelf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf_node_reinit( ++ pConfig: *const ma_hishelf_config, ++ pNode: *mut ma_hishelf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf_node_uninit( ++ pNode: *mut ma_hishelf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_delay_node_config { ++ pub nodeConfig: ma_node_config, ++ pub delay: ma_delay_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_delay_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_delay_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_delay_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_delay_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_delay_node_config::delay"] ++ [::core::mem::offset_of!(ma_delay_node_config, delay) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_delay_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ delayInFrames: ma_uint32, ++ decay: f32, ++ ) -> ma_delay_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_delay_node { ++ pub baseNode: ma_node_base, ++ pub delay: ma_delay, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_delay_node"][::core::mem::size_of::() - 408usize]; ++ ["Alignment of ma_delay_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_delay_node::baseNode"] ++ [::core::mem::offset_of!(ma_delay_node, baseNode) - 0usize]; ++ ["Offset of field: ma_delay_node::delay"] ++ [::core::mem::offset_of!(ma_delay_node, delay) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_delay_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_delay_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pDelayNode: *mut ma_delay_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_uninit( ++ pDelayNode: *mut ma_delay_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_set_wet(pDelayNode: *mut ma_delay_node, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_get_wet(pDelayNode: *const ma_delay_node) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_set_dry(pDelayNode: *mut ma_delay_node, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_get_dry(pDelayNode: *const ma_delay_node) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_set_decay(pDelayNode: *mut ma_delay_node, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_get_decay(pDelayNode: *const ma_delay_node) -> f32; ++} ++pub const ma_sound_flags_MA_SOUND_FLAG_STREAM: ma_sound_flags = 1; ++pub const ma_sound_flags_MA_SOUND_FLAG_DECODE: ma_sound_flags = 2; ++pub const ma_sound_flags_MA_SOUND_FLAG_ASYNC: ma_sound_flags = 4; ++pub const ma_sound_flags_MA_SOUND_FLAG_WAIT_INIT: ma_sound_flags = 8; ++pub const ma_sound_flags_MA_SOUND_FLAG_UNKNOWN_LENGTH: ma_sound_flags = 16; ++pub const ma_sound_flags_MA_SOUND_FLAG_LOOPING: ma_sound_flags = 32; ++pub const ma_sound_flags_MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT: ma_sound_flags = 4096; ++pub const ma_sound_flags_MA_SOUND_FLAG_NO_PITCH: ma_sound_flags = 8192; ++pub const ma_sound_flags_MA_SOUND_FLAG_NO_SPATIALIZATION: ma_sound_flags = 16384; ++pub type ma_sound_flags = core::ffi::c_uint; ++pub const ma_engine_node_type_ma_engine_node_type_sound: ma_engine_node_type = 0; ++pub const ma_engine_node_type_ma_engine_node_type_group: ma_engine_node_type = 1; ++pub type ma_engine_node_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_engine_node_config { ++ pub pEngine: *mut ma_engine, ++ pub type_: ma_engine_node_type, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub volumeSmoothTimeInPCMFrames: ma_uint32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub isPitchDisabled: ma_bool8, ++ pub isSpatializationDisabled: ma_bool8, ++ pub pinnedListenerIndex: ma_uint8, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine_node_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_engine_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine_node_config::pEngine"] ++ [::core::mem::offset_of!(ma_engine_node_config, pEngine) - 0usize]; ++ ["Offset of field: ma_engine_node_config::type_"] ++ [::core::mem::offset_of!(ma_engine_node_config, type_) - 8usize]; ++ ["Offset of field: ma_engine_node_config::channelsIn"] ++ [::core::mem::offset_of!(ma_engine_node_config, channelsIn) - 12usize]; ++ ["Offset of field: ma_engine_node_config::channelsOut"] ++ [::core::mem::offset_of!(ma_engine_node_config, channelsOut) - 16usize]; ++ ["Offset of field: ma_engine_node_config::sampleRate"] ++ [::core::mem::offset_of!(ma_engine_node_config, sampleRate) - 20usize]; ++ ["Offset of field: ma_engine_node_config::volumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_engine_node_config, volumeSmoothTimeInPCMFrames) - 24usize]; ++ ["Offset of field: ma_engine_node_config::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_engine_node_config, monoExpansionMode) - 28usize]; ++ ["Offset of field: ma_engine_node_config::isPitchDisabled"] ++ [::core::mem::offset_of!(ma_engine_node_config, isPitchDisabled) - 32usize]; ++ ["Offset of field: ma_engine_node_config::isSpatializationDisabled"] ++ [::core::mem::offset_of!(ma_engine_node_config, isSpatializationDisabled) - 33usize]; ++ ["Offset of field: ma_engine_node_config::pinnedListenerIndex"] ++ [::core::mem::offset_of!(ma_engine_node_config, pinnedListenerIndex) - 34usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_engine_node_config_init( ++ pEngine: *mut ma_engine, ++ type_: ma_engine_node_type, ++ flags: ma_uint32, ++ ) -> ma_engine_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_engine_node { ++ pub baseNode: ma_node_base, ++ pub pEngine: *mut ma_engine, ++ pub sampleRate: ma_uint32, ++ pub volumeSmoothTimeInPCMFrames: ma_uint32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub fader: ma_fader, ++ pub resampler: ma_linear_resampler, ++ pub spatializer: ma_spatializer, ++ pub panner: ma_panner, ++ pub volumeGainer: ma_gainer, ++ pub volume: ma_atomic_float, ++ pub pitch: f32, ++ pub oldPitch: f32, ++ pub oldDopplerPitch: f32, ++ pub isPitchDisabled: ma_bool32, ++ pub isSpatializationDisabled: ma_bool32, ++ pub pinnedListenerIndex: ma_uint32, ++ pub fadeSettings: ma_engine_node__bindgen_ty_1, ++ pub _ownsHeap: ma_bool8, ++ pub _pHeap: *mut core::ffi::c_void, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_engine_node__bindgen_ty_1 { ++ pub volumeBeg: ma_atomic_float, ++ pub volumeEnd: ma_atomic_float, ++ pub fadeLengthInFrames: ma_atomic_uint64, ++ pub absoluteGlobalTimeInFrames: ma_atomic_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine_node__bindgen_ty_1"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_engine_node__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine_node__bindgen_ty_1::volumeBeg"] ++ [::core::mem::offset_of!(ma_engine_node__bindgen_ty_1, volumeBeg) - 0usize]; ++ ["Offset of field: ma_engine_node__bindgen_ty_1::volumeEnd"] ++ [::core::mem::offset_of!(ma_engine_node__bindgen_ty_1, volumeEnd) - 4usize]; ++ ["Offset of field: ma_engine_node__bindgen_ty_1::fadeLengthInFrames"] ++ [::core::mem::offset_of!(ma_engine_node__bindgen_ty_1, fadeLengthInFrames) - 8usize]; ++ ["Offset of field: ma_engine_node__bindgen_ty_1::absoluteGlobalTimeInFrames"][::core::mem::offset_of!( ++ ma_engine_node__bindgen_ty_1, ++ absoluteGlobalTimeInFrames ++ ) - 16usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine_node"][::core::mem::size_of::() - 896usize]; ++ ["Alignment of ma_engine_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine_node::baseNode"] ++ [::core::mem::offset_of!(ma_engine_node, baseNode) - 0usize]; ++ ["Offset of field: ma_engine_node::pEngine"] ++ [::core::mem::offset_of!(ma_engine_node, pEngine) - 360usize]; ++ ["Offset of field: ma_engine_node::sampleRate"] ++ [::core::mem::offset_of!(ma_engine_node, sampleRate) - 368usize]; ++ ["Offset of field: ma_engine_node::volumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_engine_node, volumeSmoothTimeInPCMFrames) - 372usize]; ++ ["Offset of field: ma_engine_node::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_engine_node, monoExpansionMode) - 376usize]; ++ ["Offset of field: ma_engine_node::fader"] ++ [::core::mem::offset_of!(ma_engine_node, fader) - 384usize]; ++ ["Offset of field: ma_engine_node::resampler"] ++ [::core::mem::offset_of!(ma_engine_node, resampler) - 424usize]; ++ ["Offset of field: ma_engine_node::spatializer"] ++ [::core::mem::offset_of!(ma_engine_node, spatializer) - 560usize]; ++ ["Offset of field: ma_engine_node::panner"] ++ [::core::mem::offset_of!(ma_engine_node, panner) - 760usize]; ++ ["Offset of field: ma_engine_node::volumeGainer"] ++ [::core::mem::offset_of!(ma_engine_node, volumeGainer) - 776usize]; ++ ["Offset of field: ma_engine_node::volume"] ++ [::core::mem::offset_of!(ma_engine_node, volume) - 824usize]; ++ ["Offset of field: ma_engine_node::pitch"] ++ [::core::mem::offset_of!(ma_engine_node, pitch) - 828usize]; ++ ["Offset of field: ma_engine_node::oldPitch"] ++ [::core::mem::offset_of!(ma_engine_node, oldPitch) - 832usize]; ++ ["Offset of field: ma_engine_node::oldDopplerPitch"] ++ [::core::mem::offset_of!(ma_engine_node, oldDopplerPitch) - 836usize]; ++ ["Offset of field: ma_engine_node::isPitchDisabled"] ++ [::core::mem::offset_of!(ma_engine_node, isPitchDisabled) - 840usize]; ++ ["Offset of field: ma_engine_node::isSpatializationDisabled"] ++ [::core::mem::offset_of!(ma_engine_node, isSpatializationDisabled) - 844usize]; ++ ["Offset of field: ma_engine_node::pinnedListenerIndex"] ++ [::core::mem::offset_of!(ma_engine_node, pinnedListenerIndex) - 848usize]; ++ ["Offset of field: ma_engine_node::fadeSettings"] ++ [::core::mem::offset_of!(ma_engine_node, fadeSettings) - 856usize]; ++ ["Offset of field: ma_engine_node::_ownsHeap"] ++ [::core::mem::offset_of!(ma_engine_node, _ownsHeap) - 880usize]; ++ ["Offset of field: ma_engine_node::_pHeap"] ++ [::core::mem::offset_of!(ma_engine_node, _pHeap) - 888usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_engine_node_get_heap_size( ++ pConfig: *const ma_engine_node_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_node_init_preallocated( ++ pConfig: *const ma_engine_node_config, ++ pHeap: *mut core::ffi::c_void, ++ pEngineNode: *mut ma_engine_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_node_init( ++ pConfig: *const ma_engine_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pEngineNode: *mut ma_engine_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_node_uninit( ++ pEngineNode: *mut ma_engine_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++pub type ma_sound_end_proc = ::core::option::Option< ++ unsafe extern "C" fn(pUserData: *mut core::ffi::c_void, pSound: *mut ma_sound), ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_sound_config { ++ pub pFilePath: *const core::ffi::c_char, ++ pub pFilePathW: *const wchar_t, ++ pub pDataSource: *mut ma_data_source, ++ pub pInitialAttachment: *mut ma_node, ++ pub initialAttachmentInputBusIndex: ma_uint32, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub flags: ma_uint32, ++ pub volumeSmoothTimeInPCMFrames: ma_uint32, ++ pub initialSeekPointInPCMFrames: ma_uint64, ++ pub rangeBegInPCMFrames: ma_uint64, ++ pub rangeEndInPCMFrames: ma_uint64, ++ pub loopPointBegInPCMFrames: ma_uint64, ++ pub loopPointEndInPCMFrames: ma_uint64, ++ pub endCallback: ma_sound_end_proc, ++ pub pEndCallbackUserData: *mut core::ffi::c_void, ++ pub initNotifications: ma_resource_manager_pipeline_notifications, ++ pub pDoneFence: *mut ma_fence, ++ pub isLooping: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_sound_config"][::core::mem::size_of::() - 160usize]; ++ ["Alignment of ma_sound_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_sound_config::pFilePath"] ++ [::core::mem::offset_of!(ma_sound_config, pFilePath) - 0usize]; ++ ["Offset of field: ma_sound_config::pFilePathW"] ++ [::core::mem::offset_of!(ma_sound_config, pFilePathW) - 8usize]; ++ ["Offset of field: ma_sound_config::pDataSource"] ++ [::core::mem::offset_of!(ma_sound_config, pDataSource) - 16usize]; ++ ["Offset of field: ma_sound_config::pInitialAttachment"] ++ [::core::mem::offset_of!(ma_sound_config, pInitialAttachment) - 24usize]; ++ ["Offset of field: ma_sound_config::initialAttachmentInputBusIndex"] ++ [::core::mem::offset_of!(ma_sound_config, initialAttachmentInputBusIndex) - 32usize]; ++ ["Offset of field: ma_sound_config::channelsIn"] ++ [::core::mem::offset_of!(ma_sound_config, channelsIn) - 36usize]; ++ ["Offset of field: ma_sound_config::channelsOut"] ++ [::core::mem::offset_of!(ma_sound_config, channelsOut) - 40usize]; ++ ["Offset of field: ma_sound_config::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_sound_config, monoExpansionMode) - 44usize]; ++ ["Offset of field: ma_sound_config::flags"] ++ [::core::mem::offset_of!(ma_sound_config, flags) - 48usize]; ++ ["Offset of field: ma_sound_config::volumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, volumeSmoothTimeInPCMFrames) - 52usize]; ++ ["Offset of field: ma_sound_config::initialSeekPointInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, initialSeekPointInPCMFrames) - 56usize]; ++ ["Offset of field: ma_sound_config::rangeBegInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, rangeBegInPCMFrames) - 64usize]; ++ ["Offset of field: ma_sound_config::rangeEndInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, rangeEndInPCMFrames) - 72usize]; ++ ["Offset of field: ma_sound_config::loopPointBegInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, loopPointBegInPCMFrames) - 80usize]; ++ ["Offset of field: ma_sound_config::loopPointEndInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, loopPointEndInPCMFrames) - 88usize]; ++ ["Offset of field: ma_sound_config::endCallback"] ++ [::core::mem::offset_of!(ma_sound_config, endCallback) - 96usize]; ++ ["Offset of field: ma_sound_config::pEndCallbackUserData"] ++ [::core::mem::offset_of!(ma_sound_config, pEndCallbackUserData) - 104usize]; ++ ["Offset of field: ma_sound_config::initNotifications"] ++ [::core::mem::offset_of!(ma_sound_config, initNotifications) - 112usize]; ++ ["Offset of field: ma_sound_config::pDoneFence"] ++ [::core::mem::offset_of!(ma_sound_config, pDoneFence) - 144usize]; ++ ["Offset of field: ma_sound_config::isLooping"] ++ [::core::mem::offset_of!(ma_sound_config, isLooping) - 152usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_sound_config_init() -> ma_sound_config; ++} ++unsafe extern "C" { ++ pub fn ma_sound_config_init_2(pEngine: *mut ma_engine) -> ma_sound_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_sound { ++ pub engineNode: ma_engine_node, ++ pub pDataSource: *mut ma_data_source, ++ pub seekTarget: ma_uint64, ++ pub atEnd: ma_bool32, ++ pub endCallback: ma_sound_end_proc, ++ pub pEndCallbackUserData: *mut core::ffi::c_void, ++ pub ownsDataSource: ma_bool8, ++ pub pResourceManagerDataSource: *mut ma_resource_manager_data_source, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_sound"][::core::mem::size_of::() - 952usize]; ++ ["Alignment of ma_sound"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_sound::engineNode"] ++ [::core::mem::offset_of!(ma_sound, engineNode) - 0usize]; ++ ["Offset of field: ma_sound::pDataSource"] ++ [::core::mem::offset_of!(ma_sound, pDataSource) - 896usize]; ++ ["Offset of field: ma_sound::seekTarget"] ++ [::core::mem::offset_of!(ma_sound, seekTarget) - 904usize]; ++ ["Offset of field: ma_sound::atEnd"][::core::mem::offset_of!(ma_sound, atEnd) - 912usize]; ++ ["Offset of field: ma_sound::endCallback"] ++ [::core::mem::offset_of!(ma_sound, endCallback) - 920usize]; ++ ["Offset of field: ma_sound::pEndCallbackUserData"] ++ [::core::mem::offset_of!(ma_sound, pEndCallbackUserData) - 928usize]; ++ ["Offset of field: ma_sound::ownsDataSource"] ++ [::core::mem::offset_of!(ma_sound, ownsDataSource) - 936usize]; ++ ["Offset of field: ma_sound::pResourceManagerDataSource"] ++ [::core::mem::offset_of!(ma_sound, pResourceManagerDataSource) - 944usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_sound_inlined { ++ pub sound: ma_sound, ++ pub pNext: *mut ma_sound_inlined, ++ pub pPrev: *mut ma_sound_inlined, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_sound_inlined"][::core::mem::size_of::() - 968usize]; ++ ["Alignment of ma_sound_inlined"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_sound_inlined::sound"] ++ [::core::mem::offset_of!(ma_sound_inlined, sound) - 0usize]; ++ ["Offset of field: ma_sound_inlined::pNext"] ++ [::core::mem::offset_of!(ma_sound_inlined, pNext) - 952usize]; ++ ["Offset of field: ma_sound_inlined::pPrev"] ++ [::core::mem::offset_of!(ma_sound_inlined, pPrev) - 960usize]; ++}; ++pub type ma_sound_group_config = ma_sound_config; ++pub type ma_sound_group = ma_sound; ++unsafe extern "C" { ++ pub fn ma_sound_group_config_init() -> ma_sound_group_config; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_config_init_2(pEngine: *mut ma_engine) -> ma_sound_group_config; ++} ++pub type ma_engine_process_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pFramesOut: *mut f32, ++ frameCount: ma_uint64, ++ ), ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_engine_config { ++ pub pResourceManager: *mut ma_resource_manager, ++ pub pContext: *mut ma_context, ++ pub pDevice: *mut ma_device, ++ pub pPlaybackDeviceID: *mut ma_device_id, ++ pub dataCallback: ma_device_data_proc, ++ pub notificationCallback: ma_device_notification_proc, ++ pub pLog: *mut ma_log, ++ pub listenerCount: ma_uint32, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub periodSizeInFrames: ma_uint32, ++ pub periodSizeInMilliseconds: ma_uint32, ++ pub gainSmoothTimeInFrames: ma_uint32, ++ pub gainSmoothTimeInMilliseconds: ma_uint32, ++ pub defaultVolumeSmoothTimeInPCMFrames: ma_uint32, ++ pub preMixStackSizeInBytes: ma_uint32, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub noAutoStart: ma_bool32, ++ pub noDevice: ma_bool32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub pResourceManagerVFS: *mut ma_vfs, ++ pub onProcess: ma_engine_process_proc, ++ pub pProcessUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine_config"][::core::mem::size_of::() - 168usize]; ++ ["Alignment of ma_engine_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine_config::pResourceManager"] ++ [::core::mem::offset_of!(ma_engine_config, pResourceManager) - 0usize]; ++ ["Offset of field: ma_engine_config::pContext"] ++ [::core::mem::offset_of!(ma_engine_config, pContext) - 8usize]; ++ ["Offset of field: ma_engine_config::pDevice"] ++ [::core::mem::offset_of!(ma_engine_config, pDevice) - 16usize]; ++ ["Offset of field: ma_engine_config::pPlaybackDeviceID"] ++ [::core::mem::offset_of!(ma_engine_config, pPlaybackDeviceID) - 24usize]; ++ ["Offset of field: ma_engine_config::dataCallback"] ++ [::core::mem::offset_of!(ma_engine_config, dataCallback) - 32usize]; ++ ["Offset of field: ma_engine_config::notificationCallback"] ++ [::core::mem::offset_of!(ma_engine_config, notificationCallback) - 40usize]; ++ ["Offset of field: ma_engine_config::pLog"] ++ [::core::mem::offset_of!(ma_engine_config, pLog) - 48usize]; ++ ["Offset of field: ma_engine_config::listenerCount"] ++ [::core::mem::offset_of!(ma_engine_config, listenerCount) - 56usize]; ++ ["Offset of field: ma_engine_config::channels"] ++ [::core::mem::offset_of!(ma_engine_config, channels) - 60usize]; ++ ["Offset of field: ma_engine_config::sampleRate"] ++ [::core::mem::offset_of!(ma_engine_config, sampleRate) - 64usize]; ++ ["Offset of field: ma_engine_config::periodSizeInFrames"] ++ [::core::mem::offset_of!(ma_engine_config, periodSizeInFrames) - 68usize]; ++ ["Offset of field: ma_engine_config::periodSizeInMilliseconds"] ++ [::core::mem::offset_of!(ma_engine_config, periodSizeInMilliseconds) - 72usize]; ++ ["Offset of field: ma_engine_config::gainSmoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_engine_config, gainSmoothTimeInFrames) - 76usize]; ++ ["Offset of field: ma_engine_config::gainSmoothTimeInMilliseconds"] ++ [::core::mem::offset_of!(ma_engine_config, gainSmoothTimeInMilliseconds) - 80usize]; ++ ["Offset of field: ma_engine_config::defaultVolumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_engine_config, defaultVolumeSmoothTimeInPCMFrames) - 84usize]; ++ ["Offset of field: ma_engine_config::preMixStackSizeInBytes"] ++ [::core::mem::offset_of!(ma_engine_config, preMixStackSizeInBytes) - 88usize]; ++ ["Offset of field: ma_engine_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_engine_config, allocationCallbacks) - 96usize]; ++ ["Offset of field: ma_engine_config::noAutoStart"] ++ [::core::mem::offset_of!(ma_engine_config, noAutoStart) - 128usize]; ++ ["Offset of field: ma_engine_config::noDevice"] ++ [::core::mem::offset_of!(ma_engine_config, noDevice) - 132usize]; ++ ["Offset of field: ma_engine_config::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_engine_config, monoExpansionMode) - 136usize]; ++ ["Offset of field: ma_engine_config::pResourceManagerVFS"] ++ [::core::mem::offset_of!(ma_engine_config, pResourceManagerVFS) - 144usize]; ++ ["Offset of field: ma_engine_config::onProcess"] ++ [::core::mem::offset_of!(ma_engine_config, onProcess) - 152usize]; ++ ["Offset of field: ma_engine_config::pProcessUserData"] ++ [::core::mem::offset_of!(ma_engine_config, pProcessUserData) - 160usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_engine_config_init() -> ma_engine_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_engine { ++ pub nodeGraph: ma_node_graph, ++ pub pResourceManager: *mut ma_resource_manager, ++ pub pDevice: *mut ma_device, ++ pub pLog: *mut ma_log, ++ pub sampleRate: ma_uint32, ++ pub listenerCount: ma_uint32, ++ pub listeners: [ma_spatializer_listener; 4usize], ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub ownsResourceManager: ma_bool8, ++ pub ownsDevice: ma_bool8, ++ pub inlinedSoundLock: ma_spinlock, ++ pub pInlinedSoundHead: *mut ma_sound_inlined, ++ pub inlinedSoundCount: ma_uint32, ++ pub gainSmoothTimeInFrames: ma_uint32, ++ pub defaultVolumeSmoothTimeInPCMFrames: ma_uint32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub onProcess: ma_engine_process_proc, ++ pub pProcessUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine"][::core::mem::size_of::() - 1312usize]; ++ ["Alignment of ma_engine"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine::nodeGraph"] ++ [::core::mem::offset_of!(ma_engine, nodeGraph) - 0usize]; ++ ["Offset of field: ma_engine::pResourceManager"] ++ [::core::mem::offset_of!(ma_engine, pResourceManager) - 752usize]; ++ ["Offset of field: ma_engine::pDevice"][::core::mem::offset_of!(ma_engine, pDevice) - 760usize]; ++ ["Offset of field: ma_engine::pLog"][::core::mem::offset_of!(ma_engine, pLog) - 768usize]; ++ ["Offset of field: ma_engine::sampleRate"] ++ [::core::mem::offset_of!(ma_engine, sampleRate) - 776usize]; ++ ["Offset of field: ma_engine::listenerCount"] ++ [::core::mem::offset_of!(ma_engine, listenerCount) - 780usize]; ++ ["Offset of field: ma_engine::listeners"] ++ [::core::mem::offset_of!(ma_engine, listeners) - 784usize]; ++ ["Offset of field: ma_engine::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_engine, allocationCallbacks) - 1232usize]; ++ ["Offset of field: ma_engine::ownsResourceManager"] ++ [::core::mem::offset_of!(ma_engine, ownsResourceManager) - 1264usize]; ++ ["Offset of field: ma_engine::ownsDevice"] ++ [::core::mem::offset_of!(ma_engine, ownsDevice) - 1265usize]; ++ ["Offset of field: ma_engine::inlinedSoundLock"] ++ [::core::mem::offset_of!(ma_engine, inlinedSoundLock) - 1268usize]; ++ ["Offset of field: ma_engine::pInlinedSoundHead"] ++ [::core::mem::offset_of!(ma_engine, pInlinedSoundHead) - 1272usize]; ++ ["Offset of field: ma_engine::inlinedSoundCount"] ++ [::core::mem::offset_of!(ma_engine, inlinedSoundCount) - 1280usize]; ++ ["Offset of field: ma_engine::gainSmoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_engine, gainSmoothTimeInFrames) - 1284usize]; ++ ["Offset of field: ma_engine::defaultVolumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_engine, defaultVolumeSmoothTimeInPCMFrames) - 1288usize]; ++ ["Offset of field: ma_engine::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_engine, monoExpansionMode) - 1292usize]; ++ ["Offset of field: ma_engine::onProcess"] ++ [::core::mem::offset_of!(ma_engine, onProcess) - 1296usize]; ++ ["Offset of field: ma_engine::pProcessUserData"] ++ [::core::mem::offset_of!(ma_engine, pProcessUserData) - 1304usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_engine_init(pConfig: *const ma_engine_config, pEngine: *mut ma_engine) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_uninit(pEngine: *mut ma_engine); ++} ++unsafe extern "C" { ++ pub fn ma_engine_read_pcm_frames( ++ pEngine: *mut ma_engine, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_node_graph(pEngine: *mut ma_engine) -> *mut ma_node_graph; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_resource_manager(pEngine: *mut ma_engine) -> *mut ma_resource_manager; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_device(pEngine: *mut ma_engine) -> *mut ma_device; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_log(pEngine: *mut ma_engine) -> *mut ma_log; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_endpoint(pEngine: *mut ma_engine) -> *mut ma_node; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_time_in_pcm_frames(pEngine: *const ma_engine) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_time_in_milliseconds(pEngine: *const ma_engine) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_time_in_pcm_frames( ++ pEngine: *mut ma_engine, ++ globalTime: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_time_in_milliseconds( ++ pEngine: *mut ma_engine, ++ globalTime: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_time(pEngine: *const ma_engine) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_time(pEngine: *mut ma_engine, globalTime: ma_uint64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_channels(pEngine: *const ma_engine) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_sample_rate(pEngine: *const ma_engine) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_start(pEngine: *mut ma_engine) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_stop(pEngine: *mut ma_engine) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_volume(pEngine: *mut ma_engine, volume: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_volume(pEngine: *mut ma_engine) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_gain_db(pEngine: *mut ma_engine, gainDB: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_gain_db(pEngine: *mut ma_engine) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_listener_count(pEngine: *const ma_engine) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_find_closest_listener( ++ pEngine: *const ma_engine, ++ absolutePosX: f32, ++ absolutePosY: f32, ++ absolutePosZ: f32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_position( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_position( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_direction( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_direction( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_velocity( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_velocity( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_cone( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_cone( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_world_up( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_world_up( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_enabled( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ isEnabled: ma_bool32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_is_enabled( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_play_sound_ex( ++ pEngine: *mut ma_engine, ++ pFilePath: *const core::ffi::c_char, ++ pNode: *mut ma_node, ++ nodeInputBusIndex: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_play_sound( ++ pEngine: *mut ma_engine, ++ pFilePath: *const core::ffi::c_char, ++ pGroup: *mut ma_sound_group, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_from_file( ++ pEngine: *mut ma_engine, ++ pFilePath: *const core::ffi::c_char, ++ flags: ma_uint32, ++ pGroup: *mut ma_sound_group, ++ pDoneFence: *mut ma_fence, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_from_file_w( ++ pEngine: *mut ma_engine, ++ pFilePath: *const wchar_t, ++ flags: ma_uint32, ++ pGroup: *mut ma_sound_group, ++ pDoneFence: *mut ma_fence, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_copy( ++ pEngine: *mut ma_engine, ++ pExistingSound: *const ma_sound, ++ flags: ma_uint32, ++ pGroup: *mut ma_sound_group, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_from_data_source( ++ pEngine: *mut ma_engine, ++ pDataSource: *mut ma_data_source, ++ flags: ma_uint32, ++ pGroup: *mut ma_sound_group, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_ex( ++ pEngine: *mut ma_engine, ++ pConfig: *const ma_sound_config, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_uninit(pSound: *mut ma_sound); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_engine(pSound: *const ma_sound) -> *mut ma_engine; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_data_source(pSound: *const ma_sound) -> *mut ma_data_source; ++} ++unsafe extern "C" { ++ pub fn ma_sound_start(pSound: *mut ma_sound) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_stop(pSound: *mut ma_sound) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_stop_with_fade_in_pcm_frames( ++ pSound: *mut ma_sound, ++ fadeLengthInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_stop_with_fade_in_milliseconds( ++ pSound: *mut ma_sound, ++ fadeLengthInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_volume(pSound: *mut ma_sound, volume: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_volume(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_pan(pSound: *mut ma_sound, pan: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_pan(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_pan_mode(pSound: *mut ma_sound, panMode: ma_pan_mode); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_pan_mode(pSound: *const ma_sound) -> ma_pan_mode; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_pitch(pSound: *mut ma_sound, pitch: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_pitch(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_spatialization_enabled(pSound: *mut ma_sound, enabled: ma_bool32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_is_spatialization_enabled(pSound: *const ma_sound) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_pinned_listener_index(pSound: *mut ma_sound, listenerIndex: ma_uint32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_pinned_listener_index(pSound: *const ma_sound) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_listener_index(pSound: *const ma_sound) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_direction_to_listener(pSound: *const ma_sound) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_position(pSound: *mut ma_sound, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_position(pSound: *const ma_sound) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_direction(pSound: *mut ma_sound, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_direction(pSound: *const ma_sound) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_velocity(pSound: *mut ma_sound, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_velocity(pSound: *const ma_sound) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_attenuation_model( ++ pSound: *mut ma_sound, ++ attenuationModel: ma_attenuation_model, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_attenuation_model(pSound: *const ma_sound) -> ma_attenuation_model; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_positioning(pSound: *mut ma_sound, positioning: ma_positioning); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_positioning(pSound: *const ma_sound) -> ma_positioning; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_rolloff(pSound: *mut ma_sound, rolloff: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_rolloff(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_min_gain(pSound: *mut ma_sound, minGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_min_gain(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_max_gain(pSound: *mut ma_sound, maxGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_max_gain(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_min_distance(pSound: *mut ma_sound, minDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_min_distance(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_max_distance(pSound: *mut ma_sound, maxDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_max_distance(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_cone( ++ pSound: *mut ma_sound, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_cone( ++ pSound: *const ma_sound, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_doppler_factor(pSound: *mut ma_sound, dopplerFactor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_doppler_factor(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_directional_attenuation_factor( ++ pSound: *mut ma_sound, ++ directionalAttenuationFactor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_directional_attenuation_factor(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_fade_in_pcm_frames( ++ pSound: *mut ma_sound, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_fade_in_milliseconds( ++ pSound: *mut ma_sound, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_fade_start_in_pcm_frames( ++ pSound: *mut ma_sound, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInFrames: ma_uint64, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_fade_start_in_milliseconds( ++ pSound: *mut ma_sound, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInMilliseconds: ma_uint64, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_current_fade_volume(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_start_time_in_pcm_frames( ++ pSound: *mut ma_sound, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_start_time_in_milliseconds( ++ pSound: *mut ma_sound, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_stop_time_in_pcm_frames( ++ pSound: *mut ma_sound, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_stop_time_in_milliseconds( ++ pSound: *mut ma_sound, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_stop_time_with_fade_in_pcm_frames( ++ pSound: *mut ma_sound, ++ stopAbsoluteGlobalTimeInFrames: ma_uint64, ++ fadeLengthInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_stop_time_with_fade_in_milliseconds( ++ pSound: *mut ma_sound, ++ stopAbsoluteGlobalTimeInMilliseconds: ma_uint64, ++ fadeLengthInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_is_playing(pSound: *const ma_sound) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_time_in_pcm_frames(pSound: *const ma_sound) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_time_in_milliseconds(pSound: *const ma_sound) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_looping(pSound: *mut ma_sound, isLooping: ma_bool32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_is_looping(pSound: *const ma_sound) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_at_end(pSound: *const ma_sound) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_seek_to_pcm_frame(pSound: *mut ma_sound, frameIndex: ma_uint64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_seek_to_second(pSound: *mut ma_sound, seekPointInSeconds: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_data_format( ++ pSound: *const ma_sound, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_cursor_in_pcm_frames( ++ pSound: *const ma_sound, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_length_in_pcm_frames( ++ pSound: *const ma_sound, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_cursor_in_seconds(pSound: *const ma_sound, pCursor: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_length_in_seconds(pSound: *const ma_sound, pLength: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_end_callback( ++ pSound: *mut ma_sound, ++ callback: ma_sound_end_proc, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_init( ++ pEngine: *mut ma_engine, ++ flags: ma_uint32, ++ pParentGroup: *mut ma_sound_group, ++ pGroup: *mut ma_sound_group, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_init_ex( ++ pEngine: *mut ma_engine, ++ pConfig: *const ma_sound_group_config, ++ pGroup: *mut ma_sound_group, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_uninit(pGroup: *mut ma_sound_group); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_engine(pGroup: *const ma_sound_group) -> *mut ma_engine; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_start(pGroup: *mut ma_sound_group) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_stop(pGroup: *mut ma_sound_group) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_volume(pGroup: *mut ma_sound_group, volume: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_volume(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_pan(pGroup: *mut ma_sound_group, pan: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_pan(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_pan_mode(pGroup: *mut ma_sound_group, panMode: ma_pan_mode); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_pan_mode(pGroup: *const ma_sound_group) -> ma_pan_mode; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_pitch(pGroup: *mut ma_sound_group, pitch: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_pitch(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_spatialization_enabled( ++ pGroup: *mut ma_sound_group, ++ enabled: ma_bool32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_is_spatialization_enabled(pGroup: *const ma_sound_group) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_pinned_listener_index( ++ pGroup: *mut ma_sound_group, ++ listenerIndex: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_pinned_listener_index(pGroup: *const ma_sound_group) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_listener_index(pGroup: *const ma_sound_group) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_direction_to_listener(pGroup: *const ma_sound_group) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_position(pGroup: *mut ma_sound_group, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_position(pGroup: *const ma_sound_group) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_direction(pGroup: *mut ma_sound_group, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_direction(pGroup: *const ma_sound_group) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_velocity(pGroup: *mut ma_sound_group, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_velocity(pGroup: *const ma_sound_group) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_attenuation_model( ++ pGroup: *mut ma_sound_group, ++ attenuationModel: ma_attenuation_model, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_attenuation_model( ++ pGroup: *const ma_sound_group, ++ ) -> ma_attenuation_model; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_positioning(pGroup: *mut ma_sound_group, positioning: ma_positioning); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_positioning(pGroup: *const ma_sound_group) -> ma_positioning; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_rolloff(pGroup: *mut ma_sound_group, rolloff: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_rolloff(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_min_gain(pGroup: *mut ma_sound_group, minGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_min_gain(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_max_gain(pGroup: *mut ma_sound_group, maxGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_max_gain(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_min_distance(pGroup: *mut ma_sound_group, minDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_min_distance(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_max_distance(pGroup: *mut ma_sound_group, maxDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_max_distance(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_cone( ++ pGroup: *mut ma_sound_group, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_cone( ++ pGroup: *const ma_sound_group, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_doppler_factor(pGroup: *mut ma_sound_group, dopplerFactor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_doppler_factor(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_directional_attenuation_factor( ++ pGroup: *mut ma_sound_group, ++ directionalAttenuationFactor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_directional_attenuation_factor(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_fade_in_pcm_frames( ++ pGroup: *mut ma_sound_group, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_fade_in_milliseconds( ++ pGroup: *mut ma_sound_group, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_current_fade_volume(pGroup: *mut ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_start_time_in_pcm_frames( ++ pGroup: *mut ma_sound_group, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_start_time_in_milliseconds( ++ pGroup: *mut ma_sound_group, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_stop_time_in_pcm_frames( ++ pGroup: *mut ma_sound_group, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_stop_time_in_milliseconds( ++ pGroup: *mut ma_sound_group, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_is_playing(pGroup: *const ma_sound_group) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_time_in_pcm_frames(pGroup: *const ma_sound_group) -> ma_uint64; ++} +diff --git a/src/pregen_bindings/linux-x86_64-musl.rs b/src/pregen_bindings/linux-x86_64-musl.rs +new file mode 100644 +index 0000000000000000000000000000000000000000..3d05bd8a08525d12c1dfb8d31dabef3f7e4e4013 +--- /dev/null ++++ b/src/pregen_bindings/linux-x86_64-musl.rs +@@ -0,0 +1,14115 @@ ++/* automatically generated by rust-bindgen 0.72.1 */ ++ ++pub const MA_VERSION_MAJOR: u32 = 0; ++pub const MA_VERSION_MINOR: u32 = 11; ++pub const MA_VERSION_REVISION: u32 = 23; ++pub const MA_SIZEOF_PTR: u32 = 8; ++pub const MA_TRUE: u32 = 1; ++pub const MA_FALSE: u32 = 0; ++pub const MA_SIZE_MAX: u32 = 4294967295; ++pub const _BSD_SOURCE: u32 = 1; ++pub const _XOPEN_SOURCE: u32 = 700; ++pub const __BYTE_ORDER: u32 = 1234; ++pub const __LONG_MAX: u64 = 9223372036854775807; ++pub const __LITTLE_ENDIAN: u32 = 1234; ++pub const __BIG_ENDIAN: u32 = 4321; ++pub const __USE_TIME_BITS64: u32 = 1; ++pub const SCHED_OTHER: u32 = 0; ++pub const SCHED_FIFO: u32 = 1; ++pub const SCHED_RR: u32 = 2; ++pub const SCHED_BATCH: u32 = 3; ++pub const SCHED_IDLE: u32 = 5; ++pub const SCHED_DEADLINE: u32 = 6; ++pub const SCHED_RESET_ON_FORK: u32 = 1073741824; ++pub const CLOCKS_PER_SEC: u32 = 1000000; ++pub const TIME_UTC: u32 = 1; ++pub const CLOCK_REALTIME: u32 = 0; ++pub const CLOCK_MONOTONIC: u32 = 1; ++pub const CLOCK_PROCESS_CPUTIME_ID: u32 = 2; ++pub const CLOCK_THREAD_CPUTIME_ID: u32 = 3; ++pub const CLOCK_MONOTONIC_RAW: u32 = 4; ++pub const CLOCK_REALTIME_COARSE: u32 = 5; ++pub const CLOCK_MONOTONIC_COARSE: u32 = 6; ++pub const CLOCK_BOOTTIME: u32 = 7; ++pub const CLOCK_REALTIME_ALARM: u32 = 8; ++pub const CLOCK_BOOTTIME_ALARM: u32 = 9; ++pub const CLOCK_SGI_CYCLE: u32 = 10; ++pub const CLOCK_TAI: u32 = 11; ++pub const TIMER_ABSTIME: u32 = 1; ++pub const PTHREAD_CREATE_JOINABLE: u32 = 0; ++pub const PTHREAD_CREATE_DETACHED: u32 = 1; ++pub const PTHREAD_MUTEX_NORMAL: u32 = 0; ++pub const PTHREAD_MUTEX_DEFAULT: u32 = 0; ++pub const PTHREAD_MUTEX_RECURSIVE: u32 = 1; ++pub const PTHREAD_MUTEX_ERRORCHECK: u32 = 2; ++pub const PTHREAD_MUTEX_STALLED: u32 = 0; ++pub const PTHREAD_MUTEX_ROBUST: u32 = 1; ++pub const PTHREAD_PRIO_NONE: u32 = 0; ++pub const PTHREAD_PRIO_INHERIT: u32 = 1; ++pub const PTHREAD_PRIO_PROTECT: u32 = 2; ++pub const PTHREAD_INHERIT_SCHED: u32 = 0; ++pub const PTHREAD_EXPLICIT_SCHED: u32 = 1; ++pub const PTHREAD_SCOPE_SYSTEM: u32 = 0; ++pub const PTHREAD_SCOPE_PROCESS: u32 = 1; ++pub const PTHREAD_PROCESS_PRIVATE: u32 = 0; ++pub const PTHREAD_PROCESS_SHARED: u32 = 1; ++pub const PTHREAD_ONCE_INIT: u32 = 0; ++pub const PTHREAD_CANCEL_ENABLE: u32 = 0; ++pub const PTHREAD_CANCEL_DISABLE: u32 = 1; ++pub const PTHREAD_CANCEL_MASKED: u32 = 2; ++pub const PTHREAD_CANCEL_DEFERRED: u32 = 0; ++pub const PTHREAD_CANCEL_ASYNCHRONOUS: u32 = 1; ++pub const PTHREAD_BARRIER_SERIAL_THREAD: i32 = -1; ++pub const MA_SIMD_ALIGNMENT: u32 = 32; ++pub const __alignas_is_defined: u32 = 1; ++pub const __alignof_is_defined: u32 = 1; ++pub const MA_MIN_CHANNELS: u32 = 1; ++pub const MA_MAX_CHANNELS: u32 = 254; ++pub const MA_MAX_FILTER_ORDER: u32 = 8; ++pub const MA_MAX_LOG_CALLBACKS: u32 = 4; ++pub const MA_CHANNEL_INDEX_NULL: u32 = 255; ++pub const MA_DATA_SOURCE_SELF_MANAGED_RANGE_AND_LOOP_POINT: u32 = 1; ++pub const MA_DATA_FORMAT_FLAG_EXCLUSIVE_MODE: u32 = 2; ++pub const MA_MAX_DEVICE_NAME_LENGTH: u32 = 255; ++pub const MA_RESOURCE_MANAGER_MAX_JOB_THREAD_COUNT: u32 = 64; ++pub const MA_MAX_NODE_BUS_COUNT: u32 = 254; ++pub const MA_MAX_NODE_LOCAL_BUS_COUNT: u32 = 2; ++pub const MA_NODE_BUS_COUNT_UNKNOWN: u32 = 255; ++pub const MA_ENGINE_MAX_LISTENERS: u32 = 4; ++pub const MA_SOUND_SOURCE_CHANNEL_COUNT: u32 = 4294967295; ++pub type wchar_t = core::ffi::c_int; ++#[repr(C)] ++#[repr(align(16))] ++#[derive(Debug, Copy, Clone)] ++pub struct max_align_t { ++ pub __clang_max_align_nonce1: core::ffi::c_longlong, ++ pub __bindgen_padding_0: u64, ++ pub __clang_max_align_nonce2: u128, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of max_align_t"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of max_align_t"][::core::mem::align_of::() - 16usize]; ++ ["Offset of field: max_align_t::__clang_max_align_nonce1"] ++ [::core::mem::offset_of!(max_align_t, __clang_max_align_nonce1) - 0usize]; ++ ["Offset of field: max_align_t::__clang_max_align_nonce2"] ++ [::core::mem::offset_of!(max_align_t, __clang_max_align_nonce2) - 16usize]; ++}; ++pub type ma_int8 = core::ffi::c_schar; ++pub type ma_uint8 = core::ffi::c_uchar; ++pub type ma_int16 = core::ffi::c_short; ++pub type ma_uint16 = core::ffi::c_ushort; ++pub type ma_int32 = core::ffi::c_int; ++pub type ma_uint32 = core::ffi::c_uint; ++pub type ma_int64 = core::ffi::c_longlong; ++pub type ma_uint64 = core::ffi::c_ulonglong; ++pub type ma_uintptr = ma_uint64; ++pub type ma_bool8 = ma_uint8; ++pub type ma_bool32 = ma_uint32; ++pub type ma_float = f32; ++pub type ma_double = f64; ++pub type ma_handle = *mut core::ffi::c_void; ++pub type ma_ptr = *mut core::ffi::c_void; ++pub type ma_proc = ::core::option::Option; ++pub type time_t = core::ffi::c_long; ++pub type clockid_t = core::ffi::c_int; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct timespec { ++ pub tv_sec: time_t, ++ pub tv_nsec: core::ffi::c_long, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of timespec"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of timespec"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: timespec::tv_sec"][::core::mem::offset_of!(timespec, tv_sec) - 0usize]; ++ ["Offset of field: timespec::tv_nsec"][::core::mem::offset_of!(timespec, tv_nsec) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __pthread { ++ _unused: [u8; 0], ++} ++pub type pthread_t = *mut __pthread; ++pub type pthread_once_t = core::ffi::c_int; ++pub type pthread_key_t = core::ffi::c_uint; ++pub type pthread_spinlock_t = core::ffi::c_int; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_mutexattr_t { ++ pub __attr: core::ffi::c_uint, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_mutexattr_t"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of pthread_mutexattr_t"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: pthread_mutexattr_t::__attr"] ++ [::core::mem::offset_of!(pthread_mutexattr_t, __attr) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_condattr_t { ++ pub __attr: core::ffi::c_uint, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_condattr_t"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of pthread_condattr_t"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: pthread_condattr_t::__attr"] ++ [::core::mem::offset_of!(pthread_condattr_t, __attr) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_barrierattr_t { ++ pub __attr: core::ffi::c_uint, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_barrierattr_t"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of pthread_barrierattr_t"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: pthread_barrierattr_t::__attr"] ++ [::core::mem::offset_of!(pthread_barrierattr_t, __attr) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct pthread_rwlockattr_t { ++ pub __attr: [core::ffi::c_uint; 2usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_rwlockattr_t"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of pthread_rwlockattr_t"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: pthread_rwlockattr_t::__attr"] ++ [::core::mem::offset_of!(pthread_rwlockattr_t, __attr) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __sigset_t { ++ pub __bits: [core::ffi::c_ulong; 16usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __sigset_t"][::core::mem::size_of::<__sigset_t>() - 128usize]; ++ ["Alignment of __sigset_t"][::core::mem::align_of::<__sigset_t>() - 8usize]; ++ ["Offset of field: __sigset_t::__bits"][::core::mem::offset_of!(__sigset_t, __bits) - 0usize]; ++}; ++pub type sigset_t = __sigset_t; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct pthread_attr_t { ++ pub __u: pthread_attr_t__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_attr_t__bindgen_ty_1 { ++ pub __i: [core::ffi::c_int; 14usize], ++ pub __vi: [core::ffi::c_int; 14usize], ++ pub __s: [core::ffi::c_ulong; 7usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_attr_t__bindgen_ty_1"] ++ [::core::mem::size_of::() - 56usize]; ++ ["Alignment of pthread_attr_t__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_attr_t__bindgen_ty_1::__i"] ++ [::core::mem::offset_of!(pthread_attr_t__bindgen_ty_1, __i) - 0usize]; ++ ["Offset of field: pthread_attr_t__bindgen_ty_1::__vi"] ++ [::core::mem::offset_of!(pthread_attr_t__bindgen_ty_1, __vi) - 0usize]; ++ ["Offset of field: pthread_attr_t__bindgen_ty_1::__s"] ++ [::core::mem::offset_of!(pthread_attr_t__bindgen_ty_1, __s) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_attr_t"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of pthread_attr_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_attr_t::__u"][::core::mem::offset_of!(pthread_attr_t, __u) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct pthread_mutex_t { ++ pub __u: pthread_mutex_t__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_mutex_t__bindgen_ty_1 { ++ pub __i: [core::ffi::c_int; 10usize], ++ pub __vi: [core::ffi::c_int; 10usize], ++ pub __p: [*mut core::ffi::c_void; 5usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_mutex_t__bindgen_ty_1"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of pthread_mutex_t__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_mutex_t__bindgen_ty_1::__i"] ++ [::core::mem::offset_of!(pthread_mutex_t__bindgen_ty_1, __i) - 0usize]; ++ ["Offset of field: pthread_mutex_t__bindgen_ty_1::__vi"] ++ [::core::mem::offset_of!(pthread_mutex_t__bindgen_ty_1, __vi) - 0usize]; ++ ["Offset of field: pthread_mutex_t__bindgen_ty_1::__p"] ++ [::core::mem::offset_of!(pthread_mutex_t__bindgen_ty_1, __p) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_mutex_t"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of pthread_mutex_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_mutex_t::__u"] ++ [::core::mem::offset_of!(pthread_mutex_t, __u) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct pthread_cond_t { ++ pub __u: pthread_cond_t__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_cond_t__bindgen_ty_1 { ++ pub __i: [core::ffi::c_int; 12usize], ++ pub __vi: [core::ffi::c_int; 12usize], ++ pub __p: [*mut core::ffi::c_void; 6usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_cond_t__bindgen_ty_1"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of pthread_cond_t__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_cond_t__bindgen_ty_1::__i"] ++ [::core::mem::offset_of!(pthread_cond_t__bindgen_ty_1, __i) - 0usize]; ++ ["Offset of field: pthread_cond_t__bindgen_ty_1::__vi"] ++ [::core::mem::offset_of!(pthread_cond_t__bindgen_ty_1, __vi) - 0usize]; ++ ["Offset of field: pthread_cond_t__bindgen_ty_1::__p"] ++ [::core::mem::offset_of!(pthread_cond_t__bindgen_ty_1, __p) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_cond_t"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of pthread_cond_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_cond_t::__u"][::core::mem::offset_of!(pthread_cond_t, __u) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct pthread_rwlock_t { ++ pub __u: pthread_rwlock_t__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_rwlock_t__bindgen_ty_1 { ++ pub __i: [core::ffi::c_int; 14usize], ++ pub __vi: [core::ffi::c_int; 14usize], ++ pub __p: [*mut core::ffi::c_void; 7usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_rwlock_t__bindgen_ty_1"] ++ [::core::mem::size_of::() - 56usize]; ++ ["Alignment of pthread_rwlock_t__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_rwlock_t__bindgen_ty_1::__i"] ++ [::core::mem::offset_of!(pthread_rwlock_t__bindgen_ty_1, __i) - 0usize]; ++ ["Offset of field: pthread_rwlock_t__bindgen_ty_1::__vi"] ++ [::core::mem::offset_of!(pthread_rwlock_t__bindgen_ty_1, __vi) - 0usize]; ++ ["Offset of field: pthread_rwlock_t__bindgen_ty_1::__p"] ++ [::core::mem::offset_of!(pthread_rwlock_t__bindgen_ty_1, __p) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_rwlock_t"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of pthread_rwlock_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_rwlock_t::__u"] ++ [::core::mem::offset_of!(pthread_rwlock_t, __u) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct pthread_barrier_t { ++ pub __u: pthread_barrier_t__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union pthread_barrier_t__bindgen_ty_1 { ++ pub __i: [core::ffi::c_int; 8usize], ++ pub __vi: [core::ffi::c_int; 8usize], ++ pub __p: [*mut core::ffi::c_void; 4usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_barrier_t__bindgen_ty_1"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of pthread_barrier_t__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_barrier_t__bindgen_ty_1::__i"] ++ [::core::mem::offset_of!(pthread_barrier_t__bindgen_ty_1, __i) - 0usize]; ++ ["Offset of field: pthread_barrier_t__bindgen_ty_1::__vi"] ++ [::core::mem::offset_of!(pthread_barrier_t__bindgen_ty_1, __vi) - 0usize]; ++ ["Offset of field: pthread_barrier_t__bindgen_ty_1::__p"] ++ [::core::mem::offset_of!(pthread_barrier_t__bindgen_ty_1, __p) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of pthread_barrier_t"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of pthread_barrier_t"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: pthread_barrier_t::__u"] ++ [::core::mem::offset_of!(pthread_barrier_t, __u) - 0usize]; ++}; ++pub type pid_t = core::ffi::c_int; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sched_param { ++ pub sched_priority: core::ffi::c_int, ++ pub __reserved1: core::ffi::c_int, ++ pub __reserved2: [sched_param__bindgen_ty_1; 2usize], ++ pub __reserved3: core::ffi::c_int, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sched_param__bindgen_ty_1 { ++ pub __reserved1: time_t, ++ pub __reserved2: core::ffi::c_long, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sched_param__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of sched_param__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: sched_param__bindgen_ty_1::__reserved1"] ++ [::core::mem::offset_of!(sched_param__bindgen_ty_1, __reserved1) - 0usize]; ++ ["Offset of field: sched_param__bindgen_ty_1::__reserved2"] ++ [::core::mem::offset_of!(sched_param__bindgen_ty_1, __reserved2) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of sched_param"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of sched_param"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: sched_param::sched_priority"] ++ [::core::mem::offset_of!(sched_param, sched_priority) - 0usize]; ++ ["Offset of field: sched_param::__reserved1"] ++ [::core::mem::offset_of!(sched_param, __reserved1) - 4usize]; ++ ["Offset of field: sched_param::__reserved2"] ++ [::core::mem::offset_of!(sched_param, __reserved2) - 8usize]; ++ ["Offset of field: sched_param::__reserved3"] ++ [::core::mem::offset_of!(sched_param, __reserved3) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn sched_get_priority_max(arg1: core::ffi::c_int) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_get_priority_min(arg1: core::ffi::c_int) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_getparam(arg1: pid_t, arg2: *mut sched_param) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_getscheduler(arg1: pid_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_rr_get_interval(arg1: pid_t, arg2: *mut timespec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_setparam(arg1: pid_t, arg2: *const sched_param) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_setscheduler( ++ arg1: pid_t, ++ arg2: core::ffi::c_int, ++ arg3: *const sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn sched_yield() -> core::ffi::c_int; ++} ++pub type timer_t = *mut core::ffi::c_void; ++pub type clock_t = core::ffi::c_long; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __locale_struct { ++ _unused: [u8; 0], ++} ++pub type locale_t = *mut __locale_struct; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct tm { ++ pub tm_sec: core::ffi::c_int, ++ pub tm_min: core::ffi::c_int, ++ pub tm_hour: core::ffi::c_int, ++ pub tm_mday: core::ffi::c_int, ++ pub tm_mon: core::ffi::c_int, ++ pub tm_year: core::ffi::c_int, ++ pub tm_wday: core::ffi::c_int, ++ pub tm_yday: core::ffi::c_int, ++ pub tm_isdst: core::ffi::c_int, ++ pub tm_gmtoff: core::ffi::c_long, ++ pub tm_zone: *const core::ffi::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of tm"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of tm"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: tm::tm_sec"][::core::mem::offset_of!(tm, tm_sec) - 0usize]; ++ ["Offset of field: tm::tm_min"][::core::mem::offset_of!(tm, tm_min) - 4usize]; ++ ["Offset of field: tm::tm_hour"][::core::mem::offset_of!(tm, tm_hour) - 8usize]; ++ ["Offset of field: tm::tm_mday"][::core::mem::offset_of!(tm, tm_mday) - 12usize]; ++ ["Offset of field: tm::tm_mon"][::core::mem::offset_of!(tm, tm_mon) - 16usize]; ++ ["Offset of field: tm::tm_year"][::core::mem::offset_of!(tm, tm_year) - 20usize]; ++ ["Offset of field: tm::tm_wday"][::core::mem::offset_of!(tm, tm_wday) - 24usize]; ++ ["Offset of field: tm::tm_yday"][::core::mem::offset_of!(tm, tm_yday) - 28usize]; ++ ["Offset of field: tm::tm_isdst"][::core::mem::offset_of!(tm, tm_isdst) - 32usize]; ++ ["Offset of field: tm::tm_gmtoff"][::core::mem::offset_of!(tm, tm_gmtoff) - 40usize]; ++ ["Offset of field: tm::tm_zone"][::core::mem::offset_of!(tm, tm_zone) - 48usize]; ++}; ++unsafe extern "C" { ++ pub fn clock() -> clock_t; ++} ++unsafe extern "C" { ++ pub fn time(arg1: *mut time_t) -> time_t; ++} ++unsafe extern "C" { ++ pub fn difftime(arg1: time_t, arg2: time_t) -> f64; ++} ++unsafe extern "C" { ++ pub fn mktime(arg1: *mut tm) -> time_t; ++} ++unsafe extern "C" { ++ pub fn strftime( ++ arg1: *mut core::ffi::c_char, ++ arg2: usize, ++ arg3: *const core::ffi::c_char, ++ arg4: *const tm, ++ ) -> usize; ++} ++unsafe extern "C" { ++ pub fn gmtime(arg1: *const time_t) -> *mut tm; ++} ++unsafe extern "C" { ++ pub fn localtime(arg1: *const time_t) -> *mut tm; ++} ++unsafe extern "C" { ++ pub fn asctime(arg1: *const tm) -> *mut core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ctime(arg1: *const time_t) -> *mut core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn timespec_get(arg1: *mut timespec, arg2: core::ffi::c_int) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn strftime_l( ++ arg1: *mut core::ffi::c_char, ++ arg2: usize, ++ arg3: *const core::ffi::c_char, ++ arg4: *const tm, ++ arg5: locale_t, ++ ) -> usize; ++} ++unsafe extern "C" { ++ pub fn gmtime_r(arg1: *const time_t, arg2: *mut tm) -> *mut tm; ++} ++unsafe extern "C" { ++ pub fn localtime_r(arg1: *const time_t, arg2: *mut tm) -> *mut tm; ++} ++unsafe extern "C" { ++ pub fn asctime_r(arg1: *const tm, arg2: *mut core::ffi::c_char) -> *mut core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ctime_r(arg1: *const time_t, arg2: *mut core::ffi::c_char) -> *mut core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn tzset(); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct itimerspec { ++ pub it_interval: timespec, ++ pub it_value: timespec, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of itimerspec"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of itimerspec"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: itimerspec::it_interval"] ++ [::core::mem::offset_of!(itimerspec, it_interval) - 0usize]; ++ ["Offset of field: itimerspec::it_value"] ++ [::core::mem::offset_of!(itimerspec, it_value) - 16usize]; ++}; ++unsafe extern "C" { ++ pub fn nanosleep(arg1: *const timespec, arg2: *mut timespec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_getres(arg1: clockid_t, arg2: *mut timespec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_gettime(arg1: clockid_t, arg2: *mut timespec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_settime(arg1: clockid_t, arg2: *const timespec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_nanosleep( ++ arg1: clockid_t, ++ arg2: core::ffi::c_int, ++ arg3: *const timespec, ++ arg4: *mut timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn clock_getcpuclockid(arg1: pid_t, arg2: *mut clockid_t) -> core::ffi::c_int; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct sigevent { ++ _unused: [u8; 0], ++} ++unsafe extern "C" { ++ pub fn timer_create( ++ arg1: clockid_t, ++ arg2: *mut sigevent, ++ arg3: *mut timer_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timer_delete(arg1: timer_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timer_settime( ++ arg1: timer_t, ++ arg2: core::ffi::c_int, ++ arg3: *const itimerspec, ++ arg4: *mut itimerspec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timer_gettime(arg1: timer_t, arg2: *mut itimerspec) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timer_getoverrun(arg1: timer_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub static mut tzname: [*mut core::ffi::c_char; 2usize]; ++} ++unsafe extern "C" { ++ pub fn strptime( ++ arg1: *const core::ffi::c_char, ++ arg2: *const core::ffi::c_char, ++ arg3: *mut tm, ++ ) -> *mut core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub static mut daylight: core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub static mut timezone: core::ffi::c_long; ++} ++unsafe extern "C" { ++ pub static mut getdate_err: core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn getdate(arg1: *const core::ffi::c_char) -> *mut tm; ++} ++unsafe extern "C" { ++ pub fn stime(arg1: *const time_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn timegm(arg1: *mut tm) -> time_t; ++} ++unsafe extern "C" { ++ pub fn pthread_create( ++ arg1: *mut pthread_t, ++ arg2: *const pthread_attr_t, ++ arg3: ::core::option::Option< ++ unsafe extern "C" fn(arg1: *mut core::ffi::c_void) -> *mut core::ffi::c_void, ++ >, ++ arg4: *mut core::ffi::c_void, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_detach(arg1: pthread_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_exit(arg1: *mut core::ffi::c_void); ++} ++unsafe extern "C" { ++ pub fn pthread_join(arg1: pthread_t, arg2: *mut *mut core::ffi::c_void) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_self() -> pthread_t; ++} ++unsafe extern "C" { ++ pub fn pthread_equal(arg1: pthread_t, arg2: pthread_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_setcancelstate( ++ arg1: core::ffi::c_int, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_setcanceltype( ++ arg1: core::ffi::c_int, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_testcancel(); ++} ++unsafe extern "C" { ++ pub fn pthread_cancel(arg1: pthread_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_getschedparam( ++ arg1: pthread_t, ++ arg2: *mut core::ffi::c_int, ++ arg3: *mut sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_setschedparam( ++ arg1: pthread_t, ++ arg2: core::ffi::c_int, ++ arg3: *const sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_setschedprio(arg1: pthread_t, arg2: core::ffi::c_int) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_once( ++ arg1: *mut pthread_once_t, ++ arg2: ::core::option::Option, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_init( ++ arg1: *mut pthread_mutex_t, ++ arg2: *const pthread_mutexattr_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_lock(arg1: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_unlock(arg1: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_trylock(arg1: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_timedlock( ++ arg1: *mut pthread_mutex_t, ++ arg2: *const timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_destroy(arg1: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_consistent(arg1: *mut pthread_mutex_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_getprioceiling( ++ arg1: *const pthread_mutex_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutex_setprioceiling( ++ arg1: *mut pthread_mutex_t, ++ arg2: core::ffi::c_int, ++ arg3: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_init( ++ arg1: *mut pthread_cond_t, ++ arg2: *const pthread_condattr_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_destroy(arg1: *mut pthread_cond_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_wait( ++ arg1: *mut pthread_cond_t, ++ arg2: *mut pthread_mutex_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_timedwait( ++ arg1: *mut pthread_cond_t, ++ arg2: *mut pthread_mutex_t, ++ arg3: *const timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_broadcast(arg1: *mut pthread_cond_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_cond_signal(arg1: *mut pthread_cond_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_init( ++ arg1: *mut pthread_rwlock_t, ++ arg2: *const pthread_rwlockattr_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_destroy(arg1: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_rdlock(arg1: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_tryrdlock(arg1: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_timedrdlock( ++ arg1: *mut pthread_rwlock_t, ++ arg2: *const timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_wrlock(arg1: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_trywrlock(arg1: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_timedwrlock( ++ arg1: *mut pthread_rwlock_t, ++ arg2: *const timespec, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlock_unlock(arg1: *mut pthread_rwlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_init( ++ arg1: *mut pthread_spinlock_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_destroy(arg1: *mut pthread_spinlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_lock(arg1: *mut pthread_spinlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_trylock(arg1: *mut pthread_spinlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_spin_unlock(arg1: *mut pthread_spinlock_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrier_init( ++ arg1: *mut pthread_barrier_t, ++ arg2: *const pthread_barrierattr_t, ++ arg3: core::ffi::c_uint, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrier_destroy(arg1: *mut pthread_barrier_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrier_wait(arg1: *mut pthread_barrier_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_key_create( ++ arg1: *mut pthread_key_t, ++ arg2: ::core::option::Option, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_key_delete(arg1: pthread_key_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_getspecific(arg1: pthread_key_t) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn pthread_setspecific( ++ arg1: pthread_key_t, ++ arg2: *const core::ffi::c_void, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_init(arg1: *mut pthread_attr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_destroy(arg1: *mut pthread_attr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getguardsize( ++ arg1: *const pthread_attr_t, ++ arg2: *mut usize, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setguardsize(arg1: *mut pthread_attr_t, arg2: usize) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getstacksize( ++ arg1: *const pthread_attr_t, ++ arg2: *mut usize, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setstacksize(arg1: *mut pthread_attr_t, arg2: usize) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getdetachstate( ++ arg1: *const pthread_attr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setdetachstate( ++ arg1: *mut pthread_attr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getstack( ++ arg1: *const pthread_attr_t, ++ arg2: *mut *mut core::ffi::c_void, ++ arg3: *mut usize, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setstack( ++ arg1: *mut pthread_attr_t, ++ arg2: *mut core::ffi::c_void, ++ arg3: usize, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getscope( ++ arg1: *const pthread_attr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setscope( ++ arg1: *mut pthread_attr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getschedpolicy( ++ arg1: *const pthread_attr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setschedpolicy( ++ arg1: *mut pthread_attr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getschedparam( ++ arg1: *const pthread_attr_t, ++ arg2: *mut sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setschedparam( ++ arg1: *mut pthread_attr_t, ++ arg2: *const sched_param, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_getinheritsched( ++ arg1: *const pthread_attr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_attr_setinheritsched( ++ arg1: *mut pthread_attr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_destroy(arg1: *mut pthread_mutexattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_getprioceiling( ++ arg1: *const pthread_mutexattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_getprotocol( ++ arg1: *const pthread_mutexattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_getpshared( ++ arg1: *const pthread_mutexattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_getrobust( ++ arg1: *const pthread_mutexattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_gettype( ++ arg1: *const pthread_mutexattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_init(arg1: *mut pthread_mutexattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_setprioceiling( ++ arg1: *mut pthread_mutexattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_setprotocol( ++ arg1: *mut pthread_mutexattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_setpshared( ++ arg1: *mut pthread_mutexattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_setrobust( ++ arg1: *mut pthread_mutexattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_mutexattr_settype( ++ arg1: *mut pthread_mutexattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_init(arg1: *mut pthread_condattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_destroy(arg1: *mut pthread_condattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_setclock( ++ arg1: *mut pthread_condattr_t, ++ arg2: clockid_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_setpshared( ++ arg1: *mut pthread_condattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_getclock( ++ arg1: *const pthread_condattr_t, ++ arg2: *mut clockid_t, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_condattr_getpshared( ++ arg1: *const pthread_condattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlockattr_init(arg1: *mut pthread_rwlockattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlockattr_destroy(arg1: *mut pthread_rwlockattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlockattr_setpshared( ++ arg1: *mut pthread_rwlockattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_rwlockattr_getpshared( ++ arg1: *const pthread_rwlockattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrierattr_destroy(arg1: *mut pthread_barrierattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrierattr_getpshared( ++ arg1: *const pthread_barrierattr_t, ++ arg2: *mut core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrierattr_init(arg1: *mut pthread_barrierattr_t) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_barrierattr_setpshared( ++ arg1: *mut pthread_barrierattr_t, ++ arg2: core::ffi::c_int, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_atfork( ++ arg1: ::core::option::Option, ++ arg2: ::core::option::Option, ++ arg3: ::core::option::Option, ++ ) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_getconcurrency() -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_setconcurrency(arg1: core::ffi::c_int) -> core::ffi::c_int; ++} ++unsafe extern "C" { ++ pub fn pthread_getcpuclockid(arg1: pthread_t, arg2: *mut clockid_t) -> core::ffi::c_int; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __ptcb { ++ pub __f: ::core::option::Option, ++ pub __x: *mut core::ffi::c_void, ++ pub __next: *mut __ptcb, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __ptcb"][::core::mem::size_of::<__ptcb>() - 24usize]; ++ ["Alignment of __ptcb"][::core::mem::align_of::<__ptcb>() - 8usize]; ++ ["Offset of field: __ptcb::__f"][::core::mem::offset_of!(__ptcb, __f) - 0usize]; ++ ["Offset of field: __ptcb::__x"][::core::mem::offset_of!(__ptcb, __x) - 8usize]; ++ ["Offset of field: __ptcb::__next"][::core::mem::offset_of!(__ptcb, __next) - 16usize]; ++}; ++unsafe extern "C" { ++ pub fn _pthread_cleanup_push( ++ arg1: *mut __ptcb, ++ arg2: ::core::option::Option, ++ arg3: *mut core::ffi::c_void, ++ ); ++} ++unsafe extern "C" { ++ pub fn _pthread_cleanup_pop(arg1: *mut __ptcb, arg2: core::ffi::c_int); ++} ++pub type ma_pthread_t = pthread_t; ++pub type ma_pthread_mutex_t = pthread_mutex_t; ++pub type ma_pthread_cond_t = pthread_cond_t; ++pub type ma_wchar_win32 = ma_uint16; ++pub const ma_log_level_MA_LOG_LEVEL_DEBUG: ma_log_level = 4; ++pub const ma_log_level_MA_LOG_LEVEL_INFO: ma_log_level = 3; ++pub const ma_log_level_MA_LOG_LEVEL_WARNING: ma_log_level = 2; ++pub const ma_log_level_MA_LOG_LEVEL_ERROR: ma_log_level = 1; ++pub type ma_log_level = core::ffi::c_uint; ++pub type ma_channel = ma_uint8; ++pub const _ma_channel_position_MA_CHANNEL_NONE: _ma_channel_position = 0; ++pub const _ma_channel_position_MA_CHANNEL_MONO: _ma_channel_position = 1; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_LEFT: _ma_channel_position = 2; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_RIGHT: _ma_channel_position = 3; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_CENTER: _ma_channel_position = 4; ++pub const _ma_channel_position_MA_CHANNEL_LFE: _ma_channel_position = 5; ++pub const _ma_channel_position_MA_CHANNEL_BACK_LEFT: _ma_channel_position = 6; ++pub const _ma_channel_position_MA_CHANNEL_BACK_RIGHT: _ma_channel_position = 7; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_LEFT_CENTER: _ma_channel_position = 8; ++pub const _ma_channel_position_MA_CHANNEL_FRONT_RIGHT_CENTER: _ma_channel_position = 9; ++pub const _ma_channel_position_MA_CHANNEL_BACK_CENTER: _ma_channel_position = 10; ++pub const _ma_channel_position_MA_CHANNEL_SIDE_LEFT: _ma_channel_position = 11; ++pub const _ma_channel_position_MA_CHANNEL_SIDE_RIGHT: _ma_channel_position = 12; ++pub const _ma_channel_position_MA_CHANNEL_TOP_CENTER: _ma_channel_position = 13; ++pub const _ma_channel_position_MA_CHANNEL_TOP_FRONT_LEFT: _ma_channel_position = 14; ++pub const _ma_channel_position_MA_CHANNEL_TOP_FRONT_CENTER: _ma_channel_position = 15; ++pub const _ma_channel_position_MA_CHANNEL_TOP_FRONT_RIGHT: _ma_channel_position = 16; ++pub const _ma_channel_position_MA_CHANNEL_TOP_BACK_LEFT: _ma_channel_position = 17; ++pub const _ma_channel_position_MA_CHANNEL_TOP_BACK_CENTER: _ma_channel_position = 18; ++pub const _ma_channel_position_MA_CHANNEL_TOP_BACK_RIGHT: _ma_channel_position = 19; ++pub const _ma_channel_position_MA_CHANNEL_AUX_0: _ma_channel_position = 20; ++pub const _ma_channel_position_MA_CHANNEL_AUX_1: _ma_channel_position = 21; ++pub const _ma_channel_position_MA_CHANNEL_AUX_2: _ma_channel_position = 22; ++pub const _ma_channel_position_MA_CHANNEL_AUX_3: _ma_channel_position = 23; ++pub const _ma_channel_position_MA_CHANNEL_AUX_4: _ma_channel_position = 24; ++pub const _ma_channel_position_MA_CHANNEL_AUX_5: _ma_channel_position = 25; ++pub const _ma_channel_position_MA_CHANNEL_AUX_6: _ma_channel_position = 26; ++pub const _ma_channel_position_MA_CHANNEL_AUX_7: _ma_channel_position = 27; ++pub const _ma_channel_position_MA_CHANNEL_AUX_8: _ma_channel_position = 28; ++pub const _ma_channel_position_MA_CHANNEL_AUX_9: _ma_channel_position = 29; ++pub const _ma_channel_position_MA_CHANNEL_AUX_10: _ma_channel_position = 30; ++pub const _ma_channel_position_MA_CHANNEL_AUX_11: _ma_channel_position = 31; ++pub const _ma_channel_position_MA_CHANNEL_AUX_12: _ma_channel_position = 32; ++pub const _ma_channel_position_MA_CHANNEL_AUX_13: _ma_channel_position = 33; ++pub const _ma_channel_position_MA_CHANNEL_AUX_14: _ma_channel_position = 34; ++pub const _ma_channel_position_MA_CHANNEL_AUX_15: _ma_channel_position = 35; ++pub const _ma_channel_position_MA_CHANNEL_AUX_16: _ma_channel_position = 36; ++pub const _ma_channel_position_MA_CHANNEL_AUX_17: _ma_channel_position = 37; ++pub const _ma_channel_position_MA_CHANNEL_AUX_18: _ma_channel_position = 38; ++pub const _ma_channel_position_MA_CHANNEL_AUX_19: _ma_channel_position = 39; ++pub const _ma_channel_position_MA_CHANNEL_AUX_20: _ma_channel_position = 40; ++pub const _ma_channel_position_MA_CHANNEL_AUX_21: _ma_channel_position = 41; ++pub const _ma_channel_position_MA_CHANNEL_AUX_22: _ma_channel_position = 42; ++pub const _ma_channel_position_MA_CHANNEL_AUX_23: _ma_channel_position = 43; ++pub const _ma_channel_position_MA_CHANNEL_AUX_24: _ma_channel_position = 44; ++pub const _ma_channel_position_MA_CHANNEL_AUX_25: _ma_channel_position = 45; ++pub const _ma_channel_position_MA_CHANNEL_AUX_26: _ma_channel_position = 46; ++pub const _ma_channel_position_MA_CHANNEL_AUX_27: _ma_channel_position = 47; ++pub const _ma_channel_position_MA_CHANNEL_AUX_28: _ma_channel_position = 48; ++pub const _ma_channel_position_MA_CHANNEL_AUX_29: _ma_channel_position = 49; ++pub const _ma_channel_position_MA_CHANNEL_AUX_30: _ma_channel_position = 50; ++pub const _ma_channel_position_MA_CHANNEL_AUX_31: _ma_channel_position = 51; ++pub const _ma_channel_position_MA_CHANNEL_LEFT: _ma_channel_position = 2; ++pub const _ma_channel_position_MA_CHANNEL_RIGHT: _ma_channel_position = 3; ++pub const _ma_channel_position_MA_CHANNEL_POSITION_COUNT: _ma_channel_position = 52; ++pub type _ma_channel_position = core::ffi::c_uint; ++pub const ma_result_MA_SUCCESS: ma_result = 0; ++pub const ma_result_MA_ERROR: ma_result = -1; ++pub const ma_result_MA_INVALID_ARGS: ma_result = -2; ++pub const ma_result_MA_INVALID_OPERATION: ma_result = -3; ++pub const ma_result_MA_OUT_OF_MEMORY: ma_result = -4; ++pub const ma_result_MA_OUT_OF_RANGE: ma_result = -5; ++pub const ma_result_MA_ACCESS_DENIED: ma_result = -6; ++pub const ma_result_MA_DOES_NOT_EXIST: ma_result = -7; ++pub const ma_result_MA_ALREADY_EXISTS: ma_result = -8; ++pub const ma_result_MA_TOO_MANY_OPEN_FILES: ma_result = -9; ++pub const ma_result_MA_INVALID_FILE: ma_result = -10; ++pub const ma_result_MA_TOO_BIG: ma_result = -11; ++pub const ma_result_MA_PATH_TOO_LONG: ma_result = -12; ++pub const ma_result_MA_NAME_TOO_LONG: ma_result = -13; ++pub const ma_result_MA_NOT_DIRECTORY: ma_result = -14; ++pub const ma_result_MA_IS_DIRECTORY: ma_result = -15; ++pub const ma_result_MA_DIRECTORY_NOT_EMPTY: ma_result = -16; ++pub const ma_result_MA_AT_END: ma_result = -17; ++pub const ma_result_MA_NO_SPACE: ma_result = -18; ++pub const ma_result_MA_BUSY: ma_result = -19; ++pub const ma_result_MA_IO_ERROR: ma_result = -20; ++pub const ma_result_MA_INTERRUPT: ma_result = -21; ++pub const ma_result_MA_UNAVAILABLE: ma_result = -22; ++pub const ma_result_MA_ALREADY_IN_USE: ma_result = -23; ++pub const ma_result_MA_BAD_ADDRESS: ma_result = -24; ++pub const ma_result_MA_BAD_SEEK: ma_result = -25; ++pub const ma_result_MA_BAD_PIPE: ma_result = -26; ++pub const ma_result_MA_DEADLOCK: ma_result = -27; ++pub const ma_result_MA_TOO_MANY_LINKS: ma_result = -28; ++pub const ma_result_MA_NOT_IMPLEMENTED: ma_result = -29; ++pub const ma_result_MA_NO_MESSAGE: ma_result = -30; ++pub const ma_result_MA_BAD_MESSAGE: ma_result = -31; ++pub const ma_result_MA_NO_DATA_AVAILABLE: ma_result = -32; ++pub const ma_result_MA_INVALID_DATA: ma_result = -33; ++pub const ma_result_MA_TIMEOUT: ma_result = -34; ++pub const ma_result_MA_NO_NETWORK: ma_result = -35; ++pub const ma_result_MA_NOT_UNIQUE: ma_result = -36; ++pub const ma_result_MA_NOT_SOCKET: ma_result = -37; ++pub const ma_result_MA_NO_ADDRESS: ma_result = -38; ++pub const ma_result_MA_BAD_PROTOCOL: ma_result = -39; ++pub const ma_result_MA_PROTOCOL_UNAVAILABLE: ma_result = -40; ++pub const ma_result_MA_PROTOCOL_NOT_SUPPORTED: ma_result = -41; ++pub const ma_result_MA_PROTOCOL_FAMILY_NOT_SUPPORTED: ma_result = -42; ++pub const ma_result_MA_ADDRESS_FAMILY_NOT_SUPPORTED: ma_result = -43; ++pub const ma_result_MA_SOCKET_NOT_SUPPORTED: ma_result = -44; ++pub const ma_result_MA_CONNECTION_RESET: ma_result = -45; ++pub const ma_result_MA_ALREADY_CONNECTED: ma_result = -46; ++pub const ma_result_MA_NOT_CONNECTED: ma_result = -47; ++pub const ma_result_MA_CONNECTION_REFUSED: ma_result = -48; ++pub const ma_result_MA_NO_HOST: ma_result = -49; ++pub const ma_result_MA_IN_PROGRESS: ma_result = -50; ++pub const ma_result_MA_CANCELLED: ma_result = -51; ++pub const ma_result_MA_MEMORY_ALREADY_MAPPED: ma_result = -52; ++pub const ma_result_MA_CRC_MISMATCH: ma_result = -100; ++pub const ma_result_MA_FORMAT_NOT_SUPPORTED: ma_result = -200; ++pub const ma_result_MA_DEVICE_TYPE_NOT_SUPPORTED: ma_result = -201; ++pub const ma_result_MA_SHARE_MODE_NOT_SUPPORTED: ma_result = -202; ++pub const ma_result_MA_NO_BACKEND: ma_result = -203; ++pub const ma_result_MA_NO_DEVICE: ma_result = -204; ++pub const ma_result_MA_API_NOT_FOUND: ma_result = -205; ++pub const ma_result_MA_INVALID_DEVICE_CONFIG: ma_result = -206; ++pub const ma_result_MA_LOOP: ma_result = -207; ++pub const ma_result_MA_BACKEND_NOT_ENABLED: ma_result = -208; ++pub const ma_result_MA_DEVICE_NOT_INITIALIZED: ma_result = -300; ++pub const ma_result_MA_DEVICE_ALREADY_INITIALIZED: ma_result = -301; ++pub const ma_result_MA_DEVICE_NOT_STARTED: ma_result = -302; ++pub const ma_result_MA_DEVICE_NOT_STOPPED: ma_result = -303; ++pub const ma_result_MA_FAILED_TO_INIT_BACKEND: ma_result = -400; ++pub const ma_result_MA_FAILED_TO_OPEN_BACKEND_DEVICE: ma_result = -401; ++pub const ma_result_MA_FAILED_TO_START_BACKEND_DEVICE: ma_result = -402; ++pub const ma_result_MA_FAILED_TO_STOP_BACKEND_DEVICE: ma_result = -403; ++pub type ma_result = core::ffi::c_int; ++pub const ma_stream_format_ma_stream_format_pcm: ma_stream_format = 0; ++pub type ma_stream_format = core::ffi::c_uint; ++pub const ma_stream_layout_ma_stream_layout_interleaved: ma_stream_layout = 0; ++pub const ma_stream_layout_ma_stream_layout_deinterleaved: ma_stream_layout = 1; ++pub type ma_stream_layout = core::ffi::c_uint; ++pub const ma_dither_mode_ma_dither_mode_none: ma_dither_mode = 0; ++pub const ma_dither_mode_ma_dither_mode_rectangle: ma_dither_mode = 1; ++pub const ma_dither_mode_ma_dither_mode_triangle: ma_dither_mode = 2; ++pub type ma_dither_mode = core::ffi::c_uint; ++pub const ma_format_ma_format_unknown: ma_format = 0; ++pub const ma_format_ma_format_u8: ma_format = 1; ++pub const ma_format_ma_format_s16: ma_format = 2; ++pub const ma_format_ma_format_s24: ma_format = 3; ++pub const ma_format_ma_format_s32: ma_format = 4; ++pub const ma_format_ma_format_f32: ma_format = 5; ++pub const ma_format_ma_format_count: ma_format = 6; ++pub type ma_format = core::ffi::c_uint; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_48000: ma_standard_sample_rate = 48000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_44100: ma_standard_sample_rate = 44100; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_32000: ma_standard_sample_rate = 32000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_24000: ma_standard_sample_rate = 24000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_22050: ma_standard_sample_rate = 22050; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_88200: ma_standard_sample_rate = 88200; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_96000: ma_standard_sample_rate = 96000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_176400: ma_standard_sample_rate = 176400; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_192000: ma_standard_sample_rate = 192000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_16000: ma_standard_sample_rate = 16000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_11025: ma_standard_sample_rate = 11025; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_8000: ma_standard_sample_rate = 8000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_352800: ma_standard_sample_rate = 352800; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_384000: ma_standard_sample_rate = 384000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_min: ma_standard_sample_rate = 8000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_max: ma_standard_sample_rate = 384000; ++pub const ma_standard_sample_rate_ma_standard_sample_rate_count: ma_standard_sample_rate = 14; ++pub type ma_standard_sample_rate = core::ffi::c_uint; ++pub const ma_channel_mix_mode_ma_channel_mix_mode_rectangular: ma_channel_mix_mode = 0; ++pub const ma_channel_mix_mode_ma_channel_mix_mode_simple: ma_channel_mix_mode = 1; ++pub const ma_channel_mix_mode_ma_channel_mix_mode_custom_weights: ma_channel_mix_mode = 2; ++pub const ma_channel_mix_mode_ma_channel_mix_mode_default: ma_channel_mix_mode = 0; ++pub type ma_channel_mix_mode = core::ffi::c_uint; ++pub const ma_standard_channel_map_ma_standard_channel_map_microsoft: ma_standard_channel_map = 0; ++pub const ma_standard_channel_map_ma_standard_channel_map_alsa: ma_standard_channel_map = 1; ++pub const ma_standard_channel_map_ma_standard_channel_map_rfc3551: ma_standard_channel_map = 2; ++pub const ma_standard_channel_map_ma_standard_channel_map_flac: ma_standard_channel_map = 3; ++pub const ma_standard_channel_map_ma_standard_channel_map_vorbis: ma_standard_channel_map = 4; ++pub const ma_standard_channel_map_ma_standard_channel_map_sound4: ma_standard_channel_map = 5; ++pub const ma_standard_channel_map_ma_standard_channel_map_sndio: ma_standard_channel_map = 6; ++pub const ma_standard_channel_map_ma_standard_channel_map_webaudio: ma_standard_channel_map = 3; ++pub const ma_standard_channel_map_ma_standard_channel_map_default: ma_standard_channel_map = 0; ++pub type ma_standard_channel_map = core::ffi::c_uint; ++pub const ma_performance_profile_ma_performance_profile_low_latency: ma_performance_profile = 0; ++pub const ma_performance_profile_ma_performance_profile_conservative: ma_performance_profile = 1; ++pub type ma_performance_profile = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_allocation_callbacks { ++ pub pUserData: *mut core::ffi::c_void, ++ pub onMalloc: ::core::option::Option< ++ unsafe extern "C" fn( ++ sz: usize, ++ pUserData: *mut core::ffi::c_void, ++ ) -> *mut core::ffi::c_void, ++ >, ++ pub onRealloc: ::core::option::Option< ++ unsafe extern "C" fn( ++ p: *mut core::ffi::c_void, ++ sz: usize, ++ pUserData: *mut core::ffi::c_void, ++ ) -> *mut core::ffi::c_void, ++ >, ++ pub onFree: ::core::option::Option< ++ unsafe extern "C" fn(p: *mut core::ffi::c_void, pUserData: *mut core::ffi::c_void), ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_allocation_callbacks"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_allocation_callbacks"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_allocation_callbacks::pUserData"] ++ [::core::mem::offset_of!(ma_allocation_callbacks, pUserData) - 0usize]; ++ ["Offset of field: ma_allocation_callbacks::onMalloc"] ++ [::core::mem::offset_of!(ma_allocation_callbacks, onMalloc) - 8usize]; ++ ["Offset of field: ma_allocation_callbacks::onRealloc"] ++ [::core::mem::offset_of!(ma_allocation_callbacks, onRealloc) - 16usize]; ++ ["Offset of field: ma_allocation_callbacks::onFree"] ++ [::core::mem::offset_of!(ma_allocation_callbacks, onFree) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lcg { ++ pub state: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lcg"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_lcg"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_lcg::state"][::core::mem::offset_of!(ma_lcg, state) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_uint32 { ++ pub value: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_uint32"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_uint32"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_uint32::value"] ++ [::core::mem::offset_of!(ma_atomic_uint32, value) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_int32 { ++ pub value: ma_int32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_int32"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_int32"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_int32::value"] ++ [::core::mem::offset_of!(ma_atomic_int32, value) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_uint64 { ++ pub value: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_uint64"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_atomic_uint64"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_atomic_uint64::value"] ++ [::core::mem::offset_of!(ma_atomic_uint64, value) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_float { ++ pub value: ma_float, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_float"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_float"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_float::value"] ++ [::core::mem::offset_of!(ma_atomic_float, value) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_bool32 { ++ pub value: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_bool32"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_bool32"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_bool32::value"] ++ [::core::mem::offset_of!(ma_atomic_bool32, value) - 0usize]; ++}; ++pub type ma_spinlock = ma_uint32; ++pub const ma_thread_priority_ma_thread_priority_idle: ma_thread_priority = -5; ++pub const ma_thread_priority_ma_thread_priority_lowest: ma_thread_priority = -4; ++pub const ma_thread_priority_ma_thread_priority_low: ma_thread_priority = -3; ++pub const ma_thread_priority_ma_thread_priority_normal: ma_thread_priority = -2; ++pub const ma_thread_priority_ma_thread_priority_high: ma_thread_priority = -1; ++pub const ma_thread_priority_ma_thread_priority_highest: ma_thread_priority = 0; ++pub const ma_thread_priority_ma_thread_priority_realtime: ma_thread_priority = 1; ++pub const ma_thread_priority_ma_thread_priority_default: ma_thread_priority = 0; ++pub type ma_thread_priority = core::ffi::c_int; ++pub type ma_thread = ma_pthread_t; ++pub type ma_mutex = ma_pthread_mutex_t; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_event { ++ pub value: ma_uint32, ++ pub lock: ma_pthread_mutex_t, ++ pub cond: ma_pthread_cond_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_event"][::core::mem::size_of::() - 96usize]; ++ ["Alignment of ma_event"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_event::value"][::core::mem::offset_of!(ma_event, value) - 0usize]; ++ ["Offset of field: ma_event::lock"][::core::mem::offset_of!(ma_event, lock) - 8usize]; ++ ["Offset of field: ma_event::cond"][::core::mem::offset_of!(ma_event, cond) - 48usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_semaphore { ++ pub value: core::ffi::c_int, ++ pub lock: ma_pthread_mutex_t, ++ pub cond: ma_pthread_cond_t, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_semaphore"][::core::mem::size_of::() - 96usize]; ++ ["Alignment of ma_semaphore"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_semaphore::value"][::core::mem::offset_of!(ma_semaphore, value) - 0usize]; ++ ["Offset of field: ma_semaphore::lock"][::core::mem::offset_of!(ma_semaphore, lock) - 8usize]; ++ ["Offset of field: ma_semaphore::cond"][::core::mem::offset_of!(ma_semaphore, cond) - 48usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_version(pMajor: *mut ma_uint32, pMinor: *mut ma_uint32, pRevision: *mut ma_uint32); ++} ++unsafe extern "C" { ++ pub fn ma_version_string() -> *const core::ffi::c_char; ++} ++pub type __gnuc_va_list = __builtin_va_list; ++pub type va_list = __builtin_va_list; ++pub type ma_log_callback_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ level: ma_uint32, ++ pMessage: *const core::ffi::c_char, ++ ), ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_log_callback { ++ pub onLog: ma_log_callback_proc, ++ pub pUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_log_callback"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_log_callback"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_log_callback::onLog"] ++ [::core::mem::offset_of!(ma_log_callback, onLog) - 0usize]; ++ ["Offset of field: ma_log_callback::pUserData"] ++ [::core::mem::offset_of!(ma_log_callback, pUserData) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_log_callback_init( ++ onLog: ma_log_callback_proc, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_log_callback; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_log { ++ pub callbacks: [ma_log_callback; 4usize], ++ pub callbackCount: ma_uint32, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub lock: ma_mutex, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_log"][::core::mem::size_of::() - 144usize]; ++ ["Alignment of ma_log"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_log::callbacks"][::core::mem::offset_of!(ma_log, callbacks) - 0usize]; ++ ["Offset of field: ma_log::callbackCount"] ++ [::core::mem::offset_of!(ma_log, callbackCount) - 64usize]; ++ ["Offset of field: ma_log::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_log, allocationCallbacks) - 72usize]; ++ ["Offset of field: ma_log::lock"][::core::mem::offset_of!(ma_log, lock) - 104usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_log_init( ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pLog: *mut ma_log, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_uninit(pLog: *mut ma_log); ++} ++unsafe extern "C" { ++ pub fn ma_log_register_callback(pLog: *mut ma_log, callback: ma_log_callback) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_unregister_callback(pLog: *mut ma_log, callback: ma_log_callback) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_post( ++ pLog: *mut ma_log, ++ level: ma_uint32, ++ pMessage: *const core::ffi::c_char, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_postv( ++ pLog: *mut ma_log, ++ level: ma_uint32, ++ pFormat: *const core::ffi::c_char, ++ args: *mut __va_list_tag, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_log_postf( ++ pLog: *mut ma_log, ++ level: ma_uint32, ++ pFormat: *const core::ffi::c_char, ++ ... ++ ) -> ma_result; ++} ++#[doc = "Biquad Filtering"] ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_biquad_coefficient { ++ pub f32_: f32, ++ pub s32: ma_int32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad_coefficient"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_biquad_coefficient"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_biquad_coefficient::f32_"] ++ [::core::mem::offset_of!(ma_biquad_coefficient, f32_) - 0usize]; ++ ["Offset of field: ma_biquad_coefficient::s32"] ++ [::core::mem::offset_of!(ma_biquad_coefficient, s32) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_biquad_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub b0: f64, ++ pub b1: f64, ++ pub b2: f64, ++ pub a0: f64, ++ pub a1: f64, ++ pub a2: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad_config"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_biquad_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_biquad_config::format"] ++ [::core::mem::offset_of!(ma_biquad_config, format) - 0usize]; ++ ["Offset of field: ma_biquad_config::channels"] ++ [::core::mem::offset_of!(ma_biquad_config, channels) - 4usize]; ++ ["Offset of field: ma_biquad_config::b0"] ++ [::core::mem::offset_of!(ma_biquad_config, b0) - 8usize]; ++ ["Offset of field: ma_biquad_config::b1"] ++ [::core::mem::offset_of!(ma_biquad_config, b1) - 16usize]; ++ ["Offset of field: ma_biquad_config::b2"] ++ [::core::mem::offset_of!(ma_biquad_config, b2) - 24usize]; ++ ["Offset of field: ma_biquad_config::a0"] ++ [::core::mem::offset_of!(ma_biquad_config, a0) - 32usize]; ++ ["Offset of field: ma_biquad_config::a1"] ++ [::core::mem::offset_of!(ma_biquad_config, a1) - 40usize]; ++ ["Offset of field: ma_biquad_config::a2"] ++ [::core::mem::offset_of!(ma_biquad_config, a2) - 48usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_biquad_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ b0: f64, ++ b1: f64, ++ b2: f64, ++ a0: f64, ++ a1: f64, ++ a2: f64, ++ ) -> ma_biquad_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_biquad { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub b0: ma_biquad_coefficient, ++ pub b1: ma_biquad_coefficient, ++ pub b2: ma_biquad_coefficient, ++ pub a1: ma_biquad_coefficient, ++ pub a2: ma_biquad_coefficient, ++ pub pR1: *mut ma_biquad_coefficient, ++ pub pR2: *mut ma_biquad_coefficient, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_biquad"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_biquad::format"][::core::mem::offset_of!(ma_biquad, format) - 0usize]; ++ ["Offset of field: ma_biquad::channels"][::core::mem::offset_of!(ma_biquad, channels) - 4usize]; ++ ["Offset of field: ma_biquad::b0"][::core::mem::offset_of!(ma_biquad, b0) - 8usize]; ++ ["Offset of field: ma_biquad::b1"][::core::mem::offset_of!(ma_biquad, b1) - 12usize]; ++ ["Offset of field: ma_biquad::b2"][::core::mem::offset_of!(ma_biquad, b2) - 16usize]; ++ ["Offset of field: ma_biquad::a1"][::core::mem::offset_of!(ma_biquad, a1) - 20usize]; ++ ["Offset of field: ma_biquad::a2"][::core::mem::offset_of!(ma_biquad, a2) - 24usize]; ++ ["Offset of field: ma_biquad::pR1"][::core::mem::offset_of!(ma_biquad, pR1) - 32usize]; ++ ["Offset of field: ma_biquad::pR2"][::core::mem::offset_of!(ma_biquad, pR2) - 40usize]; ++ ["Offset of field: ma_biquad::_pHeap"][::core::mem::offset_of!(ma_biquad, _pHeap) - 48usize]; ++ ["Offset of field: ma_biquad::_ownsHeap"] ++ [::core::mem::offset_of!(ma_biquad, _ownsHeap) - 56usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_biquad_get_heap_size( ++ pConfig: *const ma_biquad_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_init_preallocated( ++ pConfig: *const ma_biquad_config, ++ pHeap: *mut core::ffi::c_void, ++ pBQ: *mut ma_biquad, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_init( ++ pConfig: *const ma_biquad_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pBQ: *mut ma_biquad, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_uninit( ++ pBQ: *mut ma_biquad, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_biquad_reinit(pConfig: *const ma_biquad_config, pBQ: *mut ma_biquad) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_clear_cache(pBQ: *mut ma_biquad) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_process_pcm_frames( ++ pBQ: *mut ma_biquad, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_get_latency(pBQ: *const ma_biquad) -> ma_uint32; ++} ++#[doc = "Low-Pass Filtering"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf1_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub q: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf1_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_lpf1_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf1_config::format"] ++ [::core::mem::offset_of!(ma_lpf1_config, format) - 0usize]; ++ ["Offset of field: ma_lpf1_config::channels"] ++ [::core::mem::offset_of!(ma_lpf1_config, channels) - 4usize]; ++ ["Offset of field: ma_lpf1_config::sampleRate"] ++ [::core::mem::offset_of!(ma_lpf1_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_lpf1_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_lpf1_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_lpf1_config::q"][::core::mem::offset_of!(ma_lpf1_config, q) - 24usize]; ++}; ++#[doc = "Low-Pass Filtering"] ++pub type ma_lpf2_config = ma_lpf1_config; ++unsafe extern "C" { ++ pub fn ma_lpf1_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ ) -> ma_lpf1_config; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ q: f64, ++ ) -> ma_lpf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_lpf1 { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub a: ma_biquad_coefficient, ++ pub pR1: *mut ma_biquad_coefficient, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf1"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_lpf1"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf1::format"][::core::mem::offset_of!(ma_lpf1, format) - 0usize]; ++ ["Offset of field: ma_lpf1::channels"][::core::mem::offset_of!(ma_lpf1, channels) - 4usize]; ++ ["Offset of field: ma_lpf1::a"][::core::mem::offset_of!(ma_lpf1, a) - 8usize]; ++ ["Offset of field: ma_lpf1::pR1"][::core::mem::offset_of!(ma_lpf1, pR1) - 16usize]; ++ ["Offset of field: ma_lpf1::_pHeap"][::core::mem::offset_of!(ma_lpf1, _pHeap) - 24usize]; ++ ["Offset of field: ma_lpf1::_ownsHeap"][::core::mem::offset_of!(ma_lpf1, _ownsHeap) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf1_get_heap_size( ++ pConfig: *const ma_lpf1_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_init_preallocated( ++ pConfig: *const ma_lpf1_config, ++ pHeap: *mut core::ffi::c_void, ++ pLPF: *mut ma_lpf1, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_init( ++ pConfig: *const ma_lpf1_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pLPF: *mut ma_lpf1, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_uninit(pLPF: *mut ma_lpf1, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_reinit(pConfig: *const ma_lpf1_config, pLPF: *mut ma_lpf1) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_clear_cache(pLPF: *mut ma_lpf1) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_process_pcm_frames( ++ pLPF: *mut ma_lpf1, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf1_get_latency(pLPF: *const ma_lpf1) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_lpf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_lpf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf2::bq"][::core::mem::offset_of!(ma_lpf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf2_get_heap_size( ++ pConfig: *const ma_lpf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_init_preallocated( ++ pConfig: *const ma_lpf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pHPF: *mut ma_lpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_init( ++ pConfig: *const ma_lpf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pLPF: *mut ma_lpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_uninit(pLPF: *mut ma_lpf2, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_reinit(pConfig: *const ma_lpf2_config, pLPF: *mut ma_lpf2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_clear_cache(pLPF: *mut ma_lpf2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_process_pcm_frames( ++ pLPF: *mut ma_lpf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf2_get_latency(pLPF: *const ma_lpf2) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub order: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_lpf_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf_config::format"] ++ [::core::mem::offset_of!(ma_lpf_config, format) - 0usize]; ++ ["Offset of field: ma_lpf_config::channels"] ++ [::core::mem::offset_of!(ma_lpf_config, channels) - 4usize]; ++ ["Offset of field: ma_lpf_config::sampleRate"] ++ [::core::mem::offset_of!(ma_lpf_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_lpf_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_lpf_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_lpf_config::order"] ++ [::core::mem::offset_of!(ma_lpf_config, order) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_lpf_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub lpf1Count: ma_uint32, ++ pub lpf2Count: ma_uint32, ++ pub pLPF1: *mut ma_lpf1, ++ pub pLPF2: *mut ma_lpf2, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_lpf"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf::format"][::core::mem::offset_of!(ma_lpf, format) - 0usize]; ++ ["Offset of field: ma_lpf::channels"][::core::mem::offset_of!(ma_lpf, channels) - 4usize]; ++ ["Offset of field: ma_lpf::sampleRate"][::core::mem::offset_of!(ma_lpf, sampleRate) - 8usize]; ++ ["Offset of field: ma_lpf::lpf1Count"][::core::mem::offset_of!(ma_lpf, lpf1Count) - 12usize]; ++ ["Offset of field: ma_lpf::lpf2Count"][::core::mem::offset_of!(ma_lpf, lpf2Count) - 16usize]; ++ ["Offset of field: ma_lpf::pLPF1"][::core::mem::offset_of!(ma_lpf, pLPF1) - 24usize]; ++ ["Offset of field: ma_lpf::pLPF2"][::core::mem::offset_of!(ma_lpf, pLPF2) - 32usize]; ++ ["Offset of field: ma_lpf::_pHeap"][::core::mem::offset_of!(ma_lpf, _pHeap) - 40usize]; ++ ["Offset of field: ma_lpf::_ownsHeap"][::core::mem::offset_of!(ma_lpf, _ownsHeap) - 48usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf_get_heap_size( ++ pConfig: *const ma_lpf_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_init_preallocated( ++ pConfig: *const ma_lpf_config, ++ pHeap: *mut core::ffi::c_void, ++ pLPF: *mut ma_lpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_init( ++ pConfig: *const ma_lpf_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pLPF: *mut ma_lpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_uninit(pLPF: *mut ma_lpf, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_lpf_reinit(pConfig: *const ma_lpf_config, pLPF: *mut ma_lpf) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_clear_cache(pLPF: *mut ma_lpf) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_process_pcm_frames( ++ pLPF: *mut ma_lpf, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_get_latency(pLPF: *const ma_lpf) -> ma_uint32; ++} ++#[doc = "High-Pass Filtering"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf1_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub q: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf1_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_hpf1_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf1_config::format"] ++ [::core::mem::offset_of!(ma_hpf1_config, format) - 0usize]; ++ ["Offset of field: ma_hpf1_config::channels"] ++ [::core::mem::offset_of!(ma_hpf1_config, channels) - 4usize]; ++ ["Offset of field: ma_hpf1_config::sampleRate"] ++ [::core::mem::offset_of!(ma_hpf1_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_hpf1_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_hpf1_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_hpf1_config::q"][::core::mem::offset_of!(ma_hpf1_config, q) - 24usize]; ++}; ++#[doc = "High-Pass Filtering"] ++pub type ma_hpf2_config = ma_hpf1_config; ++unsafe extern "C" { ++ pub fn ma_hpf1_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ ) -> ma_hpf1_config; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ q: f64, ++ ) -> ma_hpf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_hpf1 { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub a: ma_biquad_coefficient, ++ pub pR1: *mut ma_biquad_coefficient, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf1"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_hpf1"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf1::format"][::core::mem::offset_of!(ma_hpf1, format) - 0usize]; ++ ["Offset of field: ma_hpf1::channels"][::core::mem::offset_of!(ma_hpf1, channels) - 4usize]; ++ ["Offset of field: ma_hpf1::a"][::core::mem::offset_of!(ma_hpf1, a) - 8usize]; ++ ["Offset of field: ma_hpf1::pR1"][::core::mem::offset_of!(ma_hpf1, pR1) - 16usize]; ++ ["Offset of field: ma_hpf1::_pHeap"][::core::mem::offset_of!(ma_hpf1, _pHeap) - 24usize]; ++ ["Offset of field: ma_hpf1::_ownsHeap"][::core::mem::offset_of!(ma_hpf1, _ownsHeap) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf1_get_heap_size( ++ pConfig: *const ma_hpf1_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_init_preallocated( ++ pConfig: *const ma_hpf1_config, ++ pHeap: *mut core::ffi::c_void, ++ pLPF: *mut ma_hpf1, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_init( ++ pConfig: *const ma_hpf1_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pHPF: *mut ma_hpf1, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_uninit(pHPF: *mut ma_hpf1, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_reinit(pConfig: *const ma_hpf1_config, pHPF: *mut ma_hpf1) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_process_pcm_frames( ++ pHPF: *mut ma_hpf1, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf1_get_latency(pHPF: *const ma_hpf1) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_hpf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_hpf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf2::bq"][::core::mem::offset_of!(ma_hpf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf2_get_heap_size( ++ pConfig: *const ma_hpf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_init_preallocated( ++ pConfig: *const ma_hpf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pHPF: *mut ma_hpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_init( ++ pConfig: *const ma_hpf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pHPF: *mut ma_hpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_uninit(pHPF: *mut ma_hpf2, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_reinit(pConfig: *const ma_hpf2_config, pHPF: *mut ma_hpf2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_process_pcm_frames( ++ pHPF: *mut ma_hpf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf2_get_latency(pHPF: *const ma_hpf2) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub order: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_hpf_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf_config::format"] ++ [::core::mem::offset_of!(ma_hpf_config, format) - 0usize]; ++ ["Offset of field: ma_hpf_config::channels"] ++ [::core::mem::offset_of!(ma_hpf_config, channels) - 4usize]; ++ ["Offset of field: ma_hpf_config::sampleRate"] ++ [::core::mem::offset_of!(ma_hpf_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_hpf_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_hpf_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_hpf_config::order"] ++ [::core::mem::offset_of!(ma_hpf_config, order) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_hpf_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub hpf1Count: ma_uint32, ++ pub hpf2Count: ma_uint32, ++ pub pHPF1: *mut ma_hpf1, ++ pub pHPF2: *mut ma_hpf2, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_hpf"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf::format"][::core::mem::offset_of!(ma_hpf, format) - 0usize]; ++ ["Offset of field: ma_hpf::channels"][::core::mem::offset_of!(ma_hpf, channels) - 4usize]; ++ ["Offset of field: ma_hpf::sampleRate"][::core::mem::offset_of!(ma_hpf, sampleRate) - 8usize]; ++ ["Offset of field: ma_hpf::hpf1Count"][::core::mem::offset_of!(ma_hpf, hpf1Count) - 12usize]; ++ ["Offset of field: ma_hpf::hpf2Count"][::core::mem::offset_of!(ma_hpf, hpf2Count) - 16usize]; ++ ["Offset of field: ma_hpf::pHPF1"][::core::mem::offset_of!(ma_hpf, pHPF1) - 24usize]; ++ ["Offset of field: ma_hpf::pHPF2"][::core::mem::offset_of!(ma_hpf, pHPF2) - 32usize]; ++ ["Offset of field: ma_hpf::_pHeap"][::core::mem::offset_of!(ma_hpf, _pHeap) - 40usize]; ++ ["Offset of field: ma_hpf::_ownsHeap"][::core::mem::offset_of!(ma_hpf, _ownsHeap) - 48usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf_get_heap_size( ++ pConfig: *const ma_hpf_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_init_preallocated( ++ pConfig: *const ma_hpf_config, ++ pHeap: *mut core::ffi::c_void, ++ pLPF: *mut ma_hpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_init( ++ pConfig: *const ma_hpf_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pHPF: *mut ma_hpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_uninit(pHPF: *mut ma_hpf, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_hpf_reinit(pConfig: *const ma_hpf_config, pHPF: *mut ma_hpf) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_process_pcm_frames( ++ pHPF: *mut ma_hpf, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_get_latency(pHPF: *const ma_hpf) -> ma_uint32; ++} ++#[doc = "Band-Pass Filtering"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub q: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf2_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_bpf2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf2_config::format"] ++ [::core::mem::offset_of!(ma_bpf2_config, format) - 0usize]; ++ ["Offset of field: ma_bpf2_config::channels"] ++ [::core::mem::offset_of!(ma_bpf2_config, channels) - 4usize]; ++ ["Offset of field: ma_bpf2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_bpf2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_bpf2_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_bpf2_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_bpf2_config::q"][::core::mem::offset_of!(ma_bpf2_config, q) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ q: f64, ++ ) -> ma_bpf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_bpf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_bpf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf2::bq"][::core::mem::offset_of!(ma_bpf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf2_get_heap_size( ++ pConfig: *const ma_bpf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_init_preallocated( ++ pConfig: *const ma_bpf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pBPF: *mut ma_bpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_init( ++ pConfig: *const ma_bpf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pBPF: *mut ma_bpf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_uninit(pBPF: *mut ma_bpf2, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_reinit(pConfig: *const ma_bpf2_config, pBPF: *mut ma_bpf2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_process_pcm_frames( ++ pBPF: *mut ma_bpf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf2_get_latency(pBPF: *const ma_bpf2) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cutoffFrequency: f64, ++ pub order: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_bpf_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf_config::format"] ++ [::core::mem::offset_of!(ma_bpf_config, format) - 0usize]; ++ ["Offset of field: ma_bpf_config::channels"] ++ [::core::mem::offset_of!(ma_bpf_config, channels) - 4usize]; ++ ["Offset of field: ma_bpf_config::sampleRate"] ++ [::core::mem::offset_of!(ma_bpf_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_bpf_config::cutoffFrequency"] ++ [::core::mem::offset_of!(ma_bpf_config, cutoffFrequency) - 16usize]; ++ ["Offset of field: ma_bpf_config::order"] ++ [::core::mem::offset_of!(ma_bpf_config, order) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_bpf_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub bpf2Count: ma_uint32, ++ pub pBPF2: *mut ma_bpf2, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_bpf"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf::format"][::core::mem::offset_of!(ma_bpf, format) - 0usize]; ++ ["Offset of field: ma_bpf::channels"][::core::mem::offset_of!(ma_bpf, channels) - 4usize]; ++ ["Offset of field: ma_bpf::bpf2Count"][::core::mem::offset_of!(ma_bpf, bpf2Count) - 8usize]; ++ ["Offset of field: ma_bpf::pBPF2"][::core::mem::offset_of!(ma_bpf, pBPF2) - 16usize]; ++ ["Offset of field: ma_bpf::_pHeap"][::core::mem::offset_of!(ma_bpf, _pHeap) - 24usize]; ++ ["Offset of field: ma_bpf::_ownsHeap"][::core::mem::offset_of!(ma_bpf, _ownsHeap) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf_get_heap_size( ++ pConfig: *const ma_bpf_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_init_preallocated( ++ pConfig: *const ma_bpf_config, ++ pHeap: *mut core::ffi::c_void, ++ pBPF: *mut ma_bpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_init( ++ pConfig: *const ma_bpf_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pBPF: *mut ma_bpf, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_uninit(pBPF: *mut ma_bpf, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_bpf_reinit(pConfig: *const ma_bpf_config, pBPF: *mut ma_bpf) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_process_pcm_frames( ++ pBPF: *mut ma_bpf, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_get_latency(pBPF: *const ma_bpf) -> ma_uint32; ++} ++#[doc = "Notching Filter"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_notch2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub q: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_notch2_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_notch2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_notch2_config::format"] ++ [::core::mem::offset_of!(ma_notch2_config, format) - 0usize]; ++ ["Offset of field: ma_notch2_config::channels"] ++ [::core::mem::offset_of!(ma_notch2_config, channels) - 4usize]; ++ ["Offset of field: ma_notch2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_notch2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_notch2_config::q"] ++ [::core::mem::offset_of!(ma_notch2_config, q) - 16usize]; ++ ["Offset of field: ma_notch2_config::frequency"] ++ [::core::mem::offset_of!(ma_notch2_config, frequency) - 24usize]; ++}; ++#[doc = "Notching Filter"] ++pub type ma_notch_config = ma_notch2_config; ++unsafe extern "C" { ++ pub fn ma_notch2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ q: f64, ++ frequency: f64, ++ ) -> ma_notch2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_notch2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_notch2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_notch2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_notch2::bq"][::core::mem::offset_of!(ma_notch2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_notch2_get_heap_size( ++ pConfig: *const ma_notch2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_init_preallocated( ++ pConfig: *const ma_notch2_config, ++ pHeap: *mut core::ffi::c_void, ++ pFilter: *mut ma_notch2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_init( ++ pConfig: *const ma_notch2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pFilter: *mut ma_notch2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_uninit( ++ pFilter: *mut ma_notch2, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_notch2_reinit(pConfig: *const ma_notch2_config, pFilter: *mut ma_notch2) ++ -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_process_pcm_frames( ++ pFilter: *mut ma_notch2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch2_get_latency(pFilter: *const ma_notch2) -> ma_uint32; ++} ++#[doc = "Peaking EQ Filter"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_peak2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub gainDB: f64, ++ pub q: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_peak2_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_peak2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_peak2_config::format"] ++ [::core::mem::offset_of!(ma_peak2_config, format) - 0usize]; ++ ["Offset of field: ma_peak2_config::channels"] ++ [::core::mem::offset_of!(ma_peak2_config, channels) - 4usize]; ++ ["Offset of field: ma_peak2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_peak2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_peak2_config::gainDB"] ++ [::core::mem::offset_of!(ma_peak2_config, gainDB) - 16usize]; ++ ["Offset of field: ma_peak2_config::q"][::core::mem::offset_of!(ma_peak2_config, q) - 24usize]; ++ ["Offset of field: ma_peak2_config::frequency"] ++ [::core::mem::offset_of!(ma_peak2_config, frequency) - 32usize]; ++}; ++#[doc = "Peaking EQ Filter"] ++pub type ma_peak_config = ma_peak2_config; ++unsafe extern "C" { ++ pub fn ma_peak2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ q: f64, ++ frequency: f64, ++ ) -> ma_peak2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_peak2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_peak2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_peak2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_peak2::bq"][::core::mem::offset_of!(ma_peak2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_peak2_get_heap_size( ++ pConfig: *const ma_peak2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_init_preallocated( ++ pConfig: *const ma_peak2_config, ++ pHeap: *mut core::ffi::c_void, ++ pFilter: *mut ma_peak2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_init( ++ pConfig: *const ma_peak2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pFilter: *mut ma_peak2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_uninit( ++ pFilter: *mut ma_peak2, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_peak2_reinit(pConfig: *const ma_peak2_config, pFilter: *mut ma_peak2) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_process_pcm_frames( ++ pFilter: *mut ma_peak2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak2_get_latency(pFilter: *const ma_peak2) -> ma_uint32; ++} ++#[doc = "Low Shelf Filter"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_loshelf2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub gainDB: f64, ++ pub shelfSlope: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_loshelf2_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_loshelf2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_loshelf2_config::format"] ++ [::core::mem::offset_of!(ma_loshelf2_config, format) - 0usize]; ++ ["Offset of field: ma_loshelf2_config::channels"] ++ [::core::mem::offset_of!(ma_loshelf2_config, channels) - 4usize]; ++ ["Offset of field: ma_loshelf2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_loshelf2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_loshelf2_config::gainDB"] ++ [::core::mem::offset_of!(ma_loshelf2_config, gainDB) - 16usize]; ++ ["Offset of field: ma_loshelf2_config::shelfSlope"] ++ [::core::mem::offset_of!(ma_loshelf2_config, shelfSlope) - 24usize]; ++ ["Offset of field: ma_loshelf2_config::frequency"] ++ [::core::mem::offset_of!(ma_loshelf2_config, frequency) - 32usize]; ++}; ++#[doc = "Low Shelf Filter"] ++pub type ma_loshelf_config = ma_loshelf2_config; ++unsafe extern "C" { ++ pub fn ma_loshelf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ shelfSlope: f64, ++ frequency: f64, ++ ) -> ma_loshelf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_loshelf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_loshelf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_loshelf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_loshelf2::bq"][::core::mem::offset_of!(ma_loshelf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_loshelf2_get_heap_size( ++ pConfig: *const ma_loshelf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_init_preallocated( ++ pConfig: *const ma_loshelf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pFilter: *mut ma_loshelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_init( ++ pConfig: *const ma_loshelf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pFilter: *mut ma_loshelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_uninit( ++ pFilter: *mut ma_loshelf2, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_reinit( ++ pConfig: *const ma_loshelf2_config, ++ pFilter: *mut ma_loshelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_process_pcm_frames( ++ pFilter: *mut ma_loshelf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf2_get_latency(pFilter: *const ma_loshelf2) -> ma_uint32; ++} ++#[doc = "High Shelf Filter"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hishelf2_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub gainDB: f64, ++ pub shelfSlope: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hishelf2_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_hishelf2_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hishelf2_config::format"] ++ [::core::mem::offset_of!(ma_hishelf2_config, format) - 0usize]; ++ ["Offset of field: ma_hishelf2_config::channels"] ++ [::core::mem::offset_of!(ma_hishelf2_config, channels) - 4usize]; ++ ["Offset of field: ma_hishelf2_config::sampleRate"] ++ [::core::mem::offset_of!(ma_hishelf2_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_hishelf2_config::gainDB"] ++ [::core::mem::offset_of!(ma_hishelf2_config, gainDB) - 16usize]; ++ ["Offset of field: ma_hishelf2_config::shelfSlope"] ++ [::core::mem::offset_of!(ma_hishelf2_config, shelfSlope) - 24usize]; ++ ["Offset of field: ma_hishelf2_config::frequency"] ++ [::core::mem::offset_of!(ma_hishelf2_config, frequency) - 32usize]; ++}; ++#[doc = "High Shelf Filter"] ++pub type ma_hishelf_config = ma_hishelf2_config; ++unsafe extern "C" { ++ pub fn ma_hishelf2_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ shelfSlope: f64, ++ frequency: f64, ++ ) -> ma_hishelf2_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_hishelf2 { ++ pub bq: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hishelf2"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_hishelf2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hishelf2::bq"][::core::mem::offset_of!(ma_hishelf2, bq) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hishelf2_get_heap_size( ++ pConfig: *const ma_hishelf2_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_init_preallocated( ++ pConfig: *const ma_hishelf2_config, ++ pHeap: *mut core::ffi::c_void, ++ pFilter: *mut ma_hishelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_init( ++ pConfig: *const ma_hishelf2_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pFilter: *mut ma_hishelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_uninit( ++ pFilter: *mut ma_hishelf2, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_reinit( ++ pConfig: *const ma_hishelf2_config, ++ pFilter: *mut ma_hishelf2, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_process_pcm_frames( ++ pFilter: *mut ma_hishelf2, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf2_get_latency(pFilter: *const ma_hishelf2) -> ma_uint32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_delay_config { ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub delayInFrames: ma_uint32, ++ pub delayStart: ma_bool32, ++ pub wet: f32, ++ pub dry: f32, ++ pub decay: f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_delay_config"][::core::mem::size_of::() - 28usize]; ++ ["Alignment of ma_delay_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_delay_config::channels"] ++ [::core::mem::offset_of!(ma_delay_config, channels) - 0usize]; ++ ["Offset of field: ma_delay_config::sampleRate"] ++ [::core::mem::offset_of!(ma_delay_config, sampleRate) - 4usize]; ++ ["Offset of field: ma_delay_config::delayInFrames"] ++ [::core::mem::offset_of!(ma_delay_config, delayInFrames) - 8usize]; ++ ["Offset of field: ma_delay_config::delayStart"] ++ [::core::mem::offset_of!(ma_delay_config, delayStart) - 12usize]; ++ ["Offset of field: ma_delay_config::wet"] ++ [::core::mem::offset_of!(ma_delay_config, wet) - 16usize]; ++ ["Offset of field: ma_delay_config::dry"] ++ [::core::mem::offset_of!(ma_delay_config, dry) - 20usize]; ++ ["Offset of field: ma_delay_config::decay"] ++ [::core::mem::offset_of!(ma_delay_config, decay) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_delay_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ delayInFrames: ma_uint32, ++ decay: f32, ++ ) -> ma_delay_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_delay { ++ pub config: ma_delay_config, ++ pub cursor: ma_uint32, ++ pub bufferSizeInFrames: ma_uint32, ++ pub pBuffer: *mut f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_delay"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_delay"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_delay::config"][::core::mem::offset_of!(ma_delay, config) - 0usize]; ++ ["Offset of field: ma_delay::cursor"][::core::mem::offset_of!(ma_delay, cursor) - 28usize]; ++ ["Offset of field: ma_delay::bufferSizeInFrames"] ++ [::core::mem::offset_of!(ma_delay, bufferSizeInFrames) - 32usize]; ++ ["Offset of field: ma_delay::pBuffer"][::core::mem::offset_of!(ma_delay, pBuffer) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_delay_init( ++ pConfig: *const ma_delay_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pDelay: *mut ma_delay, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_delay_uninit( ++ pDelay: *mut ma_delay, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_delay_process_pcm_frames( ++ pDelay: *mut ma_delay, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_delay_set_wet(pDelay: *mut ma_delay, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_get_wet(pDelay: *const ma_delay) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_delay_set_dry(pDelay: *mut ma_delay, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_get_dry(pDelay: *const ma_delay) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_delay_set_decay(pDelay: *mut ma_delay, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_get_decay(pDelay: *const ma_delay) -> f32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_gainer_config { ++ pub channels: ma_uint32, ++ pub smoothTimeInFrames: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_gainer_config"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_gainer_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_gainer_config::channels"] ++ [::core::mem::offset_of!(ma_gainer_config, channels) - 0usize]; ++ ["Offset of field: ma_gainer_config::smoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_gainer_config, smoothTimeInFrames) - 4usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_gainer_config_init( ++ channels: ma_uint32, ++ smoothTimeInFrames: ma_uint32, ++ ) -> ma_gainer_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_gainer { ++ pub config: ma_gainer_config, ++ pub t: ma_uint32, ++ pub masterVolume: f32, ++ pub pOldGains: *mut f32, ++ pub pNewGains: *mut f32, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_gainer"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_gainer"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_gainer::config"][::core::mem::offset_of!(ma_gainer, config) - 0usize]; ++ ["Offset of field: ma_gainer::t"][::core::mem::offset_of!(ma_gainer, t) - 8usize]; ++ ["Offset of field: ma_gainer::masterVolume"] ++ [::core::mem::offset_of!(ma_gainer, masterVolume) - 12usize]; ++ ["Offset of field: ma_gainer::pOldGains"] ++ [::core::mem::offset_of!(ma_gainer, pOldGains) - 16usize]; ++ ["Offset of field: ma_gainer::pNewGains"] ++ [::core::mem::offset_of!(ma_gainer, pNewGains) - 24usize]; ++ ["Offset of field: ma_gainer::_pHeap"][::core::mem::offset_of!(ma_gainer, _pHeap) - 32usize]; ++ ["Offset of field: ma_gainer::_ownsHeap"] ++ [::core::mem::offset_of!(ma_gainer, _ownsHeap) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_gainer_get_heap_size( ++ pConfig: *const ma_gainer_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_init_preallocated( ++ pConfig: *const ma_gainer_config, ++ pHeap: *mut core::ffi::c_void, ++ pGainer: *mut ma_gainer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_init( ++ pConfig: *const ma_gainer_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pGainer: *mut ma_gainer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_uninit( ++ pGainer: *mut ma_gainer, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_gainer_process_pcm_frames( ++ pGainer: *mut ma_gainer, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_set_gain(pGainer: *mut ma_gainer, newGain: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_set_gains(pGainer: *mut ma_gainer, pNewGains: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_set_master_volume(pGainer: *mut ma_gainer, volume: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_gainer_get_master_volume(pGainer: *const ma_gainer, pVolume: *mut f32) -> ma_result; ++} ++pub const ma_pan_mode_ma_pan_mode_balance: ma_pan_mode = 0; ++pub const ma_pan_mode_ma_pan_mode_pan: ma_pan_mode = 1; ++pub type ma_pan_mode = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_panner_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub mode: ma_pan_mode, ++ pub pan: f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_panner_config"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_panner_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_panner_config::format"] ++ [::core::mem::offset_of!(ma_panner_config, format) - 0usize]; ++ ["Offset of field: ma_panner_config::channels"] ++ [::core::mem::offset_of!(ma_panner_config, channels) - 4usize]; ++ ["Offset of field: ma_panner_config::mode"] ++ [::core::mem::offset_of!(ma_panner_config, mode) - 8usize]; ++ ["Offset of field: ma_panner_config::pan"] ++ [::core::mem::offset_of!(ma_panner_config, pan) - 12usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_panner_config_init(format: ma_format, channels: ma_uint32) -> ma_panner_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_panner { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub mode: ma_pan_mode, ++ pub pan: f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_panner"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_panner"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_panner::format"][::core::mem::offset_of!(ma_panner, format) - 0usize]; ++ ["Offset of field: ma_panner::channels"][::core::mem::offset_of!(ma_panner, channels) - 4usize]; ++ ["Offset of field: ma_panner::mode"][::core::mem::offset_of!(ma_panner, mode) - 8usize]; ++ ["Offset of field: ma_panner::pan"][::core::mem::offset_of!(ma_panner, pan) - 12usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_panner_init(pConfig: *const ma_panner_config, pPanner: *mut ma_panner) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_panner_process_pcm_frames( ++ pPanner: *mut ma_panner, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_panner_set_mode(pPanner: *mut ma_panner, mode: ma_pan_mode); ++} ++unsafe extern "C" { ++ pub fn ma_panner_get_mode(pPanner: *const ma_panner) -> ma_pan_mode; ++} ++unsafe extern "C" { ++ pub fn ma_panner_set_pan(pPanner: *mut ma_panner, pan: f32); ++} ++unsafe extern "C" { ++ pub fn ma_panner_get_pan(pPanner: *const ma_panner) -> f32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_fader_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_fader_config"][::core::mem::size_of::() - 12usize]; ++ ["Alignment of ma_fader_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_fader_config::format"] ++ [::core::mem::offset_of!(ma_fader_config, format) - 0usize]; ++ ["Offset of field: ma_fader_config::channels"] ++ [::core::mem::offset_of!(ma_fader_config, channels) - 4usize]; ++ ["Offset of field: ma_fader_config::sampleRate"] ++ [::core::mem::offset_of!(ma_fader_config, sampleRate) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_fader_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_fader_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_fader { ++ pub config: ma_fader_config, ++ pub volumeBeg: f32, ++ pub volumeEnd: f32, ++ pub lengthInFrames: ma_uint64, ++ pub cursorInFrames: ma_int64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_fader"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_fader"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_fader::config"][::core::mem::offset_of!(ma_fader, config) - 0usize]; ++ ["Offset of field: ma_fader::volumeBeg"] ++ [::core::mem::offset_of!(ma_fader, volumeBeg) - 12usize]; ++ ["Offset of field: ma_fader::volumeEnd"] ++ [::core::mem::offset_of!(ma_fader, volumeEnd) - 16usize]; ++ ["Offset of field: ma_fader::lengthInFrames"] ++ [::core::mem::offset_of!(ma_fader, lengthInFrames) - 24usize]; ++ ["Offset of field: ma_fader::cursorInFrames"] ++ [::core::mem::offset_of!(ma_fader, cursorInFrames) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_fader_init(pConfig: *const ma_fader_config, pFader: *mut ma_fader) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fader_process_pcm_frames( ++ pFader: *mut ma_fader, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fader_get_data_format( ++ pFader: *const ma_fader, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_fader_set_fade( ++ pFader: *mut ma_fader, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ lengthInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_fader_set_fade_ex( ++ pFader: *mut ma_fader, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ lengthInFrames: ma_uint64, ++ startOffsetInFrames: ma_int64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_fader_get_current_volume(pFader: *const ma_fader) -> f32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_vec3f { ++ pub x: f32, ++ pub y: f32, ++ pub z: f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_vec3f"][::core::mem::size_of::() - 12usize]; ++ ["Alignment of ma_vec3f"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_vec3f::x"][::core::mem::offset_of!(ma_vec3f, x) - 0usize]; ++ ["Offset of field: ma_vec3f::y"][::core::mem::offset_of!(ma_vec3f, y) - 4usize]; ++ ["Offset of field: ma_vec3f::z"][::core::mem::offset_of!(ma_vec3f, z) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_vec3f { ++ pub v: ma_vec3f, ++ pub lock: ma_spinlock, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_vec3f"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_atomic_vec3f"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_vec3f::v"][::core::mem::offset_of!(ma_atomic_vec3f, v) - 0usize]; ++ ["Offset of field: ma_atomic_vec3f::lock"] ++ [::core::mem::offset_of!(ma_atomic_vec3f, lock) - 12usize]; ++}; ++pub const ma_attenuation_model_ma_attenuation_model_none: ma_attenuation_model = 0; ++pub const ma_attenuation_model_ma_attenuation_model_inverse: ma_attenuation_model = 1; ++pub const ma_attenuation_model_ma_attenuation_model_linear: ma_attenuation_model = 2; ++pub const ma_attenuation_model_ma_attenuation_model_exponential: ma_attenuation_model = 3; ++pub type ma_attenuation_model = core::ffi::c_uint; ++pub const ma_positioning_ma_positioning_absolute: ma_positioning = 0; ++pub const ma_positioning_ma_positioning_relative: ma_positioning = 1; ++pub type ma_positioning = core::ffi::c_uint; ++pub const ma_handedness_ma_handedness_right: ma_handedness = 0; ++pub const ma_handedness_ma_handedness_left: ma_handedness = 1; ++pub type ma_handedness = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_spatializer_listener_config { ++ pub channelsOut: ma_uint32, ++ pub pChannelMapOut: *mut ma_channel, ++ pub handedness: ma_handedness, ++ pub coneInnerAngleInRadians: f32, ++ pub coneOuterAngleInRadians: f32, ++ pub coneOuterGain: f32, ++ pub speedOfSound: f32, ++ pub worldUp: ma_vec3f, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_spatializer_listener_config"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_spatializer_listener_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_spatializer_listener_config::channelsOut"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, channelsOut) - 0usize]; ++ ["Offset of field: ma_spatializer_listener_config::pChannelMapOut"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, pChannelMapOut) - 8usize]; ++ ["Offset of field: ma_spatializer_listener_config::handedness"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, handedness) - 16usize]; ++ ["Offset of field: ma_spatializer_listener_config::coneInnerAngleInRadians"][::core::mem::offset_of!( ++ ma_spatializer_listener_config, ++ coneInnerAngleInRadians ++ ) - 20usize]; ++ ["Offset of field: ma_spatializer_listener_config::coneOuterAngleInRadians"][::core::mem::offset_of!( ++ ma_spatializer_listener_config, ++ coneOuterAngleInRadians ++ ) - 24usize]; ++ ["Offset of field: ma_spatializer_listener_config::coneOuterGain"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, coneOuterGain) - 28usize]; ++ ["Offset of field: ma_spatializer_listener_config::speedOfSound"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, speedOfSound) - 32usize]; ++ ["Offset of field: ma_spatializer_listener_config::worldUp"] ++ [::core::mem::offset_of!(ma_spatializer_listener_config, worldUp) - 36usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_config_init( ++ channelsOut: ma_uint32, ++ ) -> ma_spatializer_listener_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_spatializer_listener { ++ pub config: ma_spatializer_listener_config, ++ pub position: ma_atomic_vec3f, ++ pub direction: ma_atomic_vec3f, ++ pub velocity: ma_atomic_vec3f, ++ pub isEnabled: ma_bool32, ++ pub _ownsHeap: ma_bool32, ++ pub _pHeap: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_spatializer_listener"] ++ [::core::mem::size_of::() - 112usize]; ++ ["Alignment of ma_spatializer_listener"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_spatializer_listener::config"] ++ [::core::mem::offset_of!(ma_spatializer_listener, config) - 0usize]; ++ ["Offset of field: ma_spatializer_listener::position"] ++ [::core::mem::offset_of!(ma_spatializer_listener, position) - 48usize]; ++ ["Offset of field: ma_spatializer_listener::direction"] ++ [::core::mem::offset_of!(ma_spatializer_listener, direction) - 64usize]; ++ ["Offset of field: ma_spatializer_listener::velocity"] ++ [::core::mem::offset_of!(ma_spatializer_listener, velocity) - 80usize]; ++ ["Offset of field: ma_spatializer_listener::isEnabled"] ++ [::core::mem::offset_of!(ma_spatializer_listener, isEnabled) - 96usize]; ++ ["Offset of field: ma_spatializer_listener::_ownsHeap"] ++ [::core::mem::offset_of!(ma_spatializer_listener, _ownsHeap) - 100usize]; ++ ["Offset of field: ma_spatializer_listener::_pHeap"] ++ [::core::mem::offset_of!(ma_spatializer_listener, _pHeap) - 104usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_heap_size( ++ pConfig: *const ma_spatializer_listener_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_init_preallocated( ++ pConfig: *const ma_spatializer_listener_config, ++ pHeap: *mut core::ffi::c_void, ++ pListener: *mut ma_spatializer_listener, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_init( ++ pConfig: *const ma_spatializer_listener_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pListener: *mut ma_spatializer_listener, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_uninit( ++ pListener: *mut ma_spatializer_listener, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_channel_map( ++ pListener: *mut ma_spatializer_listener, ++ ) -> *mut ma_channel; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_cone( ++ pListener: *mut ma_spatializer_listener, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_cone( ++ pListener: *const ma_spatializer_listener, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_position( ++ pListener: *mut ma_spatializer_listener, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_position( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_direction( ++ pListener: *mut ma_spatializer_listener, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_direction( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_velocity( ++ pListener: *mut ma_spatializer_listener, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_velocity( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_speed_of_sound( ++ pListener: *mut ma_spatializer_listener, ++ speedOfSound: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_speed_of_sound( ++ pListener: *const ma_spatializer_listener, ++ ) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_world_up( ++ pListener: *mut ma_spatializer_listener, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_get_world_up( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_set_enabled( ++ pListener: *mut ma_spatializer_listener, ++ isEnabled: ma_bool32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_listener_is_enabled( ++ pListener: *const ma_spatializer_listener, ++ ) -> ma_bool32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_spatializer_config { ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub pChannelMapIn: *mut ma_channel, ++ pub attenuationModel: ma_attenuation_model, ++ pub positioning: ma_positioning, ++ pub handedness: ma_handedness, ++ pub minGain: f32, ++ pub maxGain: f32, ++ pub minDistance: f32, ++ pub maxDistance: f32, ++ pub rolloff: f32, ++ pub coneInnerAngleInRadians: f32, ++ pub coneOuterAngleInRadians: f32, ++ pub coneOuterGain: f32, ++ pub dopplerFactor: f32, ++ pub directionalAttenuationFactor: f32, ++ pub minSpatializationChannelGain: f32, ++ pub gainSmoothTimeInFrames: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_spatializer_config"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_spatializer_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_spatializer_config::channelsIn"] ++ [::core::mem::offset_of!(ma_spatializer_config, channelsIn) - 0usize]; ++ ["Offset of field: ma_spatializer_config::channelsOut"] ++ [::core::mem::offset_of!(ma_spatializer_config, channelsOut) - 4usize]; ++ ["Offset of field: ma_spatializer_config::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_spatializer_config, pChannelMapIn) - 8usize]; ++ ["Offset of field: ma_spatializer_config::attenuationModel"] ++ [::core::mem::offset_of!(ma_spatializer_config, attenuationModel) - 16usize]; ++ ["Offset of field: ma_spatializer_config::positioning"] ++ [::core::mem::offset_of!(ma_spatializer_config, positioning) - 20usize]; ++ ["Offset of field: ma_spatializer_config::handedness"] ++ [::core::mem::offset_of!(ma_spatializer_config, handedness) - 24usize]; ++ ["Offset of field: ma_spatializer_config::minGain"] ++ [::core::mem::offset_of!(ma_spatializer_config, minGain) - 28usize]; ++ ["Offset of field: ma_spatializer_config::maxGain"] ++ [::core::mem::offset_of!(ma_spatializer_config, maxGain) - 32usize]; ++ ["Offset of field: ma_spatializer_config::minDistance"] ++ [::core::mem::offset_of!(ma_spatializer_config, minDistance) - 36usize]; ++ ["Offset of field: ma_spatializer_config::maxDistance"] ++ [::core::mem::offset_of!(ma_spatializer_config, maxDistance) - 40usize]; ++ ["Offset of field: ma_spatializer_config::rolloff"] ++ [::core::mem::offset_of!(ma_spatializer_config, rolloff) - 44usize]; ++ ["Offset of field: ma_spatializer_config::coneInnerAngleInRadians"] ++ [::core::mem::offset_of!(ma_spatializer_config, coneInnerAngleInRadians) - 48usize]; ++ ["Offset of field: ma_spatializer_config::coneOuterAngleInRadians"] ++ [::core::mem::offset_of!(ma_spatializer_config, coneOuterAngleInRadians) - 52usize]; ++ ["Offset of field: ma_spatializer_config::coneOuterGain"] ++ [::core::mem::offset_of!(ma_spatializer_config, coneOuterGain) - 56usize]; ++ ["Offset of field: ma_spatializer_config::dopplerFactor"] ++ [::core::mem::offset_of!(ma_spatializer_config, dopplerFactor) - 60usize]; ++ ["Offset of field: ma_spatializer_config::directionalAttenuationFactor"] ++ [::core::mem::offset_of!(ma_spatializer_config, directionalAttenuationFactor) - 64usize]; ++ ["Offset of field: ma_spatializer_config::minSpatializationChannelGain"] ++ [::core::mem::offset_of!(ma_spatializer_config, minSpatializationChannelGain) - 68usize]; ++ ["Offset of field: ma_spatializer_config::gainSmoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_spatializer_config, gainSmoothTimeInFrames) - 72usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_spatializer_config_init( ++ channelsIn: ma_uint32, ++ channelsOut: ma_uint32, ++ ) -> ma_spatializer_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_spatializer { ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub pChannelMapIn: *mut ma_channel, ++ pub attenuationModel: ma_attenuation_model, ++ pub positioning: ma_positioning, ++ pub handedness: ma_handedness, ++ pub minGain: f32, ++ pub maxGain: f32, ++ pub minDistance: f32, ++ pub maxDistance: f32, ++ pub rolloff: f32, ++ pub coneInnerAngleInRadians: f32, ++ pub coneOuterAngleInRadians: f32, ++ pub coneOuterGain: f32, ++ pub dopplerFactor: f32, ++ pub directionalAttenuationFactor: f32, ++ pub gainSmoothTimeInFrames: ma_uint32, ++ pub position: ma_atomic_vec3f, ++ pub direction: ma_atomic_vec3f, ++ pub velocity: ma_atomic_vec3f, ++ pub dopplerPitch: f32, ++ pub minSpatializationChannelGain: f32, ++ pub gainer: ma_gainer, ++ pub pNewChannelGainsOut: *mut f32, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_spatializer"][::core::mem::size_of::() - 200usize]; ++ ["Alignment of ma_spatializer"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_spatializer::channelsIn"] ++ [::core::mem::offset_of!(ma_spatializer, channelsIn) - 0usize]; ++ ["Offset of field: ma_spatializer::channelsOut"] ++ [::core::mem::offset_of!(ma_spatializer, channelsOut) - 4usize]; ++ ["Offset of field: ma_spatializer::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_spatializer, pChannelMapIn) - 8usize]; ++ ["Offset of field: ma_spatializer::attenuationModel"] ++ [::core::mem::offset_of!(ma_spatializer, attenuationModel) - 16usize]; ++ ["Offset of field: ma_spatializer::positioning"] ++ [::core::mem::offset_of!(ma_spatializer, positioning) - 20usize]; ++ ["Offset of field: ma_spatializer::handedness"] ++ [::core::mem::offset_of!(ma_spatializer, handedness) - 24usize]; ++ ["Offset of field: ma_spatializer::minGain"] ++ [::core::mem::offset_of!(ma_spatializer, minGain) - 28usize]; ++ ["Offset of field: ma_spatializer::maxGain"] ++ [::core::mem::offset_of!(ma_spatializer, maxGain) - 32usize]; ++ ["Offset of field: ma_spatializer::minDistance"] ++ [::core::mem::offset_of!(ma_spatializer, minDistance) - 36usize]; ++ ["Offset of field: ma_spatializer::maxDistance"] ++ [::core::mem::offset_of!(ma_spatializer, maxDistance) - 40usize]; ++ ["Offset of field: ma_spatializer::rolloff"] ++ [::core::mem::offset_of!(ma_spatializer, rolloff) - 44usize]; ++ ["Offset of field: ma_spatializer::coneInnerAngleInRadians"] ++ [::core::mem::offset_of!(ma_spatializer, coneInnerAngleInRadians) - 48usize]; ++ ["Offset of field: ma_spatializer::coneOuterAngleInRadians"] ++ [::core::mem::offset_of!(ma_spatializer, coneOuterAngleInRadians) - 52usize]; ++ ["Offset of field: ma_spatializer::coneOuterGain"] ++ [::core::mem::offset_of!(ma_spatializer, coneOuterGain) - 56usize]; ++ ["Offset of field: ma_spatializer::dopplerFactor"] ++ [::core::mem::offset_of!(ma_spatializer, dopplerFactor) - 60usize]; ++ ["Offset of field: ma_spatializer::directionalAttenuationFactor"] ++ [::core::mem::offset_of!(ma_spatializer, directionalAttenuationFactor) - 64usize]; ++ ["Offset of field: ma_spatializer::gainSmoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_spatializer, gainSmoothTimeInFrames) - 68usize]; ++ ["Offset of field: ma_spatializer::position"] ++ [::core::mem::offset_of!(ma_spatializer, position) - 72usize]; ++ ["Offset of field: ma_spatializer::direction"] ++ [::core::mem::offset_of!(ma_spatializer, direction) - 88usize]; ++ ["Offset of field: ma_spatializer::velocity"] ++ [::core::mem::offset_of!(ma_spatializer, velocity) - 104usize]; ++ ["Offset of field: ma_spatializer::dopplerPitch"] ++ [::core::mem::offset_of!(ma_spatializer, dopplerPitch) - 120usize]; ++ ["Offset of field: ma_spatializer::minSpatializationChannelGain"] ++ [::core::mem::offset_of!(ma_spatializer, minSpatializationChannelGain) - 124usize]; ++ ["Offset of field: ma_spatializer::gainer"] ++ [::core::mem::offset_of!(ma_spatializer, gainer) - 128usize]; ++ ["Offset of field: ma_spatializer::pNewChannelGainsOut"] ++ [::core::mem::offset_of!(ma_spatializer, pNewChannelGainsOut) - 176usize]; ++ ["Offset of field: ma_spatializer::_pHeap"] ++ [::core::mem::offset_of!(ma_spatializer, _pHeap) - 184usize]; ++ ["Offset of field: ma_spatializer::_ownsHeap"] ++ [::core::mem::offset_of!(ma_spatializer, _ownsHeap) - 192usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_spatializer_get_heap_size( ++ pConfig: *const ma_spatializer_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_init_preallocated( ++ pConfig: *const ma_spatializer_config, ++ pHeap: *mut core::ffi::c_void, ++ pSpatializer: *mut ma_spatializer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_init( ++ pConfig: *const ma_spatializer_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pSpatializer: *mut ma_spatializer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_uninit( ++ pSpatializer: *mut ma_spatializer, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_process_pcm_frames( ++ pSpatializer: *mut ma_spatializer, ++ pListener: *mut ma_spatializer_listener, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_master_volume( ++ pSpatializer: *mut ma_spatializer, ++ volume: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_master_volume( ++ pSpatializer: *const ma_spatializer, ++ pVolume: *mut f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_input_channels(pSpatializer: *const ma_spatializer) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_output_channels(pSpatializer: *const ma_spatializer) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_attenuation_model( ++ pSpatializer: *mut ma_spatializer, ++ attenuationModel: ma_attenuation_model, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_attenuation_model( ++ pSpatializer: *const ma_spatializer, ++ ) -> ma_attenuation_model; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_positioning( ++ pSpatializer: *mut ma_spatializer, ++ positioning: ma_positioning, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_positioning(pSpatializer: *const ma_spatializer) -> ma_positioning; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_rolloff(pSpatializer: *mut ma_spatializer, rolloff: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_rolloff(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_min_gain(pSpatializer: *mut ma_spatializer, minGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_min_gain(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_max_gain(pSpatializer: *mut ma_spatializer, maxGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_max_gain(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_min_distance(pSpatializer: *mut ma_spatializer, minDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_min_distance(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_max_distance(pSpatializer: *mut ma_spatializer, maxDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_max_distance(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_cone( ++ pSpatializer: *mut ma_spatializer, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_cone( ++ pSpatializer: *const ma_spatializer, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_doppler_factor(pSpatializer: *mut ma_spatializer, dopplerFactor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_doppler_factor(pSpatializer: *const ma_spatializer) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_directional_attenuation_factor( ++ pSpatializer: *mut ma_spatializer, ++ directionalAttenuationFactor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_directional_attenuation_factor( ++ pSpatializer: *const ma_spatializer, ++ ) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_position(pSpatializer: *mut ma_spatializer, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_position(pSpatializer: *const ma_spatializer) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_direction(pSpatializer: *mut ma_spatializer, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_direction(pSpatializer: *const ma_spatializer) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_set_velocity(pSpatializer: *mut ma_spatializer, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_velocity(pSpatializer: *const ma_spatializer) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_spatializer_get_relative_position_and_direction( ++ pSpatializer: *const ma_spatializer, ++ pListener: *const ma_spatializer_listener, ++ pRelativePos: *mut ma_vec3f, ++ pRelativeDir: *mut ma_vec3f, ++ ); ++} ++#[doc = "Resampling"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_linear_resampler_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub lpfOrder: ma_uint32, ++ pub lpfNyquistFactor: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_linear_resampler_config"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_linear_resampler_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_linear_resampler_config::format"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, format) - 0usize]; ++ ["Offset of field: ma_linear_resampler_config::channels"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, channels) - 4usize]; ++ ["Offset of field: ma_linear_resampler_config::sampleRateIn"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, sampleRateIn) - 8usize]; ++ ["Offset of field: ma_linear_resampler_config::sampleRateOut"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, sampleRateOut) - 12usize]; ++ ["Offset of field: ma_linear_resampler_config::lpfOrder"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, lpfOrder) - 16usize]; ++ ["Offset of field: ma_linear_resampler_config::lpfNyquistFactor"] ++ [::core::mem::offset_of!(ma_linear_resampler_config, lpfNyquistFactor) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_linear_resampler_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_linear_resampler_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_linear_resampler { ++ pub config: ma_linear_resampler_config, ++ pub inAdvanceInt: ma_uint32, ++ pub inAdvanceFrac: ma_uint32, ++ pub inTimeInt: ma_uint32, ++ pub inTimeFrac: ma_uint32, ++ pub x0: ma_linear_resampler__bindgen_ty_1, ++ pub x1: ma_linear_resampler__bindgen_ty_2, ++ pub lpf: ma_lpf, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_linear_resampler__bindgen_ty_1 { ++ pub f32_: *mut f32, ++ pub s16: *mut ma_int16, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_linear_resampler__bindgen_ty_1"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_linear_resampler__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_linear_resampler__bindgen_ty_1::f32_"] ++ [::core::mem::offset_of!(ma_linear_resampler__bindgen_ty_1, f32_) - 0usize]; ++ ["Offset of field: ma_linear_resampler__bindgen_ty_1::s16"] ++ [::core::mem::offset_of!(ma_linear_resampler__bindgen_ty_1, s16) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_linear_resampler__bindgen_ty_2 { ++ pub f32_: *mut f32, ++ pub s16: *mut ma_int16, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_linear_resampler__bindgen_ty_2"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_linear_resampler__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_linear_resampler__bindgen_ty_2::f32_"] ++ [::core::mem::offset_of!(ma_linear_resampler__bindgen_ty_2, f32_) - 0usize]; ++ ["Offset of field: ma_linear_resampler__bindgen_ty_2::s16"] ++ [::core::mem::offset_of!(ma_linear_resampler__bindgen_ty_2, s16) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_linear_resampler"][::core::mem::size_of::() - 136usize]; ++ ["Alignment of ma_linear_resampler"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_linear_resampler::config"] ++ [::core::mem::offset_of!(ma_linear_resampler, config) - 0usize]; ++ ["Offset of field: ma_linear_resampler::inAdvanceInt"] ++ [::core::mem::offset_of!(ma_linear_resampler, inAdvanceInt) - 32usize]; ++ ["Offset of field: ma_linear_resampler::inAdvanceFrac"] ++ [::core::mem::offset_of!(ma_linear_resampler, inAdvanceFrac) - 36usize]; ++ ["Offset of field: ma_linear_resampler::inTimeInt"] ++ [::core::mem::offset_of!(ma_linear_resampler, inTimeInt) - 40usize]; ++ ["Offset of field: ma_linear_resampler::inTimeFrac"] ++ [::core::mem::offset_of!(ma_linear_resampler, inTimeFrac) - 44usize]; ++ ["Offset of field: ma_linear_resampler::x0"] ++ [::core::mem::offset_of!(ma_linear_resampler, x0) - 48usize]; ++ ["Offset of field: ma_linear_resampler::x1"] ++ [::core::mem::offset_of!(ma_linear_resampler, x1) - 56usize]; ++ ["Offset of field: ma_linear_resampler::lpf"] ++ [::core::mem::offset_of!(ma_linear_resampler, lpf) - 64usize]; ++ ["Offset of field: ma_linear_resampler::_pHeap"] ++ [::core::mem::offset_of!(ma_linear_resampler, _pHeap) - 120usize]; ++ ["Offset of field: ma_linear_resampler::_ownsHeap"] ++ [::core::mem::offset_of!(ma_linear_resampler, _ownsHeap) - 128usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_heap_size( ++ pConfig: *const ma_linear_resampler_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_init_preallocated( ++ pConfig: *const ma_linear_resampler_config, ++ pHeap: *mut core::ffi::c_void, ++ pResampler: *mut ma_linear_resampler, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_init( ++ pConfig: *const ma_linear_resampler_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pResampler: *mut ma_linear_resampler, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_uninit( ++ pResampler: *mut ma_linear_resampler, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_process_pcm_frames( ++ pResampler: *mut ma_linear_resampler, ++ pFramesIn: *const core::ffi::c_void, ++ pFrameCountIn: *mut ma_uint64, ++ pFramesOut: *mut core::ffi::c_void, ++ pFrameCountOut: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_set_rate( ++ pResampler: *mut ma_linear_resampler, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_set_rate_ratio( ++ pResampler: *mut ma_linear_resampler, ++ ratioInOut: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_input_latency( ++ pResampler: *const ma_linear_resampler, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_output_latency( ++ pResampler: *const ma_linear_resampler, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_required_input_frame_count( ++ pResampler: *const ma_linear_resampler, ++ outputFrameCount: ma_uint64, ++ pInputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_get_expected_output_frame_count( ++ pResampler: *const ma_linear_resampler, ++ inputFrameCount: ma_uint64, ++ pOutputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_linear_resampler_reset(pResampler: *mut ma_linear_resampler) -> ma_result; ++} ++pub type ma_resampling_backend = core::ffi::c_void; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resampling_backend_vtable { ++ pub onGetHeapSize: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_resampler_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result, ++ >, ++ pub onInit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_resampler_config, ++ pHeap: *mut core::ffi::c_void, ++ ppBackend: *mut *mut ma_resampling_backend, ++ ) -> ma_result, ++ >, ++ pub onUninit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_resampling_backend, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ), ++ >, ++ pub onProcess: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_resampling_backend, ++ pFramesIn: *const core::ffi::c_void, ++ pFrameCountIn: *mut ma_uint64, ++ pFramesOut: *mut core::ffi::c_void, ++ pFrameCountOut: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onSetRate: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_resampling_backend, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_result, ++ >, ++ pub onGetInputLatency: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *const ma_resampling_backend, ++ ) -> ma_uint64, ++ >, ++ pub onGetOutputLatency: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *const ma_resampling_backend, ++ ) -> ma_uint64, ++ >, ++ pub onGetRequiredInputFrameCount: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *const ma_resampling_backend, ++ outputFrameCount: ma_uint64, ++ pInputFrameCount: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onGetExpectedOutputFrameCount: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *const ma_resampling_backend, ++ inputFrameCount: ma_uint64, ++ pOutputFrameCount: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onReset: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_resampling_backend, ++ ) -> ma_result, ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampling_backend_vtable"] ++ [::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_resampling_backend_vtable"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetHeapSize"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onGetHeapSize) - 0usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onInit"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onInit) - 8usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onUninit"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onUninit) - 16usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onProcess"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onProcess) - 24usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onSetRate"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onSetRate) - 32usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetInputLatency"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onGetInputLatency) - 40usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetOutputLatency"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onGetOutputLatency) - 48usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetRequiredInputFrameCount"][::core::mem::offset_of!( ++ ma_resampling_backend_vtable, ++ onGetRequiredInputFrameCount ++ ) - 56usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onGetExpectedOutputFrameCount"][::core::mem::offset_of!( ++ ma_resampling_backend_vtable, ++ onGetExpectedOutputFrameCount ++ ) - 64usize]; ++ ["Offset of field: ma_resampling_backend_vtable::onReset"] ++ [::core::mem::offset_of!(ma_resampling_backend_vtable, onReset) - 72usize]; ++}; ++pub const ma_resample_algorithm_ma_resample_algorithm_linear: ma_resample_algorithm = 0; ++pub const ma_resample_algorithm_ma_resample_algorithm_custom: ma_resample_algorithm = 1; ++pub type ma_resample_algorithm = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resampler_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub algorithm: ma_resample_algorithm, ++ pub pBackendVTable: *mut ma_resampling_backend_vtable, ++ pub pBackendUserData: *mut core::ffi::c_void, ++ pub linear: ma_resampler_config__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resampler_config__bindgen_ty_1 { ++ pub lpfOrder: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampler_config__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_resampler_config__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_resampler_config__bindgen_ty_1::lpfOrder"] ++ [::core::mem::offset_of!(ma_resampler_config__bindgen_ty_1, lpfOrder) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampler_config"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_resampler_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resampler_config::format"] ++ [::core::mem::offset_of!(ma_resampler_config, format) - 0usize]; ++ ["Offset of field: ma_resampler_config::channels"] ++ [::core::mem::offset_of!(ma_resampler_config, channels) - 4usize]; ++ ["Offset of field: ma_resampler_config::sampleRateIn"] ++ [::core::mem::offset_of!(ma_resampler_config, sampleRateIn) - 8usize]; ++ ["Offset of field: ma_resampler_config::sampleRateOut"] ++ [::core::mem::offset_of!(ma_resampler_config, sampleRateOut) - 12usize]; ++ ["Offset of field: ma_resampler_config::algorithm"] ++ [::core::mem::offset_of!(ma_resampler_config, algorithm) - 16usize]; ++ ["Offset of field: ma_resampler_config::pBackendVTable"] ++ [::core::mem::offset_of!(ma_resampler_config, pBackendVTable) - 24usize]; ++ ["Offset of field: ma_resampler_config::pBackendUserData"] ++ [::core::mem::offset_of!(ma_resampler_config, pBackendUserData) - 32usize]; ++ ["Offset of field: ma_resampler_config::linear"] ++ [::core::mem::offset_of!(ma_resampler_config, linear) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resampler_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ algorithm: ma_resample_algorithm, ++ ) -> ma_resampler_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resampler { ++ pub pBackend: *mut ma_resampling_backend, ++ pub pBackendVTable: *mut ma_resampling_backend_vtable, ++ pub pBackendUserData: *mut core::ffi::c_void, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub state: ma_resampler__bindgen_ty_1, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_resampler__bindgen_ty_1 { ++ pub linear: ma_linear_resampler, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampler__bindgen_ty_1"] ++ [::core::mem::size_of::() - 136usize]; ++ ["Alignment of ma_resampler__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resampler__bindgen_ty_1::linear"] ++ [::core::mem::offset_of!(ma_resampler__bindgen_ty_1, linear) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resampler"][::core::mem::size_of::() - 192usize]; ++ ["Alignment of ma_resampler"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resampler::pBackend"] ++ [::core::mem::offset_of!(ma_resampler, pBackend) - 0usize]; ++ ["Offset of field: ma_resampler::pBackendVTable"] ++ [::core::mem::offset_of!(ma_resampler, pBackendVTable) - 8usize]; ++ ["Offset of field: ma_resampler::pBackendUserData"] ++ [::core::mem::offset_of!(ma_resampler, pBackendUserData) - 16usize]; ++ ["Offset of field: ma_resampler::format"] ++ [::core::mem::offset_of!(ma_resampler, format) - 24usize]; ++ ["Offset of field: ma_resampler::channels"] ++ [::core::mem::offset_of!(ma_resampler, channels) - 28usize]; ++ ["Offset of field: ma_resampler::sampleRateIn"] ++ [::core::mem::offset_of!(ma_resampler, sampleRateIn) - 32usize]; ++ ["Offset of field: ma_resampler::sampleRateOut"] ++ [::core::mem::offset_of!(ma_resampler, sampleRateOut) - 36usize]; ++ ["Offset of field: ma_resampler::state"] ++ [::core::mem::offset_of!(ma_resampler, state) - 40usize]; ++ ["Offset of field: ma_resampler::_pHeap"] ++ [::core::mem::offset_of!(ma_resampler, _pHeap) - 176usize]; ++ ["Offset of field: ma_resampler::_ownsHeap"] ++ [::core::mem::offset_of!(ma_resampler, _ownsHeap) - 184usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resampler_get_heap_size( ++ pConfig: *const ma_resampler_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_init_preallocated( ++ pConfig: *const ma_resampler_config, ++ pHeap: *mut core::ffi::c_void, ++ pResampler: *mut ma_resampler, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_init( ++ pConfig: *const ma_resampler_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pResampler: *mut ma_resampler, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_uninit( ++ pResampler: *mut ma_resampler, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_resampler_process_pcm_frames( ++ pResampler: *mut ma_resampler, ++ pFramesIn: *const core::ffi::c_void, ++ pFrameCountIn: *mut ma_uint64, ++ pFramesOut: *mut core::ffi::c_void, ++ pFrameCountOut: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_set_rate( ++ pResampler: *mut ma_resampler, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_set_rate_ratio(pResampler: *mut ma_resampler, ratio: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_get_input_latency(pResampler: *const ma_resampler) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_get_output_latency(pResampler: *const ma_resampler) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_get_required_input_frame_count( ++ pResampler: *const ma_resampler, ++ outputFrameCount: ma_uint64, ++ pInputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_get_expected_output_frame_count( ++ pResampler: *const ma_resampler, ++ inputFrameCount: ma_uint64, ++ pOutputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resampler_reset(pResampler: *mut ma_resampler) -> ma_result; ++} ++pub const ma_channel_conversion_path_ma_channel_conversion_path_unknown: ++ ma_channel_conversion_path = 0; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_passthrough: ++ ma_channel_conversion_path = 1; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_mono_out: ++ ma_channel_conversion_path = 2; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_mono_in: ++ ma_channel_conversion_path = 3; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_shuffle: ++ ma_channel_conversion_path = 4; ++pub const ma_channel_conversion_path_ma_channel_conversion_path_weights: ++ ma_channel_conversion_path = 5; ++#[doc = "Channel Conversion"] ++pub type ma_channel_conversion_path = core::ffi::c_uint; ++pub const ma_mono_expansion_mode_ma_mono_expansion_mode_duplicate: ma_mono_expansion_mode = 0; ++pub const ma_mono_expansion_mode_ma_mono_expansion_mode_average: ma_mono_expansion_mode = 1; ++pub const ma_mono_expansion_mode_ma_mono_expansion_mode_stereo_only: ma_mono_expansion_mode = 2; ++pub const ma_mono_expansion_mode_ma_mono_expansion_mode_default: ma_mono_expansion_mode = 0; ++pub type ma_mono_expansion_mode = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_channel_converter_config { ++ pub format: ma_format, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub pChannelMapIn: *const ma_channel, ++ pub pChannelMapOut: *const ma_channel, ++ pub mixingMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub ppWeights: *mut *mut f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_channel_converter_config"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_channel_converter_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_channel_converter_config::format"] ++ [::core::mem::offset_of!(ma_channel_converter_config, format) - 0usize]; ++ ["Offset of field: ma_channel_converter_config::channelsIn"] ++ [::core::mem::offset_of!(ma_channel_converter_config, channelsIn) - 4usize]; ++ ["Offset of field: ma_channel_converter_config::channelsOut"] ++ [::core::mem::offset_of!(ma_channel_converter_config, channelsOut) - 8usize]; ++ ["Offset of field: ma_channel_converter_config::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_channel_converter_config, pChannelMapIn) - 16usize]; ++ ["Offset of field: ma_channel_converter_config::pChannelMapOut"] ++ [::core::mem::offset_of!(ma_channel_converter_config, pChannelMapOut) - 24usize]; ++ ["Offset of field: ma_channel_converter_config::mixingMode"] ++ [::core::mem::offset_of!(ma_channel_converter_config, mixingMode) - 32usize]; ++ ["Offset of field: ma_channel_converter_config::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_channel_converter_config, ++ calculateLFEFromSpatialChannels ++ ) - 36usize]; ++ ["Offset of field: ma_channel_converter_config::ppWeights"] ++ [::core::mem::offset_of!(ma_channel_converter_config, ppWeights) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_channel_converter_config_init( ++ format: ma_format, ++ channelsIn: ma_uint32, ++ pChannelMapIn: *const ma_channel, ++ channelsOut: ma_uint32, ++ pChannelMapOut: *const ma_channel, ++ mixingMode: ma_channel_mix_mode, ++ ) -> ma_channel_converter_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_channel_converter { ++ pub format: ma_format, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub mixingMode: ma_channel_mix_mode, ++ pub conversionPath: ma_channel_conversion_path, ++ pub pChannelMapIn: *mut ma_channel, ++ pub pChannelMapOut: *mut ma_channel, ++ pub pShuffleTable: *mut ma_uint8, ++ pub weights: ma_channel_converter__bindgen_ty_1, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_channel_converter__bindgen_ty_1 { ++ pub f32_: *mut *mut f32, ++ pub s16: *mut *mut ma_int32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_channel_converter__bindgen_ty_1"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_channel_converter__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_channel_converter__bindgen_ty_1::f32_"] ++ [::core::mem::offset_of!(ma_channel_converter__bindgen_ty_1, f32_) - 0usize]; ++ ["Offset of field: ma_channel_converter__bindgen_ty_1::s16"] ++ [::core::mem::offset_of!(ma_channel_converter__bindgen_ty_1, s16) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_channel_converter"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_channel_converter"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_channel_converter::format"] ++ [::core::mem::offset_of!(ma_channel_converter, format) - 0usize]; ++ ["Offset of field: ma_channel_converter::channelsIn"] ++ [::core::mem::offset_of!(ma_channel_converter, channelsIn) - 4usize]; ++ ["Offset of field: ma_channel_converter::channelsOut"] ++ [::core::mem::offset_of!(ma_channel_converter, channelsOut) - 8usize]; ++ ["Offset of field: ma_channel_converter::mixingMode"] ++ [::core::mem::offset_of!(ma_channel_converter, mixingMode) - 12usize]; ++ ["Offset of field: ma_channel_converter::conversionPath"] ++ [::core::mem::offset_of!(ma_channel_converter, conversionPath) - 16usize]; ++ ["Offset of field: ma_channel_converter::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_channel_converter, pChannelMapIn) - 24usize]; ++ ["Offset of field: ma_channel_converter::pChannelMapOut"] ++ [::core::mem::offset_of!(ma_channel_converter, pChannelMapOut) - 32usize]; ++ ["Offset of field: ma_channel_converter::pShuffleTable"] ++ [::core::mem::offset_of!(ma_channel_converter, pShuffleTable) - 40usize]; ++ ["Offset of field: ma_channel_converter::weights"] ++ [::core::mem::offset_of!(ma_channel_converter, weights) - 48usize]; ++ ["Offset of field: ma_channel_converter::_pHeap"] ++ [::core::mem::offset_of!(ma_channel_converter, _pHeap) - 56usize]; ++ ["Offset of field: ma_channel_converter::_ownsHeap"] ++ [::core::mem::offset_of!(ma_channel_converter, _ownsHeap) - 64usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_channel_converter_get_heap_size( ++ pConfig: *const ma_channel_converter_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_init_preallocated( ++ pConfig: *const ma_channel_converter_config, ++ pHeap: *mut core::ffi::c_void, ++ pConverter: *mut ma_channel_converter, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_init( ++ pConfig: *const ma_channel_converter_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pConverter: *mut ma_channel_converter, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_uninit( ++ pConverter: *mut ma_channel_converter, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_process_pcm_frames( ++ pConverter: *mut ma_channel_converter, ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_get_input_channel_map( ++ pConverter: *const ma_channel_converter, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_channel_converter_get_output_channel_map( ++ pConverter: *const ma_channel_converter, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++#[doc = "Data Conversion"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_converter_config { ++ pub formatIn: ma_format, ++ pub formatOut: ma_format, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub pChannelMapIn: *mut ma_channel, ++ pub pChannelMapOut: *mut ma_channel, ++ pub ditherMode: ma_dither_mode, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub ppChannelWeights: *mut *mut f32, ++ pub allowDynamicSampleRate: ma_bool32, ++ pub resampling: ma_resampler_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_converter_config"] ++ [::core::mem::size_of::() - 120usize]; ++ ["Alignment of ma_data_converter_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_converter_config::formatIn"] ++ [::core::mem::offset_of!(ma_data_converter_config, formatIn) - 0usize]; ++ ["Offset of field: ma_data_converter_config::formatOut"] ++ [::core::mem::offset_of!(ma_data_converter_config, formatOut) - 4usize]; ++ ["Offset of field: ma_data_converter_config::channelsIn"] ++ [::core::mem::offset_of!(ma_data_converter_config, channelsIn) - 8usize]; ++ ["Offset of field: ma_data_converter_config::channelsOut"] ++ [::core::mem::offset_of!(ma_data_converter_config, channelsOut) - 12usize]; ++ ["Offset of field: ma_data_converter_config::sampleRateIn"] ++ [::core::mem::offset_of!(ma_data_converter_config, sampleRateIn) - 16usize]; ++ ["Offset of field: ma_data_converter_config::sampleRateOut"] ++ [::core::mem::offset_of!(ma_data_converter_config, sampleRateOut) - 20usize]; ++ ["Offset of field: ma_data_converter_config::pChannelMapIn"] ++ [::core::mem::offset_of!(ma_data_converter_config, pChannelMapIn) - 24usize]; ++ ["Offset of field: ma_data_converter_config::pChannelMapOut"] ++ [::core::mem::offset_of!(ma_data_converter_config, pChannelMapOut) - 32usize]; ++ ["Offset of field: ma_data_converter_config::ditherMode"] ++ [::core::mem::offset_of!(ma_data_converter_config, ditherMode) - 40usize]; ++ ["Offset of field: ma_data_converter_config::channelMixMode"] ++ [::core::mem::offset_of!(ma_data_converter_config, channelMixMode) - 44usize]; ++ ["Offset of field: ma_data_converter_config::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_data_converter_config, ++ calculateLFEFromSpatialChannels ++ ) - 48usize]; ++ ["Offset of field: ma_data_converter_config::ppChannelWeights"] ++ [::core::mem::offset_of!(ma_data_converter_config, ppChannelWeights) - 56usize]; ++ ["Offset of field: ma_data_converter_config::allowDynamicSampleRate"] ++ [::core::mem::offset_of!(ma_data_converter_config, allowDynamicSampleRate) - 64usize]; ++ ["Offset of field: ma_data_converter_config::resampling"] ++ [::core::mem::offset_of!(ma_data_converter_config, resampling) - 72usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_converter_config_init_default() -> ma_data_converter_config; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_config_init( ++ formatIn: ma_format, ++ formatOut: ma_format, ++ channelsIn: ma_uint32, ++ channelsOut: ma_uint32, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_data_converter_config; ++} ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_passthrough: ++ ma_data_converter_execution_path = 0; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_format_only: ++ ma_data_converter_execution_path = 1; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_channels_only: ++ ma_data_converter_execution_path = 2; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_resample_only: ++ ma_data_converter_execution_path = 3; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_resample_first: ++ ma_data_converter_execution_path = 4; ++pub const ma_data_converter_execution_path_ma_data_converter_execution_path_channels_first: ++ ma_data_converter_execution_path = 5; ++pub type ma_data_converter_execution_path = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_data_converter { ++ pub formatIn: ma_format, ++ pub formatOut: ma_format, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub sampleRateIn: ma_uint32, ++ pub sampleRateOut: ma_uint32, ++ pub ditherMode: ma_dither_mode, ++ pub executionPath: ma_data_converter_execution_path, ++ pub channelConverter: ma_channel_converter, ++ pub resampler: ma_resampler, ++ pub hasPreFormatConversion: ma_bool8, ++ pub hasPostFormatConversion: ma_bool8, ++ pub hasChannelConverter: ma_bool8, ++ pub hasResampler: ma_bool8, ++ pub isPassthrough: ma_bool8, ++ pub _ownsHeap: ma_bool8, ++ pub _pHeap: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_converter"][::core::mem::size_of::() - 312usize]; ++ ["Alignment of ma_data_converter"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_converter::formatIn"] ++ [::core::mem::offset_of!(ma_data_converter, formatIn) - 0usize]; ++ ["Offset of field: ma_data_converter::formatOut"] ++ [::core::mem::offset_of!(ma_data_converter, formatOut) - 4usize]; ++ ["Offset of field: ma_data_converter::channelsIn"] ++ [::core::mem::offset_of!(ma_data_converter, channelsIn) - 8usize]; ++ ["Offset of field: ma_data_converter::channelsOut"] ++ [::core::mem::offset_of!(ma_data_converter, channelsOut) - 12usize]; ++ ["Offset of field: ma_data_converter::sampleRateIn"] ++ [::core::mem::offset_of!(ma_data_converter, sampleRateIn) - 16usize]; ++ ["Offset of field: ma_data_converter::sampleRateOut"] ++ [::core::mem::offset_of!(ma_data_converter, sampleRateOut) - 20usize]; ++ ["Offset of field: ma_data_converter::ditherMode"] ++ [::core::mem::offset_of!(ma_data_converter, ditherMode) - 24usize]; ++ ["Offset of field: ma_data_converter::executionPath"] ++ [::core::mem::offset_of!(ma_data_converter, executionPath) - 28usize]; ++ ["Offset of field: ma_data_converter::channelConverter"] ++ [::core::mem::offset_of!(ma_data_converter, channelConverter) - 32usize]; ++ ["Offset of field: ma_data_converter::resampler"] ++ [::core::mem::offset_of!(ma_data_converter, resampler) - 104usize]; ++ ["Offset of field: ma_data_converter::hasPreFormatConversion"] ++ [::core::mem::offset_of!(ma_data_converter, hasPreFormatConversion) - 296usize]; ++ ["Offset of field: ma_data_converter::hasPostFormatConversion"] ++ [::core::mem::offset_of!(ma_data_converter, hasPostFormatConversion) - 297usize]; ++ ["Offset of field: ma_data_converter::hasChannelConverter"] ++ [::core::mem::offset_of!(ma_data_converter, hasChannelConverter) - 298usize]; ++ ["Offset of field: ma_data_converter::hasResampler"] ++ [::core::mem::offset_of!(ma_data_converter, hasResampler) - 299usize]; ++ ["Offset of field: ma_data_converter::isPassthrough"] ++ [::core::mem::offset_of!(ma_data_converter, isPassthrough) - 300usize]; ++ ["Offset of field: ma_data_converter::_ownsHeap"] ++ [::core::mem::offset_of!(ma_data_converter, _ownsHeap) - 301usize]; ++ ["Offset of field: ma_data_converter::_pHeap"] ++ [::core::mem::offset_of!(ma_data_converter, _pHeap) - 304usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_converter_get_heap_size( ++ pConfig: *const ma_data_converter_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_init_preallocated( ++ pConfig: *const ma_data_converter_config, ++ pHeap: *mut core::ffi::c_void, ++ pConverter: *mut ma_data_converter, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_init( ++ pConfig: *const ma_data_converter_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pConverter: *mut ma_data_converter, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_uninit( ++ pConverter: *mut ma_data_converter, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_process_pcm_frames( ++ pConverter: *mut ma_data_converter, ++ pFramesIn: *const core::ffi::c_void, ++ pFrameCountIn: *mut ma_uint64, ++ pFramesOut: *mut core::ffi::c_void, ++ pFrameCountOut: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_set_rate( ++ pConverter: *mut ma_data_converter, ++ sampleRateIn: ma_uint32, ++ sampleRateOut: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_set_rate_ratio( ++ pConverter: *mut ma_data_converter, ++ ratioInOut: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_input_latency(pConverter: *const ma_data_converter) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_output_latency(pConverter: *const ma_data_converter) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_required_input_frame_count( ++ pConverter: *const ma_data_converter, ++ outputFrameCount: ma_uint64, ++ pInputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_expected_output_frame_count( ++ pConverter: *const ma_data_converter, ++ inputFrameCount: ma_uint64, ++ pOutputFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_input_channel_map( ++ pConverter: *const ma_data_converter, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_get_output_channel_map( ++ pConverter: *const ma_data_converter, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_converter_reset(pConverter: *mut ma_data_converter) -> ma_result; ++} ++unsafe extern "C" { ++ #[doc = "Format Conversion"] ++ pub fn ma_pcm_u8_to_s16( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_u8_to_s24( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_u8_to_s32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_u8_to_f32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s16_to_u8( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s16_to_s24( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s16_to_s32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s16_to_f32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s24_to_u8( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s24_to_s16( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s24_to_s32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s24_to_f32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s32_to_u8( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s32_to_s16( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s32_to_s24( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_s32_to_f32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_f32_to_u8( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_f32_to_s16( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_f32_to_s24( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_f32_to_s32( ++ pOut: *mut core::ffi::c_void, ++ pIn: *const core::ffi::c_void, ++ count: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_convert( ++ pOut: *mut core::ffi::c_void, ++ formatOut: ma_format, ++ pIn: *const core::ffi::c_void, ++ formatIn: ma_format, ++ sampleCount: ma_uint64, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_convert_pcm_frames_format( ++ pOut: *mut core::ffi::c_void, ++ formatOut: ma_format, ++ pIn: *const core::ffi::c_void, ++ formatIn: ma_format, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ ditherMode: ma_dither_mode, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_deinterleave_pcm_frames( ++ format: ma_format, ++ channels: ma_uint32, ++ frameCount: ma_uint64, ++ pInterleavedPCMFrames: *const core::ffi::c_void, ++ ppDeinterleavedPCMFrames: *mut *mut core::ffi::c_void, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_interleave_pcm_frames( ++ format: ma_format, ++ channels: ma_uint32, ++ frameCount: ma_uint64, ++ ppDeinterleavedPCMFrames: *mut *const core::ffi::c_void, ++ pInterleavedPCMFrames: *mut core::ffi::c_void, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_get_channel( ++ pChannelMap: *const ma_channel, ++ channelCount: ma_uint32, ++ channelIndex: ma_uint32, ++ ) -> ma_channel; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_init_blank(pChannelMap: *mut ma_channel, channels: ma_uint32); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_init_standard( ++ standardChannelMap: ma_standard_channel_map, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_copy(pOut: *mut ma_channel, pIn: *const ma_channel, channels: ma_uint32); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_copy_or_default( ++ pOut: *mut ma_channel, ++ channelMapCapOut: usize, ++ pIn: *const ma_channel, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_is_valid( ++ pChannelMap: *const ma_channel, ++ channels: ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_is_equal( ++ pChannelMapA: *const ma_channel, ++ pChannelMapB: *const ma_channel, ++ channels: ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_is_blank( ++ pChannelMap: *const ma_channel, ++ channels: ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_contains_channel_position( ++ channels: ma_uint32, ++ pChannelMap: *const ma_channel, ++ channelPosition: ma_channel, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_find_channel_position( ++ channels: ma_uint32, ++ pChannelMap: *const ma_channel, ++ channelPosition: ma_channel, ++ pChannelIndex: *mut ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_channel_map_to_string( ++ pChannelMap: *const ma_channel, ++ channels: ma_uint32, ++ pBufferOut: *mut core::ffi::c_char, ++ bufferCap: usize, ++ ) -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_channel_position_to_string(channel: ma_channel) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ #[doc = "Conversion Helpers"] ++ pub fn ma_convert_frames( ++ pOut: *mut core::ffi::c_void, ++ frameCountOut: ma_uint64, ++ formatOut: ma_format, ++ channelsOut: ma_uint32, ++ sampleRateOut: ma_uint32, ++ pIn: *const core::ffi::c_void, ++ frameCountIn: ma_uint64, ++ formatIn: ma_format, ++ channelsIn: ma_uint32, ++ sampleRateIn: ma_uint32, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_convert_frames_ex( ++ pOut: *mut core::ffi::c_void, ++ frameCountOut: ma_uint64, ++ pIn: *const core::ffi::c_void, ++ frameCountIn: ma_uint64, ++ pConfig: *const ma_data_converter_config, ++ ) -> ma_uint64; ++} ++#[doc = "Data Source"] ++pub type ma_data_source = core::ffi::c_void; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_vtable { ++ pub onRead: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDataSource: *mut ma_data_source, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onSeek: ::core::option::Option< ++ unsafe extern "C" fn(pDataSource: *mut ma_data_source, frameIndex: ma_uint64) -> ma_result, ++ >, ++ pub onGetDataFormat: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDataSource: *mut ma_data_source, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result, ++ >, ++ pub onGetCursor: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDataSource: *mut ma_data_source, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onGetLength: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDataSource: *mut ma_data_source, ++ pLength: *mut ma_uint64, ++ ) -> ma_result, ++ >, ++ pub onSetLooping: ::core::option::Option< ++ unsafe extern "C" fn(pDataSource: *mut ma_data_source, isLooping: ma_bool32) -> ma_result, ++ >, ++ pub flags: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_vtable"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_data_source_vtable"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_vtable::onRead"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onRead) - 0usize]; ++ ["Offset of field: ma_data_source_vtable::onSeek"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onSeek) - 8usize]; ++ ["Offset of field: ma_data_source_vtable::onGetDataFormat"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onGetDataFormat) - 16usize]; ++ ["Offset of field: ma_data_source_vtable::onGetCursor"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onGetCursor) - 24usize]; ++ ["Offset of field: ma_data_source_vtable::onGetLength"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onGetLength) - 32usize]; ++ ["Offset of field: ma_data_source_vtable::onSetLooping"] ++ [::core::mem::offset_of!(ma_data_source_vtable, onSetLooping) - 40usize]; ++ ["Offset of field: ma_data_source_vtable::flags"] ++ [::core::mem::offset_of!(ma_data_source_vtable, flags) - 48usize]; ++}; ++pub type ma_data_source_get_next_proc = ::core::option::Option< ++ unsafe extern "C" fn(pDataSource: *mut ma_data_source) -> *mut ma_data_source, ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_config { ++ pub vtable: *const ma_data_source_vtable, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_config"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_data_source_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_config::vtable"] ++ [::core::mem::offset_of!(ma_data_source_config, vtable) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_source_config_init() -> ma_data_source_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_base { ++ pub vtable: *const ma_data_source_vtable, ++ pub rangeBegInFrames: ma_uint64, ++ pub rangeEndInFrames: ma_uint64, ++ pub loopBegInFrames: ma_uint64, ++ pub loopEndInFrames: ma_uint64, ++ pub pCurrent: *mut ma_data_source, ++ pub pNext: *mut ma_data_source, ++ pub onGetNext: ma_data_source_get_next_proc, ++ pub isLooping: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_base"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_data_source_base"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_base::vtable"] ++ [::core::mem::offset_of!(ma_data_source_base, vtable) - 0usize]; ++ ["Offset of field: ma_data_source_base::rangeBegInFrames"] ++ [::core::mem::offset_of!(ma_data_source_base, rangeBegInFrames) - 8usize]; ++ ["Offset of field: ma_data_source_base::rangeEndInFrames"] ++ [::core::mem::offset_of!(ma_data_source_base, rangeEndInFrames) - 16usize]; ++ ["Offset of field: ma_data_source_base::loopBegInFrames"] ++ [::core::mem::offset_of!(ma_data_source_base, loopBegInFrames) - 24usize]; ++ ["Offset of field: ma_data_source_base::loopEndInFrames"] ++ [::core::mem::offset_of!(ma_data_source_base, loopEndInFrames) - 32usize]; ++ ["Offset of field: ma_data_source_base::pCurrent"] ++ [::core::mem::offset_of!(ma_data_source_base, pCurrent) - 40usize]; ++ ["Offset of field: ma_data_source_base::pNext"] ++ [::core::mem::offset_of!(ma_data_source_base, pNext) - 48usize]; ++ ["Offset of field: ma_data_source_base::onGetNext"] ++ [::core::mem::offset_of!(ma_data_source_base, onGetNext) - 56usize]; ++ ["Offset of field: ma_data_source_base::isLooping"] ++ [::core::mem::offset_of!(ma_data_source_base, isLooping) - 64usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_source_init( ++ pConfig: *const ma_data_source_config, ++ pDataSource: *mut ma_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_uninit(pDataSource: *mut ma_data_source); ++} ++unsafe extern "C" { ++ pub fn ma_data_source_read_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_seek_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ frameCount: ma_uint64, ++ pFramesSeeked: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_seek_to_pcm_frame( ++ pDataSource: *mut ma_data_source, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_seek_seconds( ++ pDataSource: *mut ma_data_source, ++ secondCount: f32, ++ pSecondsSeeked: *mut f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_seek_to_second( ++ pDataSource: *mut ma_data_source, ++ seekPointInSeconds: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_data_format( ++ pDataSource: *mut ma_data_source, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_cursor_in_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_length_in_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_cursor_in_seconds( ++ pDataSource: *mut ma_data_source, ++ pCursor: *mut f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_length_in_seconds( ++ pDataSource: *mut ma_data_source, ++ pLength: *mut f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_looping( ++ pDataSource: *mut ma_data_source, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_is_looping(pDataSource: *const ma_data_source) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_range_in_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ rangeBegInFrames: ma_uint64, ++ rangeEndInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_range_in_pcm_frames( ++ pDataSource: *const ma_data_source, ++ pRangeBegInFrames: *mut ma_uint64, ++ pRangeEndInFrames: *mut ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_loop_point_in_pcm_frames( ++ pDataSource: *mut ma_data_source, ++ loopBegInFrames: ma_uint64, ++ loopEndInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_loop_point_in_pcm_frames( ++ pDataSource: *const ma_data_source, ++ pLoopBegInFrames: *mut ma_uint64, ++ pLoopEndInFrames: *mut ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_current( ++ pDataSource: *mut ma_data_source, ++ pCurrentDataSource: *mut ma_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_current(pDataSource: *const ma_data_source) -> *mut ma_data_source; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_next( ++ pDataSource: *mut ma_data_source, ++ pNextDataSource: *mut ma_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_next(pDataSource: *const ma_data_source) -> *mut ma_data_source; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_set_next_callback( ++ pDataSource: *mut ma_data_source, ++ onGetNext: ma_data_source_get_next_proc, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_get_next_callback( ++ pDataSource: *const ma_data_source, ++ ) -> ma_data_source_get_next_proc; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_audio_buffer_ref { ++ pub ds: ma_data_source_base, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub cursor: ma_uint64, ++ pub sizeInFrames: ma_uint64, ++ pub pData: *const core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_audio_buffer_ref"][::core::mem::size_of::() - 112usize]; ++ ["Alignment of ma_audio_buffer_ref"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_audio_buffer_ref::ds"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, ds) - 0usize]; ++ ["Offset of field: ma_audio_buffer_ref::format"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, format) - 72usize]; ++ ["Offset of field: ma_audio_buffer_ref::channels"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, channels) - 76usize]; ++ ["Offset of field: ma_audio_buffer_ref::sampleRate"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, sampleRate) - 80usize]; ++ ["Offset of field: ma_audio_buffer_ref::cursor"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, cursor) - 88usize]; ++ ["Offset of field: ma_audio_buffer_ref::sizeInFrames"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, sizeInFrames) - 96usize]; ++ ["Offset of field: ma_audio_buffer_ref::pData"] ++ [::core::mem::offset_of!(ma_audio_buffer_ref, pData) - 104usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_init( ++ format: ma_format, ++ channels: ma_uint32, ++ pData: *const core::ffi::c_void, ++ sizeInFrames: ma_uint64, ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_uninit(pAudioBufferRef: *mut ma_audio_buffer_ref); ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_set_data( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ pData: *const core::ffi::c_void, ++ sizeInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_read_pcm_frames( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ loop_: ma_bool32, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_seek_to_pcm_frame( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_map( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ ppFramesOut: *mut *mut core::ffi::c_void, ++ pFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_unmap( ++ pAudioBufferRef: *mut ma_audio_buffer_ref, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_at_end(pAudioBufferRef: *const ma_audio_buffer_ref) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_get_cursor_in_pcm_frames( ++ pAudioBufferRef: *const ma_audio_buffer_ref, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_get_length_in_pcm_frames( ++ pAudioBufferRef: *const ma_audio_buffer_ref, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_ref_get_available_frames( ++ pAudioBufferRef: *const ma_audio_buffer_ref, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_audio_buffer_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub sizeInFrames: ma_uint64, ++ pub pData: *const core::ffi::c_void, ++ pub allocationCallbacks: ma_allocation_callbacks, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_audio_buffer_config"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_audio_buffer_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_audio_buffer_config::format"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, format) - 0usize]; ++ ["Offset of field: ma_audio_buffer_config::channels"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, channels) - 4usize]; ++ ["Offset of field: ma_audio_buffer_config::sampleRate"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_audio_buffer_config::sizeInFrames"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, sizeInFrames) - 16usize]; ++ ["Offset of field: ma_audio_buffer_config::pData"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, pData) - 24usize]; ++ ["Offset of field: ma_audio_buffer_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_audio_buffer_config, allocationCallbacks) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_audio_buffer_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sizeInFrames: ma_uint64, ++ pData: *const core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_audio_buffer_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_audio_buffer { ++ pub ref_: ma_audio_buffer_ref, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub ownsData: ma_bool32, ++ pub _pExtraData: [ma_uint8; 1usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_audio_buffer"][::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_audio_buffer"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_audio_buffer::ref_"] ++ [::core::mem::offset_of!(ma_audio_buffer, ref_) - 0usize]; ++ ["Offset of field: ma_audio_buffer::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_audio_buffer, allocationCallbacks) - 112usize]; ++ ["Offset of field: ma_audio_buffer::ownsData"] ++ [::core::mem::offset_of!(ma_audio_buffer, ownsData) - 144usize]; ++ ["Offset of field: ma_audio_buffer::_pExtraData"] ++ [::core::mem::offset_of!(ma_audio_buffer, _pExtraData) - 148usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_audio_buffer_init( ++ pConfig: *const ma_audio_buffer_config, ++ pAudioBuffer: *mut ma_audio_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_init_copy( ++ pConfig: *const ma_audio_buffer_config, ++ pAudioBuffer: *mut ma_audio_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_alloc_and_init( ++ pConfig: *const ma_audio_buffer_config, ++ ppAudioBuffer: *mut *mut ma_audio_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_uninit(pAudioBuffer: *mut ma_audio_buffer); ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_uninit_and_free(pAudioBuffer: *mut ma_audio_buffer); ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_read_pcm_frames( ++ pAudioBuffer: *mut ma_audio_buffer, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ loop_: ma_bool32, ++ ) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_seek_to_pcm_frame( ++ pAudioBuffer: *mut ma_audio_buffer, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_map( ++ pAudioBuffer: *mut ma_audio_buffer, ++ ppFramesOut: *mut *mut core::ffi::c_void, ++ pFrameCount: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_unmap( ++ pAudioBuffer: *mut ma_audio_buffer, ++ frameCount: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_at_end(pAudioBuffer: *const ma_audio_buffer) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_get_cursor_in_pcm_frames( ++ pAudioBuffer: *const ma_audio_buffer, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_get_length_in_pcm_frames( ++ pAudioBuffer: *const ma_audio_buffer, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_audio_buffer_get_available_frames( ++ pAudioBuffer: *const ma_audio_buffer, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_paged_audio_buffer_page { ++ pub pNext: *mut ma_paged_audio_buffer_page, ++ pub sizeInFrames: ma_uint64, ++ pub pAudioData: [ma_uint8; 1usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_paged_audio_buffer_page"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_paged_audio_buffer_page"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_page::pNext"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_page, pNext) - 0usize]; ++ ["Offset of field: ma_paged_audio_buffer_page::sizeInFrames"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_page, sizeInFrames) - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_page::pAudioData"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_page, pAudioData) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_paged_audio_buffer_data { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub head: ma_paged_audio_buffer_page, ++ pub pTail: *mut ma_paged_audio_buffer_page, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_paged_audio_buffer_data"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_paged_audio_buffer_data"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_data::format"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_data, format) - 0usize]; ++ ["Offset of field: ma_paged_audio_buffer_data::channels"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_data, channels) - 4usize]; ++ ["Offset of field: ma_paged_audio_buffer_data::head"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_data, head) - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_data::pTail"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_data, pTail) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_init( ++ format: ma_format, ++ channels: ma_uint32, ++ pData: *mut ma_paged_audio_buffer_data, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_uninit( ++ pData: *mut ma_paged_audio_buffer_data, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_get_head( ++ pData: *mut ma_paged_audio_buffer_data, ++ ) -> *mut ma_paged_audio_buffer_page; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_get_tail( ++ pData: *mut ma_paged_audio_buffer_data, ++ ) -> *mut ma_paged_audio_buffer_page; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_get_length_in_pcm_frames( ++ pData: *mut ma_paged_audio_buffer_data, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_allocate_page( ++ pData: *mut ma_paged_audio_buffer_data, ++ pageSizeInFrames: ma_uint64, ++ pInitialData: *const core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppPage: *mut *mut ma_paged_audio_buffer_page, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_free_page( ++ pData: *mut ma_paged_audio_buffer_data, ++ pPage: *mut ma_paged_audio_buffer_page, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_append_page( ++ pData: *mut ma_paged_audio_buffer_data, ++ pPage: *mut ma_paged_audio_buffer_page, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_data_allocate_and_append_page( ++ pData: *mut ma_paged_audio_buffer_data, ++ pageSizeInFrames: ma_uint32, ++ pInitialData: *const core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_paged_audio_buffer_config { ++ pub pData: *mut ma_paged_audio_buffer_data, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_paged_audio_buffer_config"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_paged_audio_buffer_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer_config::pData"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer_config, pData) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_config_init( ++ pData: *mut ma_paged_audio_buffer_data, ++ ) -> ma_paged_audio_buffer_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_paged_audio_buffer { ++ pub ds: ma_data_source_base, ++ pub pData: *mut ma_paged_audio_buffer_data, ++ pub pCurrent: *mut ma_paged_audio_buffer_page, ++ pub relativeCursor: ma_uint64, ++ pub absoluteCursor: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_paged_audio_buffer"][::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_paged_audio_buffer"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_paged_audio_buffer::ds"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, ds) - 0usize]; ++ ["Offset of field: ma_paged_audio_buffer::pData"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, pData) - 72usize]; ++ ["Offset of field: ma_paged_audio_buffer::pCurrent"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, pCurrent) - 80usize]; ++ ["Offset of field: ma_paged_audio_buffer::relativeCursor"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, relativeCursor) - 88usize]; ++ ["Offset of field: ma_paged_audio_buffer::absoluteCursor"] ++ [::core::mem::offset_of!(ma_paged_audio_buffer, absoluteCursor) - 96usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_init( ++ pConfig: *const ma_paged_audio_buffer_config, ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_uninit(pPagedAudioBuffer: *mut ma_paged_audio_buffer); ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_read_pcm_frames( ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_seek_to_pcm_frame( ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_get_cursor_in_pcm_frames( ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_paged_audio_buffer_get_length_in_pcm_frames( ++ pPagedAudioBuffer: *mut ma_paged_audio_buffer, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++#[doc = "Ring Buffer"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_rb { ++ pub pBuffer: *mut core::ffi::c_void, ++ pub subbufferSizeInBytes: ma_uint32, ++ pub subbufferCount: ma_uint32, ++ pub subbufferStrideInBytes: ma_uint32, ++ pub encodedReadOffset: ma_uint32, ++ pub encodedWriteOffset: ma_uint32, ++ pub ownsBuffer: ma_bool8, ++ pub clearOnWriteAcquire: ma_bool8, ++ pub allocationCallbacks: ma_allocation_callbacks, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_rb"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_rb"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_rb::pBuffer"][::core::mem::offset_of!(ma_rb, pBuffer) - 0usize]; ++ ["Offset of field: ma_rb::subbufferSizeInBytes"] ++ [::core::mem::offset_of!(ma_rb, subbufferSizeInBytes) - 8usize]; ++ ["Offset of field: ma_rb::subbufferCount"] ++ [::core::mem::offset_of!(ma_rb, subbufferCount) - 12usize]; ++ ["Offset of field: ma_rb::subbufferStrideInBytes"] ++ [::core::mem::offset_of!(ma_rb, subbufferStrideInBytes) - 16usize]; ++ ["Offset of field: ma_rb::encodedReadOffset"] ++ [::core::mem::offset_of!(ma_rb, encodedReadOffset) - 20usize]; ++ ["Offset of field: ma_rb::encodedWriteOffset"] ++ [::core::mem::offset_of!(ma_rb, encodedWriteOffset) - 24usize]; ++ ["Offset of field: ma_rb::ownsBuffer"][::core::mem::offset_of!(ma_rb, ownsBuffer) - 28usize]; ++ ["Offset of field: ma_rb::clearOnWriteAcquire"] ++ [::core::mem::offset_of!(ma_rb, clearOnWriteAcquire) - 29usize]; ++ ["Offset of field: ma_rb::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_rb, allocationCallbacks) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_rb_init_ex( ++ subbufferSizeInBytes: usize, ++ subbufferCount: usize, ++ subbufferStrideInBytes: usize, ++ pOptionalPreallocatedBuffer: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_init( ++ bufferSizeInBytes: usize, ++ pOptionalPreallocatedBuffer: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_uninit(pRB: *mut ma_rb); ++} ++unsafe extern "C" { ++ pub fn ma_rb_reset(pRB: *mut ma_rb); ++} ++unsafe extern "C" { ++ pub fn ma_rb_acquire_read( ++ pRB: *mut ma_rb, ++ pSizeInBytes: *mut usize, ++ ppBufferOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_commit_read(pRB: *mut ma_rb, sizeInBytes: usize) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_acquire_write( ++ pRB: *mut ma_rb, ++ pSizeInBytes: *mut usize, ++ ppBufferOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_commit_write(pRB: *mut ma_rb, sizeInBytes: usize) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_seek_read(pRB: *mut ma_rb, offsetInBytes: usize) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_seek_write(pRB: *mut ma_rb, offsetInBytes: usize) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_rb_pointer_distance(pRB: *mut ma_rb) -> ma_int32; ++} ++unsafe extern "C" { ++ pub fn ma_rb_available_read(pRB: *mut ma_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_rb_available_write(pRB: *mut ma_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_rb_get_subbuffer_size(pRB: *mut ma_rb) -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_rb_get_subbuffer_stride(pRB: *mut ma_rb) -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_rb_get_subbuffer_offset(pRB: *mut ma_rb, subbufferIndex: usize) -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_rb_get_subbuffer_ptr( ++ pRB: *mut ma_rb, ++ subbufferIndex: usize, ++ pBuffer: *mut core::ffi::c_void, ++ ) -> *mut core::ffi::c_void; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_pcm_rb { ++ pub ds: ma_data_source_base, ++ pub rb: ma_rb, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_pcm_rb"][::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_pcm_rb"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_pcm_rb::ds"][::core::mem::offset_of!(ma_pcm_rb, ds) - 0usize]; ++ ["Offset of field: ma_pcm_rb::rb"][::core::mem::offset_of!(ma_pcm_rb, rb) - 72usize]; ++ ["Offset of field: ma_pcm_rb::format"][::core::mem::offset_of!(ma_pcm_rb, format) - 136usize]; ++ ["Offset of field: ma_pcm_rb::channels"] ++ [::core::mem::offset_of!(ma_pcm_rb, channels) - 140usize]; ++ ["Offset of field: ma_pcm_rb::sampleRate"] ++ [::core::mem::offset_of!(ma_pcm_rb, sampleRate) - 144usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_pcm_rb_init_ex( ++ format: ma_format, ++ channels: ma_uint32, ++ subbufferSizeInFrames: ma_uint32, ++ subbufferCount: ma_uint32, ++ subbufferStrideInFrames: ma_uint32, ++ pOptionalPreallocatedBuffer: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_pcm_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_init( ++ format: ma_format, ++ channels: ma_uint32, ++ bufferSizeInFrames: ma_uint32, ++ pOptionalPreallocatedBuffer: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_pcm_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_uninit(pRB: *mut ma_pcm_rb); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_reset(pRB: *mut ma_pcm_rb); ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_acquire_read( ++ pRB: *mut ma_pcm_rb, ++ pSizeInFrames: *mut ma_uint32, ++ ppBufferOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_commit_read(pRB: *mut ma_pcm_rb, sizeInFrames: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_acquire_write( ++ pRB: *mut ma_pcm_rb, ++ pSizeInFrames: *mut ma_uint32, ++ ppBufferOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_commit_write(pRB: *mut ma_pcm_rb, sizeInFrames: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_seek_read(pRB: *mut ma_pcm_rb, offsetInFrames: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_seek_write(pRB: *mut ma_pcm_rb, offsetInFrames: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_pointer_distance(pRB: *mut ma_pcm_rb) -> ma_int32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_available_read(pRB: *mut ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_available_write(pRB: *mut ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_subbuffer_size(pRB: *mut ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_subbuffer_stride(pRB: *mut ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_subbuffer_offset( ++ pRB: *mut ma_pcm_rb, ++ subbufferIndex: ma_uint32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_subbuffer_ptr( ++ pRB: *mut ma_pcm_rb, ++ subbufferIndex: ma_uint32, ++ pBuffer: *mut core::ffi::c_void, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_format(pRB: *const ma_pcm_rb) -> ma_format; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_channels(pRB: *const ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_get_sample_rate(pRB: *const ma_pcm_rb) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_pcm_rb_set_sample_rate(pRB: *mut ma_pcm_rb, sampleRate: ma_uint32); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_duplex_rb { ++ pub rb: ma_pcm_rb, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_duplex_rb"][::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_duplex_rb"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_duplex_rb::rb"][::core::mem::offset_of!(ma_duplex_rb, rb) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_duplex_rb_init( ++ captureFormat: ma_format, ++ captureChannels: ma_uint32, ++ sampleRate: ma_uint32, ++ captureInternalSampleRate: ma_uint32, ++ captureInternalPeriodSizeInFrames: ma_uint32, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pRB: *mut ma_duplex_rb, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_duplex_rb_uninit(pRB: *mut ma_duplex_rb) -> ma_result; ++} ++unsafe extern "C" { ++ #[doc = "Miscellaneous Helpers"] ++ pub fn ma_result_description(result: ma_result) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ma_malloc( ++ sz: usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_calloc( ++ sz: usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_realloc( ++ p: *mut core::ffi::c_void, ++ sz: usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_free(p: *mut core::ffi::c_void, pAllocationCallbacks: *const ma_allocation_callbacks); ++} ++unsafe extern "C" { ++ pub fn ma_aligned_malloc( ++ sz: usize, ++ alignment: usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_aligned_free( ++ p: *mut core::ffi::c_void, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_get_format_name(format: ma_format) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ma_blend_f32( ++ pOut: *mut f32, ++ pInA: *mut f32, ++ pInB: *mut f32, ++ factor: f32, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_get_bytes_per_sample(format: ma_format) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_log_level_to_string(logLevel: ma_uint32) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ #[doc = "Synchronization"] ++ pub fn ma_spinlock_lock(pSpinlock: *mut ma_spinlock) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spinlock_lock_noyield(pSpinlock: *mut ma_spinlock) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_spinlock_unlock(pSpinlock: *mut ma_spinlock) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_mutex_init(pMutex: *mut ma_mutex) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_mutex_uninit(pMutex: *mut ma_mutex); ++} ++unsafe extern "C" { ++ pub fn ma_mutex_lock(pMutex: *mut ma_mutex); ++} ++unsafe extern "C" { ++ pub fn ma_mutex_unlock(pMutex: *mut ma_mutex); ++} ++unsafe extern "C" { ++ pub fn ma_event_init(pEvent: *mut ma_event) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_event_uninit(pEvent: *mut ma_event); ++} ++unsafe extern "C" { ++ pub fn ma_event_wait(pEvent: *mut ma_event) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_event_signal(pEvent: *mut ma_event) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_semaphore_init( ++ initialValue: core::ffi::c_int, ++ pSemaphore: *mut ma_semaphore, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_semaphore_uninit(pSemaphore: *mut ma_semaphore); ++} ++unsafe extern "C" { ++ pub fn ma_semaphore_wait(pSemaphore: *mut ma_semaphore) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_semaphore_release(pSemaphore: *mut ma_semaphore) -> ma_result; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_fence { ++ pub e: ma_event, ++ pub counter: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_fence"][::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_fence"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_fence::e"][::core::mem::offset_of!(ma_fence, e) - 0usize]; ++ ["Offset of field: ma_fence::counter"][::core::mem::offset_of!(ma_fence, counter) - 96usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_fence_init(pFence: *mut ma_fence) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fence_uninit(pFence: *mut ma_fence); ++} ++unsafe extern "C" { ++ pub fn ma_fence_acquire(pFence: *mut ma_fence) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fence_release(pFence: *mut ma_fence) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_fence_wait(pFence: *mut ma_fence) -> ma_result; ++} ++pub type ma_async_notification = core::ffi::c_void; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_async_notification_callbacks { ++ pub onSignal: ++ ::core::option::Option, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_async_notification_callbacks"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_async_notification_callbacks"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_async_notification_callbacks::onSignal"] ++ [::core::mem::offset_of!(ma_async_notification_callbacks, onSignal) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_async_notification_signal(pNotification: *mut ma_async_notification) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_async_notification_poll { ++ pub cb: ma_async_notification_callbacks, ++ pub signalled: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_async_notification_poll"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_async_notification_poll"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_async_notification_poll::cb"] ++ [::core::mem::offset_of!(ma_async_notification_poll, cb) - 0usize]; ++ ["Offset of field: ma_async_notification_poll::signalled"] ++ [::core::mem::offset_of!(ma_async_notification_poll, signalled) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_async_notification_poll_init( ++ pNotificationPoll: *mut ma_async_notification_poll, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_async_notification_poll_is_signalled( ++ pNotificationPoll: *const ma_async_notification_poll, ++ ) -> ma_bool32; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_async_notification_event { ++ pub cb: ma_async_notification_callbacks, ++ pub e: ma_event, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_async_notification_event"] ++ [::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_async_notification_event"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_async_notification_event::cb"] ++ [::core::mem::offset_of!(ma_async_notification_event, cb) - 0usize]; ++ ["Offset of field: ma_async_notification_event::e"] ++ [::core::mem::offset_of!(ma_async_notification_event, e) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_async_notification_event_init( ++ pNotificationEvent: *mut ma_async_notification_event, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_async_notification_event_uninit( ++ pNotificationEvent: *mut ma_async_notification_event, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_async_notification_event_wait( ++ pNotificationEvent: *mut ma_async_notification_event, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_async_notification_event_signal( ++ pNotificationEvent: *mut ma_async_notification_event, ++ ) -> ma_result; ++} ++#[doc = "Job Queue"] ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_slot_allocator_config { ++ pub capacity: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_slot_allocator_config"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_slot_allocator_config"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_slot_allocator_config::capacity"] ++ [::core::mem::offset_of!(ma_slot_allocator_config, capacity) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_slot_allocator_config_init(capacity: ma_uint32) -> ma_slot_allocator_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_slot_allocator_group { ++ pub bitfield: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_slot_allocator_group"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_slot_allocator_group"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_slot_allocator_group::bitfield"] ++ [::core::mem::offset_of!(ma_slot_allocator_group, bitfield) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_slot_allocator { ++ pub pGroups: *mut ma_slot_allocator_group, ++ pub pSlots: *mut ma_uint32, ++ pub count: ma_uint32, ++ pub capacity: ma_uint32, ++ pub _ownsHeap: ma_bool32, ++ pub _pHeap: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_slot_allocator"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_slot_allocator"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_slot_allocator::pGroups"] ++ [::core::mem::offset_of!(ma_slot_allocator, pGroups) - 0usize]; ++ ["Offset of field: ma_slot_allocator::pSlots"] ++ [::core::mem::offset_of!(ma_slot_allocator, pSlots) - 8usize]; ++ ["Offset of field: ma_slot_allocator::count"] ++ [::core::mem::offset_of!(ma_slot_allocator, count) - 16usize]; ++ ["Offset of field: ma_slot_allocator::capacity"] ++ [::core::mem::offset_of!(ma_slot_allocator, capacity) - 20usize]; ++ ["Offset of field: ma_slot_allocator::_ownsHeap"] ++ [::core::mem::offset_of!(ma_slot_allocator, _ownsHeap) - 24usize]; ++ ["Offset of field: ma_slot_allocator::_pHeap"] ++ [::core::mem::offset_of!(ma_slot_allocator, _pHeap) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_slot_allocator_get_heap_size( ++ pConfig: *const ma_slot_allocator_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_init_preallocated( ++ pConfig: *const ma_slot_allocator_config, ++ pHeap: *mut core::ffi::c_void, ++ pAllocator: *mut ma_slot_allocator, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_init( ++ pConfig: *const ma_slot_allocator_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pAllocator: *mut ma_slot_allocator, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_uninit( ++ pAllocator: *mut ma_slot_allocator, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_alloc( ++ pAllocator: *mut ma_slot_allocator, ++ pSlot: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_slot_allocator_free(pAllocator: *mut ma_slot_allocator, slot: ma_uint64) ++ -> ma_result; ++} ++pub type ma_job_proc = ::core::option::Option ma_result>; ++pub const ma_job_type_MA_JOB_TYPE_QUIT: ma_job_type = 0; ++pub const ma_job_type_MA_JOB_TYPE_CUSTOM: ma_job_type = 1; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER_NODE: ma_job_type = 2; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER_NODE: ma_job_type = 3; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE: ma_job_type = 4; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER: ma_job_type = 5; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER: ma_job_type = 6; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_STREAM: ma_job_type = 7; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_STREAM: ma_job_type = 8; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_STREAM: ma_job_type = 9; ++pub const ma_job_type_MA_JOB_TYPE_RESOURCE_MANAGER_SEEK_DATA_STREAM: ma_job_type = 10; ++pub const ma_job_type_MA_JOB_TYPE_DEVICE_AAUDIO_REROUTE: ma_job_type = 11; ++pub const ma_job_type_MA_JOB_TYPE_COUNT: ma_job_type = 12; ++pub type ma_job_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_job { ++ pub toc: ma_job__bindgen_ty_1, ++ pub next: ma_uint64, ++ pub order: ma_uint32, ++ pub data: ma_job__bindgen_ty_2, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_1 { ++ pub breakup: ma_job__bindgen_ty_1__bindgen_ty_1, ++ pub allocation: ma_uint64, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_1__bindgen_ty_1 { ++ pub code: ma_uint16, ++ pub slot: ma_uint16, ++ pub refcount: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_job__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_job__bindgen_ty_1__bindgen_ty_1::code"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1__bindgen_ty_1, code) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_1__bindgen_ty_1::slot"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1__bindgen_ty_1, slot) - 2usize]; ++ ["Offset of field: ma_job__bindgen_ty_1__bindgen_ty_1::refcount"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1__bindgen_ty_1, refcount) - 4usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_1"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_job__bindgen_ty_1"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_1::breakup"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1, breakup) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_1::allocation"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_1, allocation) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_2 { ++ pub custom: ma_job__bindgen_ty_2__bindgen_ty_1, ++ pub resourceManager: ma_job__bindgen_ty_2__bindgen_ty_2, ++ pub device: ma_job__bindgen_ty_2__bindgen_ty_3, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_1 { ++ pub proc_: ma_job_proc, ++ pub data0: ma_uintptr, ++ pub data1: ma_uintptr, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_1::proc_"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_1, proc_) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_1::data0"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_1, data0) - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_1::data1"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_1, data1) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_2__bindgen_ty_2 { ++ pub loadDataBufferNode: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pub freeDataBufferNode: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pub pageDataBufferNode: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pub loadDataBuffer: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pub freeDataBuffer: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5, ++ pub loadDataStream: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pub freeDataStream: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7, ++ pub pageDataStream: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8, ++ pub seekDataStream: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1 { ++ pub pResourceManager: *mut core::ffi::c_void, ++ pub pDataBufferNode: *mut core::ffi::c_void, ++ pub pFilePath: *mut core::ffi::c_char, ++ pub pFilePathW: *mut wchar_t, ++ pub flags: ma_uint32, ++ pub pInitNotification: *mut ma_async_notification, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pInitFence: *mut ma_fence, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pResourceManager"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pResourceManager ++ ) ++ - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pDataBufferNode"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pDataBufferNode ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pFilePath"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pFilePath ++ ) - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pFilePathW"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pFilePathW ++ ) - 24usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::flags"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ flags ++ ) - 32usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pInitNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pInitNotification ++ ) ++ - 40usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pDoneNotification ++ ) ++ - 48usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pInitFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pInitFence ++ ) - 56usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_1, ++ pDoneFence ++ ) - 64usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2 { ++ pub pResourceManager: *mut core::ffi::c_void, ++ pub pDataBufferNode: *mut core::ffi::c_void, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2::pResourceManager"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pResourceManager ++ ) ++ - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2::pDataBufferNode"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pDataBufferNode ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pDoneNotification ++ ) ++ - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_2, ++ pDoneFence ++ ) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3 { ++ pub pResourceManager: *mut core::ffi::c_void, ++ pub pDataBufferNode: *mut core::ffi::c_void, ++ pub pDecoder: *mut core::ffi::c_void, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pResourceManager"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pResourceManager ++ ) ++ - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pDataBufferNode"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pDataBufferNode ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pDecoder"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pDecoder ++ ) - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pDoneNotification ++ ) ++ - 24usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_3, ++ pDoneFence ++ ) - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4 { ++ pub pDataBuffer: *mut core::ffi::c_void, ++ pub pInitNotification: *mut ma_async_notification, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pInitFence: *mut ma_fence, ++ pub pDoneFence: *mut ma_fence, ++ pub rangeBegInPCMFrames: ma_uint64, ++ pub rangeEndInPCMFrames: ma_uint64, ++ pub loopPointBegInPCMFrames: ma_uint64, ++ pub loopPointEndInPCMFrames: ma_uint64, ++ pub isLooping: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4"] ++ [::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pDataBuffer"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pDataBuffer ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pInitNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pInitNotification ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pDoneNotification ++ ) ++ - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pInitFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pInitFence ++ ) - 24usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ pDoneFence ++ ) - 32usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::rangeBegInPCMFrames"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ rangeBegInPCMFrames ++ ) ++ - 40usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::rangeEndInPCMFrames"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ rangeEndInPCMFrames ++ ) ++ - 48usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::loopPointBegInPCMFrames"] ++ [::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ loopPointBegInPCMFrames ++ ) - 56usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::loopPointEndInPCMFrames"] ++ [::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ loopPointEndInPCMFrames ++ ) - 64usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4::isLooping"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_4, ++ isLooping ++ ) - 72usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5 { ++ pub pDataBuffer: *mut core::ffi::c_void, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5::pDataBuffer"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5, ++ pDataBuffer ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5, ++ pDoneNotification ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_5, ++ pDoneFence ++ ) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6 { ++ pub pDataStream: *mut core::ffi::c_void, ++ pub pFilePath: *mut core::ffi::c_char, ++ pub pFilePathW: *mut wchar_t, ++ pub initialSeekPoint: ma_uint64, ++ pub pInitNotification: *mut ma_async_notification, ++ pub pInitFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pDataStream"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pDataStream ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pFilePath"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pFilePath ++ ) - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pFilePathW"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pFilePathW ++ ) - 16usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::initialSeekPoint"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ initialSeekPoint ++ ) ++ - 24usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pInitNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pInitNotification ++ ) ++ - 32usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6::pInitFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_6, ++ pInitFence ++ ) - 40usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7 { ++ pub pDataStream: *mut core::ffi::c_void, ++ pub pDoneNotification: *mut ma_async_notification, ++ pub pDoneFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7::pDataStream"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7, ++ pDataStream ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7::pDoneNotification"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7, ++ pDoneNotification ++ ) ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7::pDoneFence"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_7, ++ pDoneFence ++ ) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8 { ++ pub pDataStream: *mut core::ffi::c_void, ++ pub pageIndex: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8::pDataStream"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8, ++ pDataStream ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8::pageIndex"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_8, ++ pageIndex ++ ) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9 { ++ pub pDataStream: *mut core::ffi::c_void, ++ pub frameIndex: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9::pDataStream"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9, ++ pDataStream ++ ) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9::frameIndex"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_2__bindgen_ty_9, ++ frameIndex ++ ) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_2"] ++ [::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::loadDataBufferNode"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, loadDataBufferNode) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::freeDataBufferNode"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, freeDataBufferNode) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::pageDataBufferNode"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, pageDataBufferNode) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::loadDataBuffer"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, loadDataBuffer) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::freeDataBuffer"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, freeDataBuffer) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::loadDataStream"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, loadDataStream) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::freeDataStream"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, freeDataStream) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::pageDataStream"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, pageDataStream) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_2::seekDataStream"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_2, seekDataStream) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_2__bindgen_ty_3 { ++ pub aaudio: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1 { ++ pub reroute: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1 { ++ pub pDevice: *mut core::ffi::c_void, ++ pub deviceType: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1"][::core::mem::size_of::< ++ ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1, ++ >() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() ++ - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1::pDevice"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1, ++ pDevice ++ ) ++ - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1::deviceType"] ++ [::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1__bindgen_ty_1, ++ deviceType ++ ) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1::reroute"][::core::mem::offset_of!( ++ ma_job__bindgen_ty_2__bindgen_ty_3__bindgen_ty_1, ++ reroute ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2__bindgen_ty_3"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_job__bindgen_ty_2__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2__bindgen_ty_3::aaudio"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2__bindgen_ty_3, aaudio) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job__bindgen_ty_2"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_job__bindgen_ty_2"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job__bindgen_ty_2::custom"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2, custom) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2::resourceManager"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2, resourceManager) - 0usize]; ++ ["Offset of field: ma_job__bindgen_ty_2::device"] ++ [::core::mem::offset_of!(ma_job__bindgen_ty_2, device) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job"][::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_job"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job::toc"][::core::mem::offset_of!(ma_job, toc) - 0usize]; ++ ["Offset of field: ma_job::next"][::core::mem::offset_of!(ma_job, next) - 8usize]; ++ ["Offset of field: ma_job::order"][::core::mem::offset_of!(ma_job, order) - 16usize]; ++ ["Offset of field: ma_job::data"][::core::mem::offset_of!(ma_job, data) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_job_init(code: ma_uint16) -> ma_job; ++} ++unsafe extern "C" { ++ pub fn ma_job_process(pJob: *mut ma_job) -> ma_result; ++} ++pub const ma_job_queue_flags_MA_JOB_QUEUE_FLAG_NON_BLOCKING: ma_job_queue_flags = 1; ++pub type ma_job_queue_flags = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_job_queue_config { ++ pub flags: ma_uint32, ++ pub capacity: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job_queue_config"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_job_queue_config"][::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_job_queue_config::flags"] ++ [::core::mem::offset_of!(ma_job_queue_config, flags) - 0usize]; ++ ["Offset of field: ma_job_queue_config::capacity"] ++ [::core::mem::offset_of!(ma_job_queue_config, capacity) - 4usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_job_queue_config_init(flags: ma_uint32, capacity: ma_uint32) -> ma_job_queue_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_job_queue { ++ pub flags: ma_uint32, ++ pub capacity: ma_uint32, ++ pub head: ma_uint64, ++ pub tail: ma_uint64, ++ pub sem: ma_semaphore, ++ pub allocator: ma_slot_allocator, ++ pub pJobs: *mut ma_job, ++ pub lock: ma_spinlock, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_job_queue"][::core::mem::size_of::() - 192usize]; ++ ["Alignment of ma_job_queue"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_job_queue::flags"][::core::mem::offset_of!(ma_job_queue, flags) - 0usize]; ++ ["Offset of field: ma_job_queue::capacity"] ++ [::core::mem::offset_of!(ma_job_queue, capacity) - 4usize]; ++ ["Offset of field: ma_job_queue::head"][::core::mem::offset_of!(ma_job_queue, head) - 8usize]; ++ ["Offset of field: ma_job_queue::tail"][::core::mem::offset_of!(ma_job_queue, tail) - 16usize]; ++ ["Offset of field: ma_job_queue::sem"][::core::mem::offset_of!(ma_job_queue, sem) - 24usize]; ++ ["Offset of field: ma_job_queue::allocator"] ++ [::core::mem::offset_of!(ma_job_queue, allocator) - 120usize]; ++ ["Offset of field: ma_job_queue::pJobs"] ++ [::core::mem::offset_of!(ma_job_queue, pJobs) - 160usize]; ++ ["Offset of field: ma_job_queue::lock"][::core::mem::offset_of!(ma_job_queue, lock) - 168usize]; ++ ["Offset of field: ma_job_queue::_pHeap"] ++ [::core::mem::offset_of!(ma_job_queue, _pHeap) - 176usize]; ++ ["Offset of field: ma_job_queue::_ownsHeap"] ++ [::core::mem::offset_of!(ma_job_queue, _ownsHeap) - 184usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_job_queue_get_heap_size( ++ pConfig: *const ma_job_queue_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_init_preallocated( ++ pConfig: *const ma_job_queue_config, ++ pHeap: *mut core::ffi::c_void, ++ pQueue: *mut ma_job_queue, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_init( ++ pConfig: *const ma_job_queue_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pQueue: *mut ma_job_queue, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_uninit( ++ pQueue: *mut ma_job_queue, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_post(pQueue: *mut ma_job_queue, pJob: *const ma_job) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_job_queue_next(pQueue: *mut ma_job_queue, pJob: *mut ma_job) -> ma_result; ++} ++pub const ma_device_state_ma_device_state_uninitialized: ma_device_state = 0; ++pub const ma_device_state_ma_device_state_stopped: ma_device_state = 1; ++pub const ma_device_state_ma_device_state_started: ma_device_state = 2; ++pub const ma_device_state_ma_device_state_starting: ma_device_state = 3; ++pub const ma_device_state_ma_device_state_stopping: ma_device_state = 4; ++pub type ma_device_state = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_atomic_device_state { ++ pub value: ma_device_state, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_atomic_device_state"][::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_atomic_device_state"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_atomic_device_state::value"] ++ [::core::mem::offset_of!(ma_atomic_device_state, value) - 0usize]; ++}; ++pub const ma_backend_ma_backend_wasapi: ma_backend = 0; ++pub const ma_backend_ma_backend_dsound: ma_backend = 1; ++pub const ma_backend_ma_backend_winmm: ma_backend = 2; ++pub const ma_backend_ma_backend_coreaudio: ma_backend = 3; ++pub const ma_backend_ma_backend_sndio: ma_backend = 4; ++pub const ma_backend_ma_backend_audio4: ma_backend = 5; ++pub const ma_backend_ma_backend_oss: ma_backend = 6; ++pub const ma_backend_ma_backend_pulseaudio: ma_backend = 7; ++pub const ma_backend_ma_backend_alsa: ma_backend = 8; ++pub const ma_backend_ma_backend_jack: ma_backend = 9; ++pub const ma_backend_ma_backend_aaudio: ma_backend = 10; ++pub const ma_backend_ma_backend_opensl: ma_backend = 11; ++pub const ma_backend_ma_backend_webaudio: ma_backend = 12; ++pub const ma_backend_ma_backend_custom: ma_backend = 13; ++pub const ma_backend_ma_backend_null: ma_backend = 14; ++pub type ma_backend = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_job_thread_config { ++ pub noThread: ma_bool32, ++ pub jobQueueCapacity: ma_uint32, ++ pub jobQueueFlags: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_job_thread_config"] ++ [::core::mem::size_of::() - 12usize]; ++ ["Alignment of ma_device_job_thread_config"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_job_thread_config::noThread"] ++ [::core::mem::offset_of!(ma_device_job_thread_config, noThread) - 0usize]; ++ ["Offset of field: ma_device_job_thread_config::jobQueueCapacity"] ++ [::core::mem::offset_of!(ma_device_job_thread_config, jobQueueCapacity) - 4usize]; ++ ["Offset of field: ma_device_job_thread_config::jobQueueFlags"] ++ [::core::mem::offset_of!(ma_device_job_thread_config, jobQueueFlags) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_device_job_thread_config_init() -> ma_device_job_thread_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device_job_thread { ++ pub thread: ma_thread, ++ pub jobQueue: ma_job_queue, ++ pub _hasThread: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_job_thread"][::core::mem::size_of::() - 208usize]; ++ ["Alignment of ma_device_job_thread"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_job_thread::thread"] ++ [::core::mem::offset_of!(ma_device_job_thread, thread) - 0usize]; ++ ["Offset of field: ma_device_job_thread::jobQueue"] ++ [::core::mem::offset_of!(ma_device_job_thread, jobQueue) - 8usize]; ++ ["Offset of field: ma_device_job_thread::_hasThread"] ++ [::core::mem::offset_of!(ma_device_job_thread, _hasThread) - 200usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_device_job_thread_init( ++ pConfig: *const ma_device_job_thread_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pJobThread: *mut ma_device_job_thread, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_job_thread_uninit( ++ pJobThread: *mut ma_device_job_thread, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_device_job_thread_post( ++ pJobThread: *mut ma_device_job_thread, ++ pJob: *const ma_job, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_job_thread_next( ++ pJobThread: *mut ma_device_job_thread, ++ pJob: *mut ma_job, ++ ) -> ma_result; ++} ++pub const ma_device_notification_type_ma_device_notification_type_started: ++ ma_device_notification_type = 0; ++pub const ma_device_notification_type_ma_device_notification_type_stopped: ++ ma_device_notification_type = 1; ++pub const ma_device_notification_type_ma_device_notification_type_rerouted: ++ ma_device_notification_type = 2; ++pub const ma_device_notification_type_ma_device_notification_type_interruption_began: ++ ma_device_notification_type = 3; ++pub const ma_device_notification_type_ma_device_notification_type_interruption_ended: ++ ma_device_notification_type = 4; ++pub const ma_device_notification_type_ma_device_notification_type_unlocked: ++ ma_device_notification_type = 5; ++pub type ma_device_notification_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device_notification { ++ pub pDevice: *mut ma_device, ++ pub type_: ma_device_notification_type, ++ pub data: ma_device_notification__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_device_notification__bindgen_ty_1 { ++ pub started: ma_device_notification__bindgen_ty_1__bindgen_ty_1, ++ pub stopped: ma_device_notification__bindgen_ty_1__bindgen_ty_2, ++ pub rerouted: ma_device_notification__bindgen_ty_1__bindgen_ty_3, ++ pub interruption: ma_device_notification__bindgen_ty_1__bindgen_ty_4, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_notification__bindgen_ty_1__bindgen_ty_1 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1__bindgen_ty_1::_unused"][::core::mem::offset_of!( ++ ma_device_notification__bindgen_ty_1__bindgen_ty_1, ++ _unused ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_notification__bindgen_ty_1__bindgen_ty_2 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1__bindgen_ty_2::_unused"][::core::mem::offset_of!( ++ ma_device_notification__bindgen_ty_1__bindgen_ty_2, ++ _unused ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_notification__bindgen_ty_1__bindgen_ty_3 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1__bindgen_ty_3::_unused"][::core::mem::offset_of!( ++ ma_device_notification__bindgen_ty_1__bindgen_ty_3, ++ _unused ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_notification__bindgen_ty_1__bindgen_ty_4 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1__bindgen_ty_4"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1__bindgen_ty_4"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1__bindgen_ty_4::_unused"][::core::mem::offset_of!( ++ ma_device_notification__bindgen_ty_1__bindgen_ty_4, ++ _unused ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_notification__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1::started"] ++ [::core::mem::offset_of!(ma_device_notification__bindgen_ty_1, started) - 0usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1::stopped"] ++ [::core::mem::offset_of!(ma_device_notification__bindgen_ty_1, stopped) - 0usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1::rerouted"] ++ [::core::mem::offset_of!(ma_device_notification__bindgen_ty_1, rerouted) - 0usize]; ++ ["Offset of field: ma_device_notification__bindgen_ty_1::interruption"] ++ [::core::mem::offset_of!(ma_device_notification__bindgen_ty_1, interruption) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_notification"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_device_notification"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_notification::pDevice"] ++ [::core::mem::offset_of!(ma_device_notification, pDevice) - 0usize]; ++ ["Offset of field: ma_device_notification::type_"] ++ [::core::mem::offset_of!(ma_device_notification, type_) - 8usize]; ++ ["Offset of field: ma_device_notification::data"] ++ [::core::mem::offset_of!(ma_device_notification, data) - 12usize]; ++}; ++pub type ma_device_notification_proc = ++ ::core::option::Option; ++pub type ma_device_data_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ pOutput: *mut core::ffi::c_void, ++ pInput: *const core::ffi::c_void, ++ frameCount: ma_uint32, ++ ), ++>; ++pub type ma_stop_proc = ::core::option::Option; ++pub const ma_device_type_ma_device_type_playback: ma_device_type = 1; ++pub const ma_device_type_ma_device_type_capture: ma_device_type = 2; ++pub const ma_device_type_ma_device_type_duplex: ma_device_type = 3; ++pub const ma_device_type_ma_device_type_loopback: ma_device_type = 4; ++pub type ma_device_type = core::ffi::c_uint; ++pub const ma_share_mode_ma_share_mode_shared: ma_share_mode = 0; ++pub const ma_share_mode_ma_share_mode_exclusive: ma_share_mode = 1; ++pub type ma_share_mode = core::ffi::c_uint; ++pub const ma_ios_session_category_ma_ios_session_category_default: ma_ios_session_category = 0; ++pub const ma_ios_session_category_ma_ios_session_category_none: ma_ios_session_category = 1; ++pub const ma_ios_session_category_ma_ios_session_category_ambient: ma_ios_session_category = 2; ++pub const ma_ios_session_category_ma_ios_session_category_solo_ambient: ma_ios_session_category = 3; ++pub const ma_ios_session_category_ma_ios_session_category_playback: ma_ios_session_category = 4; ++pub const ma_ios_session_category_ma_ios_session_category_record: ma_ios_session_category = 5; ++pub const ma_ios_session_category_ma_ios_session_category_play_and_record: ma_ios_session_category = ++ 6; ++pub const ma_ios_session_category_ma_ios_session_category_multi_route: ma_ios_session_category = 7; ++pub type ma_ios_session_category = core::ffi::c_uint; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_mix_with_others: ++ ma_ios_session_category_option = 1; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_duck_others: ++ ma_ios_session_category_option = 2; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_allow_bluetooth: ++ ma_ios_session_category_option = 4; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_default_to_speaker: ++ ma_ios_session_category_option = 8; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_interrupt_spoken_audio_and_mix_with_others : ma_ios_session_category_option = 17 ; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_allow_bluetooth_a2dp: ++ ma_ios_session_category_option = 32; ++pub const ma_ios_session_category_option_ma_ios_session_category_option_allow_air_play: ++ ma_ios_session_category_option = 64; ++pub type ma_ios_session_category_option = core::ffi::c_uint; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_default: ma_opensl_stream_type = 0; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_voice: ma_opensl_stream_type = 1; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_system: ma_opensl_stream_type = 2; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_ring: ma_opensl_stream_type = 3; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_media: ma_opensl_stream_type = 4; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_alarm: ma_opensl_stream_type = 5; ++pub const ma_opensl_stream_type_ma_opensl_stream_type_notification: ma_opensl_stream_type = 6; ++pub type ma_opensl_stream_type = core::ffi::c_uint; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_default: ++ ma_opensl_recording_preset = 0; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_generic: ++ ma_opensl_recording_preset = 1; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_camcorder: ++ ma_opensl_recording_preset = 2; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_voice_recognition: ++ ma_opensl_recording_preset = 3; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_voice_communication: ++ ma_opensl_recording_preset = 4; ++pub const ma_opensl_recording_preset_ma_opensl_recording_preset_voice_unprocessed: ++ ma_opensl_recording_preset = 5; ++pub type ma_opensl_recording_preset = core::ffi::c_uint; ++pub const ma_wasapi_usage_ma_wasapi_usage_default: ma_wasapi_usage = 0; ++pub const ma_wasapi_usage_ma_wasapi_usage_games: ma_wasapi_usage = 1; ++pub const ma_wasapi_usage_ma_wasapi_usage_pro_audio: ma_wasapi_usage = 2; ++pub type ma_wasapi_usage = core::ffi::c_uint; ++pub const ma_aaudio_usage_ma_aaudio_usage_default: ma_aaudio_usage = 0; ++pub const ma_aaudio_usage_ma_aaudio_usage_media: ma_aaudio_usage = 1; ++pub const ma_aaudio_usage_ma_aaudio_usage_voice_communication: ma_aaudio_usage = 2; ++pub const ma_aaudio_usage_ma_aaudio_usage_voice_communication_signalling: ma_aaudio_usage = 3; ++pub const ma_aaudio_usage_ma_aaudio_usage_alarm: ma_aaudio_usage = 4; ++pub const ma_aaudio_usage_ma_aaudio_usage_notification: ma_aaudio_usage = 5; ++pub const ma_aaudio_usage_ma_aaudio_usage_notification_ringtone: ma_aaudio_usage = 6; ++pub const ma_aaudio_usage_ma_aaudio_usage_notification_event: ma_aaudio_usage = 7; ++pub const ma_aaudio_usage_ma_aaudio_usage_assistance_accessibility: ma_aaudio_usage = 8; ++pub const ma_aaudio_usage_ma_aaudio_usage_assistance_navigation_guidance: ma_aaudio_usage = 9; ++pub const ma_aaudio_usage_ma_aaudio_usage_assistance_sonification: ma_aaudio_usage = 10; ++pub const ma_aaudio_usage_ma_aaudio_usage_game: ma_aaudio_usage = 11; ++pub const ma_aaudio_usage_ma_aaudio_usage_assitant: ma_aaudio_usage = 12; ++pub const ma_aaudio_usage_ma_aaudio_usage_emergency: ma_aaudio_usage = 13; ++pub const ma_aaudio_usage_ma_aaudio_usage_safety: ma_aaudio_usage = 14; ++pub const ma_aaudio_usage_ma_aaudio_usage_vehicle_status: ma_aaudio_usage = 15; ++pub const ma_aaudio_usage_ma_aaudio_usage_announcement: ma_aaudio_usage = 16; ++pub type ma_aaudio_usage = core::ffi::c_uint; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_default: ma_aaudio_content_type = 0; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_speech: ma_aaudio_content_type = 1; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_music: ma_aaudio_content_type = 2; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_movie: ma_aaudio_content_type = 3; ++pub const ma_aaudio_content_type_ma_aaudio_content_type_sonification: ma_aaudio_content_type = 4; ++pub type ma_aaudio_content_type = core::ffi::c_uint; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_default: ma_aaudio_input_preset = 0; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_generic: ma_aaudio_input_preset = 1; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_camcorder: ma_aaudio_input_preset = 2; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_voice_recognition: ma_aaudio_input_preset = ++ 3; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_voice_communication: ++ ma_aaudio_input_preset = 4; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_unprocessed: ma_aaudio_input_preset = 5; ++pub const ma_aaudio_input_preset_ma_aaudio_input_preset_voice_performance: ma_aaudio_input_preset = ++ 6; ++pub type ma_aaudio_input_preset = core::ffi::c_uint; ++pub const ma_aaudio_allowed_capture_policy_ma_aaudio_allow_capture_default: ++ ma_aaudio_allowed_capture_policy = 0; ++pub const ma_aaudio_allowed_capture_policy_ma_aaudio_allow_capture_by_all: ++ ma_aaudio_allowed_capture_policy = 1; ++pub const ma_aaudio_allowed_capture_policy_ma_aaudio_allow_capture_by_system: ++ ma_aaudio_allowed_capture_policy = 2; ++pub const ma_aaudio_allowed_capture_policy_ma_aaudio_allow_capture_by_none: ++ ma_aaudio_allowed_capture_policy = 3; ++pub type ma_aaudio_allowed_capture_policy = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_timer { ++ pub counter: ma_int64, ++ pub counterD: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_timer"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_timer"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_timer::counter"][::core::mem::offset_of!(ma_timer, counter) - 0usize]; ++ ["Offset of field: ma_timer::counterD"][::core::mem::offset_of!(ma_timer, counterD) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_device_id { ++ pub wasapi: [ma_wchar_win32; 64usize], ++ pub dsound: [ma_uint8; 16usize], ++ pub winmm: ma_uint32, ++ pub alsa: [core::ffi::c_char; 256usize], ++ pub pulse: [core::ffi::c_char; 256usize], ++ pub jack: core::ffi::c_int, ++ pub coreaudio: [core::ffi::c_char; 256usize], ++ pub sndio: [core::ffi::c_char; 256usize], ++ pub audio4: [core::ffi::c_char; 256usize], ++ pub oss: [core::ffi::c_char; 64usize], ++ pub aaudio: ma_int32, ++ pub opensl: ma_uint32, ++ pub webaudio: [core::ffi::c_char; 32usize], ++ pub custom: ma_device_id__bindgen_ty_1, ++ pub nullbackend: core::ffi::c_int, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_device_id__bindgen_ty_1 { ++ pub i: core::ffi::c_int, ++ pub s: [core::ffi::c_char; 256usize], ++ pub p: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_id__bindgen_ty_1"] ++ [::core::mem::size_of::() - 256usize]; ++ ["Alignment of ma_device_id__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_id__bindgen_ty_1::i"] ++ [::core::mem::offset_of!(ma_device_id__bindgen_ty_1, i) - 0usize]; ++ ["Offset of field: ma_device_id__bindgen_ty_1::s"] ++ [::core::mem::offset_of!(ma_device_id__bindgen_ty_1, s) - 0usize]; ++ ["Offset of field: ma_device_id__bindgen_ty_1::p"] ++ [::core::mem::offset_of!(ma_device_id__bindgen_ty_1, p) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_id"][::core::mem::size_of::() - 256usize]; ++ ["Alignment of ma_device_id"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_id::wasapi"] ++ [::core::mem::offset_of!(ma_device_id, wasapi) - 0usize]; ++ ["Offset of field: ma_device_id::dsound"] ++ [::core::mem::offset_of!(ma_device_id, dsound) - 0usize]; ++ ["Offset of field: ma_device_id::winmm"][::core::mem::offset_of!(ma_device_id, winmm) - 0usize]; ++ ["Offset of field: ma_device_id::alsa"][::core::mem::offset_of!(ma_device_id, alsa) - 0usize]; ++ ["Offset of field: ma_device_id::pulse"][::core::mem::offset_of!(ma_device_id, pulse) - 0usize]; ++ ["Offset of field: ma_device_id::jack"][::core::mem::offset_of!(ma_device_id, jack) - 0usize]; ++ ["Offset of field: ma_device_id::coreaudio"] ++ [::core::mem::offset_of!(ma_device_id, coreaudio) - 0usize]; ++ ["Offset of field: ma_device_id::sndio"][::core::mem::offset_of!(ma_device_id, sndio) - 0usize]; ++ ["Offset of field: ma_device_id::audio4"] ++ [::core::mem::offset_of!(ma_device_id, audio4) - 0usize]; ++ ["Offset of field: ma_device_id::oss"][::core::mem::offset_of!(ma_device_id, oss) - 0usize]; ++ ["Offset of field: ma_device_id::aaudio"] ++ [::core::mem::offset_of!(ma_device_id, aaudio) - 0usize]; ++ ["Offset of field: ma_device_id::opensl"] ++ [::core::mem::offset_of!(ma_device_id, opensl) - 0usize]; ++ ["Offset of field: ma_device_id::webaudio"] ++ [::core::mem::offset_of!(ma_device_id, webaudio) - 0usize]; ++ ["Offset of field: ma_device_id::custom"] ++ [::core::mem::offset_of!(ma_device_id, custom) - 0usize]; ++ ["Offset of field: ma_device_id::nullbackend"] ++ [::core::mem::offset_of!(ma_device_id, nullbackend) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_device_id_equal(pA: *const ma_device_id, pB: *const ma_device_id) -> ma_bool32; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device_info { ++ pub id: ma_device_id, ++ pub name: [core::ffi::c_char; 256usize], ++ pub isDefault: ma_bool32, ++ pub nativeDataFormatCount: ma_uint32, ++ pub nativeDataFormats: [ma_device_info__bindgen_ty_1; 64usize], ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_info__bindgen_ty_1 { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub flags: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_info__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_device_info__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_info__bindgen_ty_1::format"] ++ [::core::mem::offset_of!(ma_device_info__bindgen_ty_1, format) - 0usize]; ++ ["Offset of field: ma_device_info__bindgen_ty_1::channels"] ++ [::core::mem::offset_of!(ma_device_info__bindgen_ty_1, channels) - 4usize]; ++ ["Offset of field: ma_device_info__bindgen_ty_1::sampleRate"] ++ [::core::mem::offset_of!(ma_device_info__bindgen_ty_1, sampleRate) - 8usize]; ++ ["Offset of field: ma_device_info__bindgen_ty_1::flags"] ++ [::core::mem::offset_of!(ma_device_info__bindgen_ty_1, flags) - 12usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_info"][::core::mem::size_of::() - 1544usize]; ++ ["Alignment of ma_device_info"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_info::id"][::core::mem::offset_of!(ma_device_info, id) - 0usize]; ++ ["Offset of field: ma_device_info::name"] ++ [::core::mem::offset_of!(ma_device_info, name) - 256usize]; ++ ["Offset of field: ma_device_info::isDefault"] ++ [::core::mem::offset_of!(ma_device_info, isDefault) - 512usize]; ++ ["Offset of field: ma_device_info::nativeDataFormatCount"] ++ [::core::mem::offset_of!(ma_device_info, nativeDataFormatCount) - 516usize]; ++ ["Offset of field: ma_device_info::nativeDataFormats"] ++ [::core::mem::offset_of!(ma_device_info, nativeDataFormats) - 520usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config { ++ pub deviceType: ma_device_type, ++ pub sampleRate: ma_uint32, ++ pub periodSizeInFrames: ma_uint32, ++ pub periodSizeInMilliseconds: ma_uint32, ++ pub periods: ma_uint32, ++ pub performanceProfile: ma_performance_profile, ++ pub noPreSilencedOutputBuffer: ma_bool8, ++ pub noClip: ma_bool8, ++ pub noDisableDenormals: ma_bool8, ++ pub noFixedSizedCallback: ma_bool8, ++ pub dataCallback: ma_device_data_proc, ++ pub notificationCallback: ma_device_notification_proc, ++ pub stopCallback: ma_stop_proc, ++ pub pUserData: *mut core::ffi::c_void, ++ pub resampling: ma_resampler_config, ++ pub playback: ma_device_config__bindgen_ty_1, ++ pub capture: ma_device_config__bindgen_ty_2, ++ pub wasapi: ma_device_config__bindgen_ty_3, ++ pub alsa: ma_device_config__bindgen_ty_4, ++ pub pulse: ma_device_config__bindgen_ty_5, ++ pub coreaudio: ma_device_config__bindgen_ty_6, ++ pub opensl: ma_device_config__bindgen_ty_7, ++ pub aaudio: ma_device_config__bindgen_ty_8, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_1 { ++ pub pDeviceID: *const ma_device_id, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub pChannelMap: *mut ma_channel, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub shareMode: ma_share_mode, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_1"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_device_config__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::pDeviceID"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, pDeviceID) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::format"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, format) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::channels"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, channels) - 12usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::pChannelMap"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, pChannelMap) - 16usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::channelMixMode"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, channelMixMode) - 24usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_1, ++ calculateLFEFromSpatialChannels ++ ) ++ - 28usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_1::shareMode"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_1, shareMode) - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_2 { ++ pub pDeviceID: *const ma_device_id, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub pChannelMap: *mut ma_channel, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub shareMode: ma_share_mode, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_2"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_device_config__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::pDeviceID"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, pDeviceID) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::format"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, format) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::channels"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, channels) - 12usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::pChannelMap"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, pChannelMap) - 16usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::channelMixMode"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, channelMixMode) - 24usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_2, ++ calculateLFEFromSpatialChannels ++ ) ++ - 28usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_2::shareMode"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_2, shareMode) - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_3 { ++ pub usage: ma_wasapi_usage, ++ pub noAutoConvertSRC: ma_bool8, ++ pub noDefaultQualitySRC: ma_bool8, ++ pub noAutoStreamRouting: ma_bool8, ++ pub noHardwareOffloading: ma_bool8, ++ pub loopbackProcessID: ma_uint32, ++ pub loopbackProcessExclude: ma_bool8, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_3"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_device_config__bindgen_ty_3"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::usage"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, usage) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::noAutoConvertSRC"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, noAutoConvertSRC) - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::noDefaultQualitySRC"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, noDefaultQualitySRC) - 5usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::noAutoStreamRouting"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, noAutoStreamRouting) - 6usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::noHardwareOffloading"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, noHardwareOffloading) - 7usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::loopbackProcessID"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, loopbackProcessID) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_3::loopbackProcessExclude"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_3, loopbackProcessExclude) - 12usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_4 { ++ pub noMMap: ma_bool32, ++ pub noAutoFormat: ma_bool32, ++ pub noAutoChannels: ma_bool32, ++ pub noAutoResample: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_4"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_device_config__bindgen_ty_4"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_4::noMMap"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_4, noMMap) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_4::noAutoFormat"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_4, noAutoFormat) - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_4::noAutoChannels"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_4, noAutoChannels) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_4::noAutoResample"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_4, noAutoResample) - 12usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_5 { ++ pub pStreamNamePlayback: *const core::ffi::c_char, ++ pub pStreamNameCapture: *const core::ffi::c_char, ++ pub channelMap: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_5"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_device_config__bindgen_ty_5"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_5::pStreamNamePlayback"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_5, pStreamNamePlayback) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_5::pStreamNameCapture"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_5, pStreamNameCapture) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_5::channelMap"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_5, channelMap) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_6 { ++ pub allowNominalSampleRateChange: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_6"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device_config__bindgen_ty_6"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_6::allowNominalSampleRateChange"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_6, ++ allowNominalSampleRateChange ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_7 { ++ pub streamType: ma_opensl_stream_type, ++ pub recordingPreset: ma_opensl_recording_preset, ++ pub enableCompatibilityWorkarounds: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_7"] ++ [::core::mem::size_of::() - 12usize]; ++ ["Alignment of ma_device_config__bindgen_ty_7"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_7::streamType"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_7, streamType) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_7::recordingPreset"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_7, recordingPreset) - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_7::enableCompatibilityWorkarounds"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_7, ++ enableCompatibilityWorkarounds ++ ) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_config__bindgen_ty_8 { ++ pub usage: ma_aaudio_usage, ++ pub contentType: ma_aaudio_content_type, ++ pub inputPreset: ma_aaudio_input_preset, ++ pub allowedCapturePolicy: ma_aaudio_allowed_capture_policy, ++ pub noAutoStartAfterReroute: ma_bool32, ++ pub enableCompatibilityWorkarounds: ma_bool32, ++ pub allowSetBufferCapacity: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config__bindgen_ty_8"] ++ [::core::mem::size_of::() - 28usize]; ++ ["Alignment of ma_device_config__bindgen_ty_8"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::usage"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, usage) - 0usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::contentType"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, contentType) - 4usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::inputPreset"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, inputPreset) - 8usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::allowedCapturePolicy"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, allowedCapturePolicy) - 12usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::noAutoStartAfterReroute"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_8, ++ noAutoStartAfterReroute ++ ) - 16usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::enableCompatibilityWorkarounds"][::core::mem::offset_of!( ++ ma_device_config__bindgen_ty_8, ++ enableCompatibilityWorkarounds ++ ) ++ - 20usize]; ++ ["Offset of field: ma_device_config__bindgen_ty_8::allowSetBufferCapacity"] ++ [::core::mem::offset_of!(ma_device_config__bindgen_ty_8, allowSetBufferCapacity) - 24usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_config"][::core::mem::size_of::() - 296usize]; ++ ["Alignment of ma_device_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_config::deviceType"] ++ [::core::mem::offset_of!(ma_device_config, deviceType) - 0usize]; ++ ["Offset of field: ma_device_config::sampleRate"] ++ [::core::mem::offset_of!(ma_device_config, sampleRate) - 4usize]; ++ ["Offset of field: ma_device_config::periodSizeInFrames"] ++ [::core::mem::offset_of!(ma_device_config, periodSizeInFrames) - 8usize]; ++ ["Offset of field: ma_device_config::periodSizeInMilliseconds"] ++ [::core::mem::offset_of!(ma_device_config, periodSizeInMilliseconds) - 12usize]; ++ ["Offset of field: ma_device_config::periods"] ++ [::core::mem::offset_of!(ma_device_config, periods) - 16usize]; ++ ["Offset of field: ma_device_config::performanceProfile"] ++ [::core::mem::offset_of!(ma_device_config, performanceProfile) - 20usize]; ++ ["Offset of field: ma_device_config::noPreSilencedOutputBuffer"] ++ [::core::mem::offset_of!(ma_device_config, noPreSilencedOutputBuffer) - 24usize]; ++ ["Offset of field: ma_device_config::noClip"] ++ [::core::mem::offset_of!(ma_device_config, noClip) - 25usize]; ++ ["Offset of field: ma_device_config::noDisableDenormals"] ++ [::core::mem::offset_of!(ma_device_config, noDisableDenormals) - 26usize]; ++ ["Offset of field: ma_device_config::noFixedSizedCallback"] ++ [::core::mem::offset_of!(ma_device_config, noFixedSizedCallback) - 27usize]; ++ ["Offset of field: ma_device_config::dataCallback"] ++ [::core::mem::offset_of!(ma_device_config, dataCallback) - 32usize]; ++ ["Offset of field: ma_device_config::notificationCallback"] ++ [::core::mem::offset_of!(ma_device_config, notificationCallback) - 40usize]; ++ ["Offset of field: ma_device_config::stopCallback"] ++ [::core::mem::offset_of!(ma_device_config, stopCallback) - 48usize]; ++ ["Offset of field: ma_device_config::pUserData"] ++ [::core::mem::offset_of!(ma_device_config, pUserData) - 56usize]; ++ ["Offset of field: ma_device_config::resampling"] ++ [::core::mem::offset_of!(ma_device_config, resampling) - 64usize]; ++ ["Offset of field: ma_device_config::playback"] ++ [::core::mem::offset_of!(ma_device_config, playback) - 112usize]; ++ ["Offset of field: ma_device_config::capture"] ++ [::core::mem::offset_of!(ma_device_config, capture) - 152usize]; ++ ["Offset of field: ma_device_config::wasapi"] ++ [::core::mem::offset_of!(ma_device_config, wasapi) - 192usize]; ++ ["Offset of field: ma_device_config::alsa"] ++ [::core::mem::offset_of!(ma_device_config, alsa) - 208usize]; ++ ["Offset of field: ma_device_config::pulse"] ++ [::core::mem::offset_of!(ma_device_config, pulse) - 224usize]; ++ ["Offset of field: ma_device_config::coreaudio"] ++ [::core::mem::offset_of!(ma_device_config, coreaudio) - 248usize]; ++ ["Offset of field: ma_device_config::opensl"] ++ [::core::mem::offset_of!(ma_device_config, opensl) - 252usize]; ++ ["Offset of field: ma_device_config::aaudio"] ++ [::core::mem::offset_of!(ma_device_config, aaudio) - 264usize]; ++}; ++pub type ma_enum_devices_callback_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pContext: *mut ma_context, ++ deviceType: ma_device_type, ++ pInfo: *const ma_device_info, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_bool32, ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device_descriptor { ++ pub pDeviceID: *const ma_device_id, ++ pub shareMode: ma_share_mode, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub channelMap: [ma_channel; 254usize], ++ pub periodSizeInFrames: ma_uint32, ++ pub periodSizeInMilliseconds: ma_uint32, ++ pub periodCount: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device_descriptor"][::core::mem::size_of::() - 296usize]; ++ ["Alignment of ma_device_descriptor"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device_descriptor::pDeviceID"] ++ [::core::mem::offset_of!(ma_device_descriptor, pDeviceID) - 0usize]; ++ ["Offset of field: ma_device_descriptor::shareMode"] ++ [::core::mem::offset_of!(ma_device_descriptor, shareMode) - 8usize]; ++ ["Offset of field: ma_device_descriptor::format"] ++ [::core::mem::offset_of!(ma_device_descriptor, format) - 12usize]; ++ ["Offset of field: ma_device_descriptor::channels"] ++ [::core::mem::offset_of!(ma_device_descriptor, channels) - 16usize]; ++ ["Offset of field: ma_device_descriptor::sampleRate"] ++ [::core::mem::offset_of!(ma_device_descriptor, sampleRate) - 20usize]; ++ ["Offset of field: ma_device_descriptor::channelMap"] ++ [::core::mem::offset_of!(ma_device_descriptor, channelMap) - 24usize]; ++ ["Offset of field: ma_device_descriptor::periodSizeInFrames"] ++ [::core::mem::offset_of!(ma_device_descriptor, periodSizeInFrames) - 280usize]; ++ ["Offset of field: ma_device_descriptor::periodSizeInMilliseconds"] ++ [::core::mem::offset_of!(ma_device_descriptor, periodSizeInMilliseconds) - 284usize]; ++ ["Offset of field: ma_device_descriptor::periodCount"] ++ [::core::mem::offset_of!(ma_device_descriptor, periodCount) - 288usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_backend_callbacks { ++ pub onContextInit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pContext: *mut ma_context, ++ pConfig: *const ma_context_config, ++ pCallbacks: *mut ma_backend_callbacks, ++ ) -> ma_result, ++ >, ++ pub onContextUninit: ++ ::core::option::Option ma_result>, ++ pub onContextEnumerateDevices: ::core::option::Option< ++ unsafe extern "C" fn( ++ pContext: *mut ma_context, ++ callback: ma_enum_devices_callback_proc, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_result, ++ >, ++ pub onContextGetDeviceInfo: ::core::option::Option< ++ unsafe extern "C" fn( ++ pContext: *mut ma_context, ++ deviceType: ma_device_type, ++ pDeviceID: *const ma_device_id, ++ pDeviceInfo: *mut ma_device_info, ++ ) -> ma_result, ++ >, ++ pub onDeviceInit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ pConfig: *const ma_device_config, ++ pDescriptorPlayback: *mut ma_device_descriptor, ++ pDescriptorCapture: *mut ma_device_descriptor, ++ ) -> ma_result, ++ >, ++ pub onDeviceUninit: ++ ::core::option::Option ma_result>, ++ pub onDeviceStart: ++ ::core::option::Option ma_result>, ++ pub onDeviceStop: ++ ::core::option::Option ma_result>, ++ pub onDeviceRead: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ pFrames: *mut core::ffi::c_void, ++ frameCount: ma_uint32, ++ pFramesRead: *mut ma_uint32, ++ ) -> ma_result, ++ >, ++ pub onDeviceWrite: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ pFrames: *const core::ffi::c_void, ++ frameCount: ma_uint32, ++ pFramesWritten: *mut ma_uint32, ++ ) -> ma_result, ++ >, ++ pub onDeviceDataLoop: ++ ::core::option::Option ma_result>, ++ pub onDeviceDataLoopWakeup: ++ ::core::option::Option ma_result>, ++ pub onDeviceGetInfo: ::core::option::Option< ++ unsafe extern "C" fn( ++ pDevice: *mut ma_device, ++ type_: ma_device_type, ++ pDeviceInfo: *mut ma_device_info, ++ ) -> ma_result, ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_backend_callbacks"][::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_backend_callbacks"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_backend_callbacks::onContextInit"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onContextInit) - 0usize]; ++ ["Offset of field: ma_backend_callbacks::onContextUninit"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onContextUninit) - 8usize]; ++ ["Offset of field: ma_backend_callbacks::onContextEnumerateDevices"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onContextEnumerateDevices) - 16usize]; ++ ["Offset of field: ma_backend_callbacks::onContextGetDeviceInfo"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onContextGetDeviceInfo) - 24usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceInit"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceInit) - 32usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceUninit"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceUninit) - 40usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceStart"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceStart) - 48usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceStop"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceStop) - 56usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceRead"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceRead) - 64usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceWrite"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceWrite) - 72usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceDataLoop"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceDataLoop) - 80usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceDataLoopWakeup"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceDataLoopWakeup) - 88usize]; ++ ["Offset of field: ma_backend_callbacks::onDeviceGetInfo"] ++ [::core::mem::offset_of!(ma_backend_callbacks, onDeviceGetInfo) - 96usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config { ++ pub pLog: *mut ma_log, ++ pub threadPriority: ma_thread_priority, ++ pub threadStackSize: usize, ++ pub pUserData: *mut core::ffi::c_void, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub dsound: ma_context_config__bindgen_ty_1, ++ pub alsa: ma_context_config__bindgen_ty_2, ++ pub pulse: ma_context_config__bindgen_ty_3, ++ pub coreaudio: ma_context_config__bindgen_ty_4, ++ pub jack: ma_context_config__bindgen_ty_5, ++ pub custom: ma_backend_callbacks, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_1 { ++ pub hWnd: ma_handle, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_1"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_context_config__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_1::hWnd"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_1, hWnd) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_2 { ++ pub useVerboseDeviceEnumeration: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_2"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context_config__bindgen_ty_2"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_2::useVerboseDeviceEnumeration"][::core::mem::offset_of!( ++ ma_context_config__bindgen_ty_2, ++ useVerboseDeviceEnumeration ++ ) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_3 { ++ pub pApplicationName: *const core::ffi::c_char, ++ pub pServerName: *const core::ffi::c_char, ++ pub tryAutoSpawn: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_3"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_context_config__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_3::pApplicationName"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_3, pApplicationName) - 0usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_3::pServerName"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_3, pServerName) - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_3::tryAutoSpawn"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_3, tryAutoSpawn) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_4 { ++ pub sessionCategory: ma_ios_session_category, ++ pub sessionCategoryOptions: ma_uint32, ++ pub noAudioSessionActivate: ma_bool32, ++ pub noAudioSessionDeactivate: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_4"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_context_config__bindgen_ty_4"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_4::sessionCategory"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_4, sessionCategory) - 0usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_4::sessionCategoryOptions"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_4, sessionCategoryOptions) - 4usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_4::noAudioSessionActivate"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_4, noAudioSessionActivate) - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_4::noAudioSessionDeactivate"][::core::mem::offset_of!( ++ ma_context_config__bindgen_ty_4, ++ noAudioSessionDeactivate ++ ) - 12usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_config__bindgen_ty_5 { ++ pub pClientName: *const core::ffi::c_char, ++ pub tryStartServer: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config__bindgen_ty_5"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_context_config__bindgen_ty_5"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_5::pClientName"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_5, pClientName) - 0usize]; ++ ["Offset of field: ma_context_config__bindgen_ty_5::tryStartServer"] ++ [::core::mem::offset_of!(ma_context_config__bindgen_ty_5, tryStartServer) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_config"][::core::mem::size_of::() - 240usize]; ++ ["Alignment of ma_context_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_config::pLog"] ++ [::core::mem::offset_of!(ma_context_config, pLog) - 0usize]; ++ ["Offset of field: ma_context_config::threadPriority"] ++ [::core::mem::offset_of!(ma_context_config, threadPriority) - 8usize]; ++ ["Offset of field: ma_context_config::threadStackSize"] ++ [::core::mem::offset_of!(ma_context_config, threadStackSize) - 16usize]; ++ ["Offset of field: ma_context_config::pUserData"] ++ [::core::mem::offset_of!(ma_context_config, pUserData) - 24usize]; ++ ["Offset of field: ma_context_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_context_config, allocationCallbacks) - 32usize]; ++ ["Offset of field: ma_context_config::dsound"] ++ [::core::mem::offset_of!(ma_context_config, dsound) - 64usize]; ++ ["Offset of field: ma_context_config::alsa"] ++ [::core::mem::offset_of!(ma_context_config, alsa) - 72usize]; ++ ["Offset of field: ma_context_config::pulse"] ++ [::core::mem::offset_of!(ma_context_config, pulse) - 80usize]; ++ ["Offset of field: ma_context_config::coreaudio"] ++ [::core::mem::offset_of!(ma_context_config, coreaudio) - 104usize]; ++ ["Offset of field: ma_context_config::jack"] ++ [::core::mem::offset_of!(ma_context_config, jack) - 120usize]; ++ ["Offset of field: ma_context_config::custom"] ++ [::core::mem::offset_of!(ma_context_config, custom) - 136usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_context_command__wasapi { ++ pub code: core::ffi::c_int, ++ pub pEvent: *mut ma_event, ++ pub data: ma_context_command__wasapi__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_context_command__wasapi__bindgen_ty_1 { ++ pub quit: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1, ++ pub createAudioClient: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ pub releaseAudioClient: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1"][::core::mem::align_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1, ++ >() - 4usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1::_unused"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_1, ++ _unused ++ ) ++ - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2 { ++ pub deviceType: ma_device_type, ++ pub pAudioClient: *mut core::ffi::c_void, ++ pub ppAudioClientService: *mut *mut core::ffi::c_void, ++ pub pResult: *mut ma_result, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2"][::core::mem::size_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ >() - 32usize]; ++ ["Alignment of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2"][::core::mem::align_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ >() - 8usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2::deviceType"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ deviceType ++ ) ++ - 0usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2::pAudioClient"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ pAudioClient ++ ) ++ - 8usize]; ++ [ ++ "Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2::ppAudioClientService", ++ ][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ ppAudioClientService ++ ) - 16usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2::pResult"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_2, ++ pResult ++ ) ++ - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3 { ++ pub pDevice: *mut ma_device, ++ pub deviceType: ma_device_type, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3"][::core::mem::size_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++ >() - 16usize]; ++ ["Alignment of ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3"][::core::mem::align_of::< ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++ >() - 8usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3::pDevice"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++ pDevice ++ ) ++ - 0usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3::deviceType"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1__bindgen_ty_3, ++ deviceType ++ ) ++ - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi__bindgen_ty_1"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_context_command__wasapi__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1::quit"] ++ [::core::mem::offset_of!(ma_context_command__wasapi__bindgen_ty_1, quit) - 0usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1::createAudioClient"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1, ++ createAudioClient ++ ) - 0usize]; ++ ["Offset of field: ma_context_command__wasapi__bindgen_ty_1::releaseAudioClient"][::core::mem::offset_of!( ++ ma_context_command__wasapi__bindgen_ty_1, ++ releaseAudioClient ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context_command__wasapi"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_context_command__wasapi"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context_command__wasapi::code"] ++ [::core::mem::offset_of!(ma_context_command__wasapi, code) - 0usize]; ++ ["Offset of field: ma_context_command__wasapi::pEvent"] ++ [::core::mem::offset_of!(ma_context_command__wasapi, pEvent) - 8usize]; ++ ["Offset of field: ma_context_command__wasapi::data"] ++ [::core::mem::offset_of!(ma_context_command__wasapi, data) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_context { ++ pub callbacks: ma_backend_callbacks, ++ pub backend: ma_backend, ++ pub pLog: *mut ma_log, ++ pub log: ma_log, ++ pub threadPriority: ma_thread_priority, ++ pub threadStackSize: usize, ++ pub pUserData: *mut core::ffi::c_void, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub deviceEnumLock: ma_mutex, ++ pub deviceInfoLock: ma_mutex, ++ pub deviceInfoCapacity: ma_uint32, ++ pub playbackDeviceInfoCount: ma_uint32, ++ pub captureDeviceInfoCount: ma_uint32, ++ pub pDeviceInfos: *mut ma_device_info, ++ pub __bindgen_anon_1: ma_context__bindgen_ty_1, ++ pub __bindgen_anon_2: ma_context__bindgen_ty_2, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_context__bindgen_ty_1 { ++ pub alsa: ma_context__bindgen_ty_1__bindgen_ty_1, ++ pub pulse: ma_context__bindgen_ty_1__bindgen_ty_2, ++ pub jack: ma_context__bindgen_ty_1__bindgen_ty_3, ++ pub null_backend: ma_context__bindgen_ty_1__bindgen_ty_4, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_context__bindgen_ty_1__bindgen_ty_1 { ++ pub asoundSO: ma_handle, ++ pub snd_pcm_open: ma_proc, ++ pub snd_pcm_close: ma_proc, ++ pub snd_pcm_hw_params_sizeof: ma_proc, ++ pub snd_pcm_hw_params_any: ma_proc, ++ pub snd_pcm_hw_params_set_format: ma_proc, ++ pub snd_pcm_hw_params_set_format_first: ma_proc, ++ pub snd_pcm_hw_params_get_format_mask: ma_proc, ++ pub snd_pcm_hw_params_set_channels: ma_proc, ++ pub snd_pcm_hw_params_set_channels_near: ma_proc, ++ pub snd_pcm_hw_params_set_channels_minmax: ma_proc, ++ pub snd_pcm_hw_params_set_rate_resample: ma_proc, ++ pub snd_pcm_hw_params_set_rate: ma_proc, ++ pub snd_pcm_hw_params_set_rate_near: ma_proc, ++ pub snd_pcm_hw_params_set_rate_minmax: ma_proc, ++ pub snd_pcm_hw_params_set_buffer_size_near: ma_proc, ++ pub snd_pcm_hw_params_set_periods_near: ma_proc, ++ pub snd_pcm_hw_params_set_access: ma_proc, ++ pub snd_pcm_hw_params_get_format: ma_proc, ++ pub snd_pcm_hw_params_get_channels: ma_proc, ++ pub snd_pcm_hw_params_get_channels_min: ma_proc, ++ pub snd_pcm_hw_params_get_channels_max: ma_proc, ++ pub snd_pcm_hw_params_get_rate: ma_proc, ++ pub snd_pcm_hw_params_get_rate_min: ma_proc, ++ pub snd_pcm_hw_params_get_rate_max: ma_proc, ++ pub snd_pcm_hw_params_get_buffer_size: ma_proc, ++ pub snd_pcm_hw_params_get_periods: ma_proc, ++ pub snd_pcm_hw_params_get_access: ma_proc, ++ pub snd_pcm_hw_params_test_format: ma_proc, ++ pub snd_pcm_hw_params_test_channels: ma_proc, ++ pub snd_pcm_hw_params_test_rate: ma_proc, ++ pub snd_pcm_hw_params: ma_proc, ++ pub snd_pcm_sw_params_sizeof: ma_proc, ++ pub snd_pcm_sw_params_current: ma_proc, ++ pub snd_pcm_sw_params_get_boundary: ma_proc, ++ pub snd_pcm_sw_params_set_avail_min: ma_proc, ++ pub snd_pcm_sw_params_set_start_threshold: ma_proc, ++ pub snd_pcm_sw_params_set_stop_threshold: ma_proc, ++ pub snd_pcm_sw_params: ma_proc, ++ pub snd_pcm_format_mask_sizeof: ma_proc, ++ pub snd_pcm_format_mask_test: ma_proc, ++ pub snd_pcm_get_chmap: ma_proc, ++ pub snd_pcm_state: ma_proc, ++ pub snd_pcm_prepare: ma_proc, ++ pub snd_pcm_start: ma_proc, ++ pub snd_pcm_drop: ma_proc, ++ pub snd_pcm_drain: ma_proc, ++ pub snd_pcm_reset: ma_proc, ++ pub snd_device_name_hint: ma_proc, ++ pub snd_device_name_get_hint: ma_proc, ++ pub snd_card_get_index: ma_proc, ++ pub snd_device_name_free_hint: ma_proc, ++ pub snd_pcm_mmap_begin: ma_proc, ++ pub snd_pcm_mmap_commit: ma_proc, ++ pub snd_pcm_recover: ma_proc, ++ pub snd_pcm_readi: ma_proc, ++ pub snd_pcm_writei: ma_proc, ++ pub snd_pcm_avail: ma_proc, ++ pub snd_pcm_avail_update: ma_proc, ++ pub snd_pcm_wait: ma_proc, ++ pub snd_pcm_nonblock: ma_proc, ++ pub snd_pcm_info: ma_proc, ++ pub snd_pcm_info_sizeof: ma_proc, ++ pub snd_pcm_info_get_name: ma_proc, ++ pub snd_pcm_poll_descriptors: ma_proc, ++ pub snd_pcm_poll_descriptors_count: ma_proc, ++ pub snd_pcm_poll_descriptors_revents: ma_proc, ++ pub snd_config_update_free_global: ma_proc, ++ pub internalDeviceEnumLock: ma_mutex, ++ pub useVerboseDeviceEnumeration: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 592usize]; ++ ["Alignment of ma_context__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::asoundSO"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, asoundSO) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_open"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_open) - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_close"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_close) - 16usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_sizeof"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_sizeof ++ ) ++ - 24usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_any"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_any ++ ) - 32usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_format"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_format ++ ) ++ - 40usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_format_first"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_format_first ++ ) - 48usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_format_mask"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_format_mask ++ ) - 56usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_channels"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_channels ++ ) ++ - 64usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_channels_near", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_channels_near ++ ) - 72usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_channels_minmax", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_channels_minmax ++ ) - 80usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_rate_resample", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_rate_resample ++ ) - 88usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_rate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_rate ++ ) ++ - 96usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_rate_near"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_rate_near ++ ) ++ - 104usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_rate_minmax"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_rate_minmax ++ ) - 112usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_buffer_size_near", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_buffer_size_near ++ ) - 120usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_periods_near"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_periods_near ++ ) - 128usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_set_access"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_set_access ++ ) ++ - 136usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_format"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_format ++ ) ++ - 144usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_channels"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_channels ++ ) ++ - 152usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_channels_min"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_channels_min ++ ) - 160usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_channels_max"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_channels_max ++ ) - 168usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_rate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_rate ++ ) ++ - 176usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_rate_min"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_rate_min ++ ) ++ - 184usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_rate_max"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_rate_max ++ ) ++ - 192usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_buffer_size"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_buffer_size ++ ) - 200usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_periods"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_periods ++ ) ++ - 208usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_get_access"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_get_access ++ ) ++ - 216usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_test_format"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_test_format ++ ) ++ - 224usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_test_channels"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_test_channels ++ ) ++ - 232usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params_test_rate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params_test_rate ++ ) ++ - 240usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_hw_params"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_hw_params ++ ) - 248usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_sizeof"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_sizeof ++ ) ++ - 256usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_current"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_current ++ ) ++ - 264usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_get_boundary"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_get_boundary ++ ) ++ - 272usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_set_avail_min"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_set_avail_min ++ ) ++ - 280usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_set_start_threshold", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_set_start_threshold ++ ) - 288usize]; ++ [ ++ "Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params_set_stop_threshold", ++ ][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params_set_stop_threshold ++ ) - 296usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_sw_params"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_sw_params ++ ) - 304usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_format_mask_sizeof"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_format_mask_sizeof ++ ) ++ - 312usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_format_mask_test"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_format_mask_test ++ ) ++ - 320usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_get_chmap"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_get_chmap ++ ) - 328usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_state"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_state) - 336usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_prepare"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_prepare ++ ) - 344usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_start"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_start) - 352usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_drop"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_drop) - 360usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_drain"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_drain) - 368usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_reset"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_reset) - 376usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_device_name_hint"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_device_name_hint ++ ) - 384usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_device_name_get_hint"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_device_name_get_hint ++ ) ++ - 392usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_card_get_index"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_card_get_index ++ ) - 400usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_device_name_free_hint"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_device_name_free_hint ++ ) ++ - 408usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_mmap_begin"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_mmap_begin ++ ) - 416usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_mmap_commit"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_mmap_commit ++ ) - 424usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_recover"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_recover ++ ) - 432usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_readi"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_readi) - 440usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_writei"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_writei ++ ) - 448usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_avail"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_avail) - 456usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_avail_update"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_avail_update ++ ) - 464usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_wait"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_wait) - 472usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_nonblock"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_nonblock ++ ) - 480usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_info"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_1, snd_pcm_info) - 488usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_info_sizeof"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_info_sizeof ++ ) - 496usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_info_get_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_info_get_name ++ ) ++ - 504usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_poll_descriptors"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_poll_descriptors ++ ) ++ - 512usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_poll_descriptors_count"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_poll_descriptors_count ++ ) ++ - 520usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_pcm_poll_descriptors_revents"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_pcm_poll_descriptors_revents ++ ) ++ - 528usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::snd_config_update_free_global"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ snd_config_update_free_global ++ ) ++ - 536usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::internalDeviceEnumLock"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ internalDeviceEnumLock ++ ) ++ - 544usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_1::useVerboseDeviceEnumeration"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_1, ++ useVerboseDeviceEnumeration ++ ) ++ - 584usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context__bindgen_ty_1__bindgen_ty_2 { ++ pub pulseSO: ma_handle, ++ pub pa_mainloop_new: ma_proc, ++ pub pa_mainloop_free: ma_proc, ++ pub pa_mainloop_quit: ma_proc, ++ pub pa_mainloop_get_api: ma_proc, ++ pub pa_mainloop_iterate: ma_proc, ++ pub pa_mainloop_wakeup: ma_proc, ++ pub pa_threaded_mainloop_new: ma_proc, ++ pub pa_threaded_mainloop_free: ma_proc, ++ pub pa_threaded_mainloop_start: ma_proc, ++ pub pa_threaded_mainloop_stop: ma_proc, ++ pub pa_threaded_mainloop_lock: ma_proc, ++ pub pa_threaded_mainloop_unlock: ma_proc, ++ pub pa_threaded_mainloop_wait: ma_proc, ++ pub pa_threaded_mainloop_signal: ma_proc, ++ pub pa_threaded_mainloop_accept: ma_proc, ++ pub pa_threaded_mainloop_get_retval: ma_proc, ++ pub pa_threaded_mainloop_get_api: ma_proc, ++ pub pa_threaded_mainloop_in_thread: ma_proc, ++ pub pa_threaded_mainloop_set_name: ma_proc, ++ pub pa_context_new: ma_proc, ++ pub pa_context_unref: ma_proc, ++ pub pa_context_connect: ma_proc, ++ pub pa_context_disconnect: ma_proc, ++ pub pa_context_set_state_callback: ma_proc, ++ pub pa_context_get_state: ma_proc, ++ pub pa_context_get_sink_info_list: ma_proc, ++ pub pa_context_get_source_info_list: ma_proc, ++ pub pa_context_get_sink_info_by_name: ma_proc, ++ pub pa_context_get_source_info_by_name: ma_proc, ++ pub pa_operation_unref: ma_proc, ++ pub pa_operation_get_state: ma_proc, ++ pub pa_channel_map_init_extend: ma_proc, ++ pub pa_channel_map_valid: ma_proc, ++ pub pa_channel_map_compatible: ma_proc, ++ pub pa_stream_new: ma_proc, ++ pub pa_stream_unref: ma_proc, ++ pub pa_stream_connect_playback: ma_proc, ++ pub pa_stream_connect_record: ma_proc, ++ pub pa_stream_disconnect: ma_proc, ++ pub pa_stream_get_state: ma_proc, ++ pub pa_stream_get_sample_spec: ma_proc, ++ pub pa_stream_get_channel_map: ma_proc, ++ pub pa_stream_get_buffer_attr: ma_proc, ++ pub pa_stream_set_buffer_attr: ma_proc, ++ pub pa_stream_get_device_name: ma_proc, ++ pub pa_stream_set_write_callback: ma_proc, ++ pub pa_stream_set_read_callback: ma_proc, ++ pub pa_stream_set_suspended_callback: ma_proc, ++ pub pa_stream_set_moved_callback: ma_proc, ++ pub pa_stream_is_suspended: ma_proc, ++ pub pa_stream_flush: ma_proc, ++ pub pa_stream_drain: ma_proc, ++ pub pa_stream_is_corked: ma_proc, ++ pub pa_stream_cork: ma_proc, ++ pub pa_stream_trigger: ma_proc, ++ pub pa_stream_begin_write: ma_proc, ++ pub pa_stream_write: ma_proc, ++ pub pa_stream_peek: ma_proc, ++ pub pa_stream_drop: ma_proc, ++ pub pa_stream_writable_size: ma_proc, ++ pub pa_stream_readable_size: ma_proc, ++ pub pMainLoop: ma_ptr, ++ pub pPulseContext: ma_ptr, ++ pub pApplicationName: *mut core::ffi::c_char, ++ pub pServerName: *mut core::ffi::c_char, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::size_of::() - 528usize]; ++ ["Alignment of ma_context__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pulseSO"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pulseSO) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_new"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pa_mainloop_new) - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_free"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_free ++ ) - 16usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_quit"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_quit ++ ) - 24usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_get_api"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_get_api ++ ) - 32usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_iterate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_iterate ++ ) - 40usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_mainloop_wakeup"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_mainloop_wakeup ++ ) - 48usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_new"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_new ++ ) ++ - 56usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_free"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_free ++ ) ++ - 64usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_start"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_start ++ ) ++ - 72usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_stop"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_stop ++ ) ++ - 80usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_lock"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_lock ++ ) ++ - 88usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_unlock"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_unlock ++ ) ++ - 96usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_wait"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_wait ++ ) ++ - 104usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_signal"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_signal ++ ) ++ - 112usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_accept"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_accept ++ ) ++ - 120usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_get_retval"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_get_retval ++ ) ++ - 128usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_get_api"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_get_api ++ ) ++ - 136usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_in_thread"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_in_thread ++ ) ++ - 144usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_threaded_mainloop_set_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_threaded_mainloop_set_name ++ ) ++ - 152usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_new"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_new ++ ) - 160usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_unref"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_unref ++ ) - 168usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_connect"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_connect ++ ) - 176usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_disconnect"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_disconnect ++ ) ++ - 184usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_set_state_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_set_state_callback ++ ) ++ - 192usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_state"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_state ++ ) - 200usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_sink_info_list"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_sink_info_list ++ ) ++ - 208usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_source_info_list"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_source_info_list ++ ) ++ - 216usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_sink_info_by_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_sink_info_by_name ++ ) ++ - 224usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_context_get_source_info_by_name"] ++ [::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_context_get_source_info_by_name ++ ) - 232usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_operation_unref"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_operation_unref ++ ) - 240usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_operation_get_state"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_operation_get_state ++ ) ++ - 248usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_channel_map_init_extend"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_channel_map_init_extend ++ ) ++ - 256usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_channel_map_valid"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_channel_map_valid ++ ) - 264usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_channel_map_compatible"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_channel_map_compatible ++ ) ++ - 272usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_new"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pa_stream_new) - 280usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_unref"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_unref ++ ) - 288usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_connect_playback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_connect_playback ++ ) ++ - 296usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_connect_record"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_connect_record ++ ) ++ - 304usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_disconnect"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_disconnect ++ ) - 312usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_state"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_state ++ ) - 320usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_sample_spec"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_sample_spec ++ ) ++ - 328usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_channel_map"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_channel_map ++ ) ++ - 336usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_buffer_attr"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_buffer_attr ++ ) ++ - 344usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_buffer_attr"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_buffer_attr ++ ) ++ - 352usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_get_device_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_get_device_name ++ ) ++ - 360usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_write_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_write_callback ++ ) ++ - 368usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_read_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_read_callback ++ ) ++ - 376usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_suspended_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_suspended_callback ++ ) ++ - 384usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_set_moved_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_set_moved_callback ++ ) ++ - 392usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_is_suspended"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_is_suspended ++ ) ++ - 400usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_flush"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_flush ++ ) - 408usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_drain"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_drain ++ ) - 416usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_is_corked"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_is_corked ++ ) - 424usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_cork"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_cork ++ ) - 432usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_trigger"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_trigger ++ ) - 440usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_begin_write"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_begin_write ++ ) ++ - 448usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_write"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_write ++ ) - 456usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_peek"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_peek ++ ) - 464usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_drop"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_drop ++ ) - 472usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_writable_size"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_writable_size ++ ) ++ - 480usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pa_stream_readable_size"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pa_stream_readable_size ++ ) ++ - 488usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pMainLoop"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pMainLoop) - 496usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pPulseContext"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pPulseContext) - 504usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pApplicationName"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_2, ++ pApplicationName ++ ) - 512usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_2::pServerName"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_2, pServerName) - 520usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context__bindgen_ty_1__bindgen_ty_3 { ++ pub jackSO: ma_handle, ++ pub jack_client_open: ma_proc, ++ pub jack_client_close: ma_proc, ++ pub jack_client_name_size: ma_proc, ++ pub jack_set_process_callback: ma_proc, ++ pub jack_set_buffer_size_callback: ma_proc, ++ pub jack_on_shutdown: ma_proc, ++ pub jack_get_sample_rate: ma_proc, ++ pub jack_get_buffer_size: ma_proc, ++ pub jack_get_ports: ma_proc, ++ pub jack_activate: ma_proc, ++ pub jack_deactivate: ma_proc, ++ pub jack_connect: ma_proc, ++ pub jack_port_register: ma_proc, ++ pub jack_port_name: ma_proc, ++ pub jack_port_get_buffer: ma_proc, ++ pub jack_free: ma_proc, ++ pub pClientName: *mut core::ffi::c_char, ++ pub tryStartServer: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_context__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jackSO"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jackSO) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_client_open"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_client_open ++ ) - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_client_close"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_client_close ++ ) - 16usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_client_name_size"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_client_name_size ++ ) - 24usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_set_process_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_set_process_callback ++ ) ++ - 32usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_set_buffer_size_callback"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_set_buffer_size_callback ++ ) ++ - 40usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_on_shutdown"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_on_shutdown ++ ) - 48usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_get_sample_rate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_get_sample_rate ++ ) - 56usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_get_buffer_size"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_get_buffer_size ++ ) - 64usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_get_ports"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jack_get_ports) - 72usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_activate"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jack_activate) - 80usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_deactivate"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_deactivate ++ ) - 88usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_connect"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jack_connect) - 96usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_port_register"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_port_register ++ ) - 104usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_port_name"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_port_name ++ ) - 112usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_port_get_buffer"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ jack_port_get_buffer ++ ) - 120usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::jack_free"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, jack_free) - 128usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::pClientName"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_3, pClientName) - 136usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_3::tryStartServer"][::core::mem::offset_of!( ++ ma_context__bindgen_ty_1__bindgen_ty_3, ++ tryStartServer ++ ) - 144usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context__bindgen_ty_1__bindgen_ty_4 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1__bindgen_ty_4"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context__bindgen_ty_1__bindgen_ty_4"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context__bindgen_ty_1__bindgen_ty_4::_unused"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1__bindgen_ty_4, _unused) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_1"] ++ [::core::mem::size_of::() - 592usize]; ++ ["Alignment of ma_context__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context__bindgen_ty_1::alsa"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1, alsa) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1::pulse"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1, pulse) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1::jack"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1, jack) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_1::null_backend"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_1, null_backend) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_context__bindgen_ty_2 { ++ pub posix: ma_context__bindgen_ty_2__bindgen_ty_1, ++ pub _unused: core::ffi::c_int, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_context__bindgen_ty_2__bindgen_ty_1 { ++ pub _unused: core::ffi::c_int, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context__bindgen_ty_2__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context__bindgen_ty_2__bindgen_ty_1::_unused"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_2__bindgen_ty_1, _unused) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context__bindgen_ty_2"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_context__bindgen_ty_2"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_context__bindgen_ty_2::posix"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_2, posix) - 0usize]; ++ ["Offset of field: ma_context__bindgen_ty_2::_unused"] ++ [::core::mem::offset_of!(ma_context__bindgen_ty_2, _unused) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_context"][::core::mem::size_of::() - 1024usize]; ++ ["Alignment of ma_context"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_context::callbacks"] ++ [::core::mem::offset_of!(ma_context, callbacks) - 0usize]; ++ ["Offset of field: ma_context::backend"] ++ [::core::mem::offset_of!(ma_context, backend) - 104usize]; ++ ["Offset of field: ma_context::pLog"][::core::mem::offset_of!(ma_context, pLog) - 112usize]; ++ ["Offset of field: ma_context::log"][::core::mem::offset_of!(ma_context, log) - 120usize]; ++ ["Offset of field: ma_context::threadPriority"] ++ [::core::mem::offset_of!(ma_context, threadPriority) - 264usize]; ++ ["Offset of field: ma_context::threadStackSize"] ++ [::core::mem::offset_of!(ma_context, threadStackSize) - 272usize]; ++ ["Offset of field: ma_context::pUserData"] ++ [::core::mem::offset_of!(ma_context, pUserData) - 280usize]; ++ ["Offset of field: ma_context::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_context, allocationCallbacks) - 288usize]; ++ ["Offset of field: ma_context::deviceEnumLock"] ++ [::core::mem::offset_of!(ma_context, deviceEnumLock) - 320usize]; ++ ["Offset of field: ma_context::deviceInfoLock"] ++ [::core::mem::offset_of!(ma_context, deviceInfoLock) - 360usize]; ++ ["Offset of field: ma_context::deviceInfoCapacity"] ++ [::core::mem::offset_of!(ma_context, deviceInfoCapacity) - 400usize]; ++ ["Offset of field: ma_context::playbackDeviceInfoCount"] ++ [::core::mem::offset_of!(ma_context, playbackDeviceInfoCount) - 404usize]; ++ ["Offset of field: ma_context::captureDeviceInfoCount"] ++ [::core::mem::offset_of!(ma_context, captureDeviceInfoCount) - 408usize]; ++ ["Offset of field: ma_context::pDeviceInfos"] ++ [::core::mem::offset_of!(ma_context, pDeviceInfos) - 416usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device { ++ pub pContext: *mut ma_context, ++ pub type_: ma_device_type, ++ pub sampleRate: ma_uint32, ++ pub state: ma_atomic_device_state, ++ pub onData: ma_device_data_proc, ++ pub onNotification: ma_device_notification_proc, ++ pub onStop: ma_stop_proc, ++ pub pUserData: *mut core::ffi::c_void, ++ pub startStopLock: ma_mutex, ++ pub wakeupEvent: ma_event, ++ pub startEvent: ma_event, ++ pub stopEvent: ma_event, ++ pub thread: ma_thread, ++ pub workResult: ma_result, ++ pub isOwnerOfContext: ma_bool8, ++ pub noPreSilencedOutputBuffer: ma_bool8, ++ pub noClip: ma_bool8, ++ pub noDisableDenormals: ma_bool8, ++ pub noFixedSizedCallback: ma_bool8, ++ pub masterVolumeFactor: ma_atomic_float, ++ pub duplexRB: ma_duplex_rb, ++ pub resampling: ma_device__bindgen_ty_1, ++ pub playback: ma_device__bindgen_ty_2, ++ pub capture: ma_device__bindgen_ty_3, ++ pub __bindgen_anon_1: ma_device__bindgen_ty_4, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_1 { ++ pub algorithm: ma_resample_algorithm, ++ pub pBackendVTable: *mut ma_resampling_backend_vtable, ++ pub pBackendUserData: *mut core::ffi::c_void, ++ pub linear: ma_device__bindgen_ty_1__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_1__bindgen_ty_1 { ++ pub lpfOrder: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 4usize]; ++ ["Alignment of ma_device__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_device__bindgen_ty_1__bindgen_ty_1::lpfOrder"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1__bindgen_ty_1, lpfOrder) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_1"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_device__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_1::algorithm"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1, algorithm) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_1::pBackendVTable"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1, pBackendVTable) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_1::pBackendUserData"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1, pBackendUserData) - 16usize]; ++ ["Offset of field: ma_device__bindgen_ty_1::linear"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_1, linear) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device__bindgen_ty_2 { ++ pub pID: *mut ma_device_id, ++ pub id: ma_device_id, ++ pub name: [core::ffi::c_char; 256usize], ++ pub shareMode: ma_share_mode, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub channelMap: [ma_channel; 254usize], ++ pub internalFormat: ma_format, ++ pub internalChannels: ma_uint32, ++ pub internalSampleRate: ma_uint32, ++ pub internalChannelMap: [ma_channel; 254usize], ++ pub internalPeriodSizeInFrames: ma_uint32, ++ pub internalPeriods: ma_uint32, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub converter: ma_data_converter, ++ pub pIntermediaryBuffer: *mut core::ffi::c_void, ++ pub intermediaryBufferCap: ma_uint32, ++ pub intermediaryBufferLen: ma_uint32, ++ pub pInputCache: *mut core::ffi::c_void, ++ pub inputCacheCap: ma_uint64, ++ pub inputCacheConsumed: ma_uint64, ++ pub inputCacheRemaining: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_2"] ++ [::core::mem::size_of::() - 1432usize]; ++ ["Alignment of ma_device__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::pID"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, pID) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::id"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, id) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::name"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, name) - 264usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::shareMode"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, shareMode) - 520usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::format"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, format) - 524usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::channels"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, channels) - 528usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::channelMap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, channelMap) - 532usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalFormat"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalFormat) - 788usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalChannels"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalChannels) - 792usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalSampleRate"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalSampleRate) - 796usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalChannelMap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalChannelMap) - 800usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalPeriodSizeInFrames"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalPeriodSizeInFrames) - 1056usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::internalPeriods"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, internalPeriods) - 1060usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::channelMixMode"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, channelMixMode) - 1064usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_2, ++ calculateLFEFromSpatialChannels ++ ) - 1068usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::converter"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, converter) - 1072usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::pIntermediaryBuffer"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, pIntermediaryBuffer) - 1384usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::intermediaryBufferCap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, intermediaryBufferCap) - 1392usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::intermediaryBufferLen"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, intermediaryBufferLen) - 1396usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::pInputCache"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, pInputCache) - 1400usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::inputCacheCap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, inputCacheCap) - 1408usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::inputCacheConsumed"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, inputCacheConsumed) - 1416usize]; ++ ["Offset of field: ma_device__bindgen_ty_2::inputCacheRemaining"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_2, inputCacheRemaining) - 1424usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device__bindgen_ty_3 { ++ pub pID: *mut ma_device_id, ++ pub id: ma_device_id, ++ pub name: [core::ffi::c_char; 256usize], ++ pub shareMode: ma_share_mode, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub channelMap: [ma_channel; 254usize], ++ pub internalFormat: ma_format, ++ pub internalChannels: ma_uint32, ++ pub internalSampleRate: ma_uint32, ++ pub internalChannelMap: [ma_channel; 254usize], ++ pub internalPeriodSizeInFrames: ma_uint32, ++ pub internalPeriods: ma_uint32, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub calculateLFEFromSpatialChannels: ma_bool32, ++ pub converter: ma_data_converter, ++ pub pIntermediaryBuffer: *mut core::ffi::c_void, ++ pub intermediaryBufferCap: ma_uint32, ++ pub intermediaryBufferLen: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_3"] ++ [::core::mem::size_of::() - 1400usize]; ++ ["Alignment of ma_device__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::pID"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, pID) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::id"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, id) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::name"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, name) - 264usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::shareMode"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, shareMode) - 520usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::format"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, format) - 524usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::channels"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, channels) - 528usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::channelMap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, channelMap) - 532usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalFormat"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalFormat) - 788usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalChannels"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalChannels) - 792usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalSampleRate"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalSampleRate) - 796usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalChannelMap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalChannelMap) - 800usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalPeriodSizeInFrames"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalPeriodSizeInFrames) - 1056usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::internalPeriods"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, internalPeriods) - 1060usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::channelMixMode"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, channelMixMode) - 1064usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::calculateLFEFromSpatialChannels"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_3, ++ calculateLFEFromSpatialChannels ++ ) - 1068usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::converter"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, converter) - 1072usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::pIntermediaryBuffer"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, pIntermediaryBuffer) - 1384usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::intermediaryBufferCap"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, intermediaryBufferCap) - 1392usize]; ++ ["Offset of field: ma_device__bindgen_ty_3::intermediaryBufferLen"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_3, intermediaryBufferLen) - 1396usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_device__bindgen_ty_4 { ++ pub alsa: ma_device__bindgen_ty_4__bindgen_ty_1, ++ pub pulse: ma_device__bindgen_ty_4__bindgen_ty_2, ++ pub jack: ma_device__bindgen_ty_4__bindgen_ty_3, ++ pub null_device: ma_device__bindgen_ty_4__bindgen_ty_4, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_4__bindgen_ty_1 { ++ pub pPCMPlayback: ma_ptr, ++ pub pPCMCapture: ma_ptr, ++ pub pPollDescriptorsPlayback: *mut core::ffi::c_void, ++ pub pPollDescriptorsCapture: *mut core::ffi::c_void, ++ pub pollDescriptorCountPlayback: core::ffi::c_int, ++ pub pollDescriptorCountCapture: core::ffi::c_int, ++ pub wakeupfdPlayback: core::ffi::c_int, ++ pub wakeupfdCapture: core::ffi::c_int, ++ pub isUsingMMapPlayback: ma_bool8, ++ pub isUsingMMapCapture: ma_bool8, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4__bindgen_ty_1"] ++ [::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_device__bindgen_ty_4__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pPCMPlayback"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_1, pPCMPlayback) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pPCMCapture"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_1, pPCMCapture) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pPollDescriptorsPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ pPollDescriptorsPlayback ++ ) ++ - 16usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pPollDescriptorsCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ pPollDescriptorsCapture ++ ) ++ - 24usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pollDescriptorCountPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ pollDescriptorCountPlayback ++ ) ++ - 32usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::pollDescriptorCountCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ pollDescriptorCountCapture ++ ) ++ - 36usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::wakeupfdPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ wakeupfdPlayback ++ ) - 40usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::wakeupfdCapture"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_1, wakeupfdCapture) - 44usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::isUsingMMapPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ isUsingMMapPlayback ++ ) - 48usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_1::isUsingMMapCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_1, ++ isUsingMMapCapture ++ ) - 49usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_4__bindgen_ty_2 { ++ pub pMainLoop: ma_ptr, ++ pub pPulseContext: ma_ptr, ++ pub pStreamPlayback: ma_ptr, ++ pub pStreamCapture: ma_ptr, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4__bindgen_ty_2"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_device__bindgen_ty_4__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_2::pMainLoop"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_2, pMainLoop) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_2::pPulseContext"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_2, pPulseContext) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_2::pStreamPlayback"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_2, pStreamPlayback) - 16usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_2::pStreamCapture"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_2, pStreamCapture) - 24usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_device__bindgen_ty_4__bindgen_ty_3 { ++ pub pClient: ma_ptr, ++ pub ppPortsPlayback: *mut ma_ptr, ++ pub ppPortsCapture: *mut ma_ptr, ++ pub pIntermediaryBufferPlayback: *mut f32, ++ pub pIntermediaryBufferCapture: *mut f32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4__bindgen_ty_3"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_device__bindgen_ty_4__bindgen_ty_3"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::pClient"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_3, pClient) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::ppPortsPlayback"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_3, ppPortsPlayback) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::ppPortsCapture"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_3, ppPortsCapture) - 16usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::pIntermediaryBufferPlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_3, ++ pIntermediaryBufferPlayback ++ ) ++ - 24usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_3::pIntermediaryBufferCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_3, ++ pIntermediaryBufferCapture ++ ) ++ - 32usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_device__bindgen_ty_4__bindgen_ty_4 { ++ pub deviceThread: ma_thread, ++ pub operationEvent: ma_event, ++ pub operationCompletionEvent: ma_event, ++ pub operationSemaphore: ma_semaphore, ++ pub operation: ma_uint32, ++ pub operationResult: ma_result, ++ pub timer: ma_timer, ++ pub priorRunTime: f64, ++ pub currentPeriodFramesRemainingPlayback: ma_uint32, ++ pub currentPeriodFramesRemainingCapture: ma_uint32, ++ pub lastProcessedFramePlayback: ma_uint64, ++ pub lastProcessedFrameCapture: ma_uint64, ++ pub isStarted: ma_atomic_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4__bindgen_ty_4"] ++ [::core::mem::size_of::() - 352usize]; ++ ["Alignment of ma_device__bindgen_ty_4__bindgen_ty_4"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::deviceThread"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, deviceThread) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operationEvent"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, operationEvent) - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operationCompletionEvent"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ operationCompletionEvent ++ ) ++ - 104usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operationSemaphore"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ operationSemaphore ++ ) - 200usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operation"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, operation) - 296usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::operationResult"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ operationResult ++ ) - 300usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::timer"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, timer) - 304usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::priorRunTime"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, priorRunTime) - 312usize]; ++ [ ++ "Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::currentPeriodFramesRemainingPlayback", ++ ][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ currentPeriodFramesRemainingPlayback ++ ) - 320usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::currentPeriodFramesRemainingCapture"] ++ [::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ currentPeriodFramesRemainingCapture ++ ) - 324usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::lastProcessedFramePlayback"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ lastProcessedFramePlayback ++ ) ++ - 328usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::lastProcessedFrameCapture"][::core::mem::offset_of!( ++ ma_device__bindgen_ty_4__bindgen_ty_4, ++ lastProcessedFrameCapture ++ ) ++ - 336usize]; ++ ["Offset of field: ma_device__bindgen_ty_4__bindgen_ty_4::isStarted"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4__bindgen_ty_4, isStarted) - 344usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device__bindgen_ty_4"] ++ [::core::mem::size_of::() - 352usize]; ++ ["Alignment of ma_device__bindgen_ty_4"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device__bindgen_ty_4::alsa"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4, alsa) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4::pulse"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4, pulse) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4::jack"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4, jack) - 0usize]; ++ ["Offset of field: ma_device__bindgen_ty_4::null_device"] ++ [::core::mem::offset_of!(ma_device__bindgen_ty_4, null_device) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_device"][::core::mem::size_of::() - 3776usize]; ++ ["Alignment of ma_device"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_device::pContext"][::core::mem::offset_of!(ma_device, pContext) - 0usize]; ++ ["Offset of field: ma_device::type_"][::core::mem::offset_of!(ma_device, type_) - 8usize]; ++ ["Offset of field: ma_device::sampleRate"] ++ [::core::mem::offset_of!(ma_device, sampleRate) - 12usize]; ++ ["Offset of field: ma_device::state"][::core::mem::offset_of!(ma_device, state) - 16usize]; ++ ["Offset of field: ma_device::onData"][::core::mem::offset_of!(ma_device, onData) - 24usize]; ++ ["Offset of field: ma_device::onNotification"] ++ [::core::mem::offset_of!(ma_device, onNotification) - 32usize]; ++ ["Offset of field: ma_device::onStop"][::core::mem::offset_of!(ma_device, onStop) - 40usize]; ++ ["Offset of field: ma_device::pUserData"] ++ [::core::mem::offset_of!(ma_device, pUserData) - 48usize]; ++ ["Offset of field: ma_device::startStopLock"] ++ [::core::mem::offset_of!(ma_device, startStopLock) - 56usize]; ++ ["Offset of field: ma_device::wakeupEvent"] ++ [::core::mem::offset_of!(ma_device, wakeupEvent) - 96usize]; ++ ["Offset of field: ma_device::startEvent"] ++ [::core::mem::offset_of!(ma_device, startEvent) - 192usize]; ++ ["Offset of field: ma_device::stopEvent"] ++ [::core::mem::offset_of!(ma_device, stopEvent) - 288usize]; ++ ["Offset of field: ma_device::thread"][::core::mem::offset_of!(ma_device, thread) - 384usize]; ++ ["Offset of field: ma_device::workResult"] ++ [::core::mem::offset_of!(ma_device, workResult) - 392usize]; ++ ["Offset of field: ma_device::isOwnerOfContext"] ++ [::core::mem::offset_of!(ma_device, isOwnerOfContext) - 396usize]; ++ ["Offset of field: ma_device::noPreSilencedOutputBuffer"] ++ [::core::mem::offset_of!(ma_device, noPreSilencedOutputBuffer) - 397usize]; ++ ["Offset of field: ma_device::noClip"][::core::mem::offset_of!(ma_device, noClip) - 398usize]; ++ ["Offset of field: ma_device::noDisableDenormals"] ++ [::core::mem::offset_of!(ma_device, noDisableDenormals) - 399usize]; ++ ["Offset of field: ma_device::noFixedSizedCallback"] ++ [::core::mem::offset_of!(ma_device, noFixedSizedCallback) - 400usize]; ++ ["Offset of field: ma_device::masterVolumeFactor"] ++ [::core::mem::offset_of!(ma_device, masterVolumeFactor) - 404usize]; ++ ["Offset of field: ma_device::duplexRB"] ++ [::core::mem::offset_of!(ma_device, duplexRB) - 408usize]; ++ ["Offset of field: ma_device::resampling"] ++ [::core::mem::offset_of!(ma_device, resampling) - 560usize]; ++ ["Offset of field: ma_device::playback"] ++ [::core::mem::offset_of!(ma_device, playback) - 592usize]; ++ ["Offset of field: ma_device::capture"] ++ [::core::mem::offset_of!(ma_device, capture) - 2024usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_context_config_init() -> ma_context_config; ++} ++unsafe extern "C" { ++ pub fn ma_context_init( ++ backends: *const ma_backend, ++ backendCount: ma_uint32, ++ pConfig: *const ma_context_config, ++ pContext: *mut ma_context, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_uninit(pContext: *mut ma_context) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_sizeof() -> usize; ++} ++unsafe extern "C" { ++ pub fn ma_context_get_log(pContext: *mut ma_context) -> *mut ma_log; ++} ++unsafe extern "C" { ++ pub fn ma_context_enumerate_devices( ++ pContext: *mut ma_context, ++ callback: ma_enum_devices_callback_proc, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_get_devices( ++ pContext: *mut ma_context, ++ ppPlaybackDeviceInfos: *mut *mut ma_device_info, ++ pPlaybackDeviceCount: *mut ma_uint32, ++ ppCaptureDeviceInfos: *mut *mut ma_device_info, ++ pCaptureDeviceCount: *mut ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_get_device_info( ++ pContext: *mut ma_context, ++ deviceType: ma_device_type, ++ pDeviceID: *const ma_device_id, ++ pDeviceInfo: *mut ma_device_info, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_context_is_loopback_supported(pContext: *mut ma_context) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_device_config_init(deviceType: ma_device_type) -> ma_device_config; ++} ++unsafe extern "C" { ++ pub fn ma_device_init( ++ pContext: *mut ma_context, ++ pConfig: *const ma_device_config, ++ pDevice: *mut ma_device, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_init_ex( ++ backends: *const ma_backend, ++ backendCount: ma_uint32, ++ pContextConfig: *const ma_context_config, ++ pConfig: *const ma_device_config, ++ pDevice: *mut ma_device, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_uninit(pDevice: *mut ma_device); ++} ++unsafe extern "C" { ++ pub fn ma_device_get_context(pDevice: *mut ma_device) -> *mut ma_context; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_log(pDevice: *mut ma_device) -> *mut ma_log; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_info( ++ pDevice: *mut ma_device, ++ type_: ma_device_type, ++ pDeviceInfo: *mut ma_device_info, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_name( ++ pDevice: *mut ma_device, ++ type_: ma_device_type, ++ pName: *mut core::ffi::c_char, ++ nameCap: usize, ++ pLengthNotIncludingNullTerminator: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_start(pDevice: *mut ma_device) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_stop(pDevice: *mut ma_device) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_is_started(pDevice: *const ma_device) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_state(pDevice: *const ma_device) -> ma_device_state; ++} ++unsafe extern "C" { ++ pub fn ma_device_post_init( ++ pDevice: *mut ma_device, ++ deviceType: ma_device_type, ++ pPlaybackDescriptor: *const ma_device_descriptor, ++ pCaptureDescriptor: *const ma_device_descriptor, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_set_master_volume(pDevice: *mut ma_device, volume: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_master_volume(pDevice: *mut ma_device, pVolume: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_set_master_volume_db(pDevice: *mut ma_device, gainDB: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_get_master_volume_db(pDevice: *mut ma_device, pGainDB: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_device_handle_backend_data_callback( ++ pDevice: *mut ma_device, ++ pOutput: *mut core::ffi::c_void, ++ pInput: *const core::ffi::c_void, ++ frameCount: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_calculate_buffer_size_in_frames_from_descriptor( ++ pDescriptor: *const ma_device_descriptor, ++ nativeSampleRate: ma_uint32, ++ performanceProfile: ma_performance_profile, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_get_backend_name(backend: ma_backend) -> *const core::ffi::c_char; ++} ++unsafe extern "C" { ++ pub fn ma_get_backend_from_name( ++ pBackendName: *const core::ffi::c_char, ++ pBackend: *mut ma_backend, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_is_backend_enabled(backend: ma_backend) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_get_enabled_backends( ++ pBackends: *mut ma_backend, ++ backendCap: usize, ++ pBackendCount: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_is_loopback_supported(backend: ma_backend) -> ma_bool32; ++} ++unsafe extern "C" { ++ #[doc = "Utilities"] ++ pub fn ma_calculate_buffer_size_in_milliseconds_from_frames( ++ bufferSizeInFrames: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_calculate_buffer_size_in_frames_from_milliseconds( ++ bufferSizeInMilliseconds: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_copy_pcm_frames( ++ dst: *mut core::ffi::c_void, ++ src: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_silence_pcm_frames( ++ p: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_offset_pcm_frames_ptr( ++ p: *mut core::ffi::c_void, ++ offsetInFrames: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ) -> *mut core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_offset_pcm_frames_const_ptr( ++ p: *const core::ffi::c_void, ++ offsetInFrames: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ) -> *const core::ffi::c_void; ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_u8(pDst: *mut ma_uint8, pSrc: *const ma_int16, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_s16(pDst: *mut ma_int16, pSrc: *const ma_int32, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_s24(pDst: *mut ma_uint8, pSrc: *const ma_int64, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_s32(pDst: *mut ma_int32, pSrc: *const ma_int64, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_samples_f32(pDst: *mut f32, pSrc: *const f32, count: ma_uint64); ++} ++unsafe extern "C" { ++ pub fn ma_clip_pcm_frames( ++ pDst: *mut core::ffi::c_void, ++ pSrc: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_u8( ++ pSamplesOut: *mut ma_uint8, ++ pSamplesIn: *const ma_uint8, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_s16( ++ pSamplesOut: *mut ma_int16, ++ pSamplesIn: *const ma_int16, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_s24( ++ pSamplesOut: *mut core::ffi::c_void, ++ pSamplesIn: *const core::ffi::c_void, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_s32( ++ pSamplesOut: *mut ma_int32, ++ pSamplesIn: *const ma_int32, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_f32( ++ pSamplesOut: *mut f32, ++ pSamplesIn: *const f32, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_u8(pSamples: *mut ma_uint8, sampleCount: ma_uint64, factor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_s16(pSamples: *mut ma_int16, sampleCount: ma_uint64, factor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_s24( ++ pSamples: *mut core::ffi::c_void, ++ sampleCount: ma_uint64, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_s32(pSamples: *mut ma_int32, sampleCount: ma_uint64, factor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_f32(pSamples: *mut f32, sampleCount: ma_uint64, factor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_u8( ++ pFramesOut: *mut ma_uint8, ++ pFramesIn: *const ma_uint8, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_s16( ++ pFramesOut: *mut ma_int16, ++ pFramesIn: *const ma_int16, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_s24( ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_s32( ++ pFramesOut: *mut ma_int32, ++ pFramesIn: *const ma_int32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames_f32( ++ pFramesOut: *mut f32, ++ pFramesIn: *const f32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_pcm_frames( ++ pFramesOut: *mut core::ffi::c_void, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_u8( ++ pFrames: *mut ma_uint8, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_s16( ++ pFrames: *mut ma_int16, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_s24( ++ pFrames: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_s32( ++ pFrames: *mut ma_int32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames_f32( ++ pFrames: *mut f32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_apply_volume_factor_pcm_frames( ++ pFrames: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ factor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_factor_per_channel_f32( ++ pFramesOut: *mut f32, ++ pFramesIn: *const f32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ pChannelGains: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_u8( ++ pDst: *mut ma_uint8, ++ pSrc: *const ma_int16, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_s16( ++ pDst: *mut ma_int16, ++ pSrc: *const ma_int32, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_s24( ++ pDst: *mut ma_uint8, ++ pSrc: *const ma_int64, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_s32( ++ pDst: *mut ma_int32, ++ pSrc: *const ma_int64, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_samples_f32( ++ pDst: *mut f32, ++ pSrc: *const f32, ++ count: ma_uint64, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_copy_and_apply_volume_and_clip_pcm_frames( ++ pDst: *mut core::ffi::c_void, ++ pSrc: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ volume: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_volume_linear_to_db(factor: f32) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_volume_db_to_linear(gain: f32) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_mix_pcm_frames_f32( ++ pDst: *mut f32, ++ pSrc: *const f32, ++ frameCount: ma_uint64, ++ channels: ma_uint32, ++ volume: f32, ++ ) -> ma_result; ++} ++#[doc = "VFS\n===\n\nThe VFS object (virtual file system) is what's used to customize file access. This is useful in cases where stdio FILE* based APIs may not be entirely\nappropriate for a given situation."] ++pub type ma_vfs = core::ffi::c_void; ++pub type ma_vfs_file = ma_handle; ++pub const ma_open_mode_flags_MA_OPEN_MODE_READ: ma_open_mode_flags = 1; ++pub const ma_open_mode_flags_MA_OPEN_MODE_WRITE: ma_open_mode_flags = 2; ++pub type ma_open_mode_flags = core::ffi::c_uint; ++pub const ma_seek_origin_ma_seek_origin_start: ma_seek_origin = 0; ++pub const ma_seek_origin_ma_seek_origin_current: ma_seek_origin = 1; ++pub const ma_seek_origin_ma_seek_origin_end: ma_seek_origin = 2; ++pub type ma_seek_origin = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_file_info { ++ pub sizeInBytes: ma_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_file_info"][::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_file_info"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_file_info::sizeInBytes"] ++ [::core::mem::offset_of!(ma_file_info, sizeInBytes) - 0usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_vfs_callbacks { ++ pub onOpen: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ openMode: ma_uint32, ++ pFile: *mut ma_vfs_file, ++ ) -> ma_result, ++ >, ++ pub onOpenW: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const wchar_t, ++ openMode: ma_uint32, ++ pFile: *mut ma_vfs_file, ++ ) -> ma_result, ++ >, ++ pub onClose: ::core::option::Option< ++ unsafe extern "C" fn(pVFS: *mut ma_vfs, file: ma_vfs_file) -> ma_result, ++ >, ++ pub onRead: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pDst: *mut core::ffi::c_void, ++ sizeInBytes: usize, ++ pBytesRead: *mut usize, ++ ) -> ma_result, ++ >, ++ pub onWrite: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pSrc: *const core::ffi::c_void, ++ sizeInBytes: usize, ++ pBytesWritten: *mut usize, ++ ) -> ma_result, ++ >, ++ pub onSeek: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ offset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result, ++ >, ++ pub onTell: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pCursor: *mut ma_int64, ++ ) -> ma_result, ++ >, ++ pub onInfo: ::core::option::Option< ++ unsafe extern "C" fn( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pInfo: *mut ma_file_info, ++ ) -> ma_result, ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_vfs_callbacks"][::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_vfs_callbacks"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_vfs_callbacks::onOpen"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onOpen) - 0usize]; ++ ["Offset of field: ma_vfs_callbacks::onOpenW"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onOpenW) - 8usize]; ++ ["Offset of field: ma_vfs_callbacks::onClose"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onClose) - 16usize]; ++ ["Offset of field: ma_vfs_callbacks::onRead"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onRead) - 24usize]; ++ ["Offset of field: ma_vfs_callbacks::onWrite"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onWrite) - 32usize]; ++ ["Offset of field: ma_vfs_callbacks::onSeek"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onSeek) - 40usize]; ++ ["Offset of field: ma_vfs_callbacks::onTell"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onTell) - 48usize]; ++ ["Offset of field: ma_vfs_callbacks::onInfo"] ++ [::core::mem::offset_of!(ma_vfs_callbacks, onInfo) - 56usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_vfs_open( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ openMode: ma_uint32, ++ pFile: *mut ma_vfs_file, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_open_w( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const wchar_t, ++ openMode: ma_uint32, ++ pFile: *mut ma_vfs_file, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_close(pVFS: *mut ma_vfs, file: ma_vfs_file) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_read( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pDst: *mut core::ffi::c_void, ++ sizeInBytes: usize, ++ pBytesRead: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_write( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ pSrc: *const core::ffi::c_void, ++ sizeInBytes: usize, ++ pBytesWritten: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_seek( ++ pVFS: *mut ma_vfs, ++ file: ma_vfs_file, ++ offset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_tell(pVFS: *mut ma_vfs, file: ma_vfs_file, pCursor: *mut ma_int64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_info(pVFS: *mut ma_vfs, file: ma_vfs_file, pInfo: *mut ma_file_info) ++ -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_vfs_open_and_read_file( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ ppData: *mut *mut core::ffi::c_void, ++ pSize: *mut usize, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_default_vfs { ++ pub cb: ma_vfs_callbacks, ++ pub allocationCallbacks: ma_allocation_callbacks, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_default_vfs"][::core::mem::size_of::() - 96usize]; ++ ["Alignment of ma_default_vfs"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_default_vfs::cb"][::core::mem::offset_of!(ma_default_vfs, cb) - 0usize]; ++ ["Offset of field: ma_default_vfs::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_default_vfs, allocationCallbacks) - 64usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_default_vfs_init( ++ pVFS: *mut ma_default_vfs, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ) -> ma_result; ++} ++pub type ma_read_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBufferOut: *mut core::ffi::c_void, ++ bytesToRead: usize, ++ pBytesRead: *mut usize, ++ ) -> ma_result, ++>; ++pub type ma_seek_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ offset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result, ++>; ++pub type ma_tell_proc = ::core::option::Option< ++ unsafe extern "C" fn(pUserData: *mut core::ffi::c_void, pCursor: *mut ma_int64) -> ma_result, ++>; ++pub const ma_encoding_format_ma_encoding_format_unknown: ma_encoding_format = 0; ++pub const ma_encoding_format_ma_encoding_format_wav: ma_encoding_format = 1; ++pub const ma_encoding_format_ma_encoding_format_flac: ma_encoding_format = 2; ++pub const ma_encoding_format_ma_encoding_format_mp3: ma_encoding_format = 3; ++pub const ma_encoding_format_ma_encoding_format_vorbis: ma_encoding_format = 4; ++pub type ma_encoding_format = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoding_backend_config { ++ pub preferredFormat: ma_format, ++ pub seekPointCount: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoding_backend_config"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_decoding_backend_config"] ++ [::core::mem::align_of::() - 4usize]; ++ ["Offset of field: ma_decoding_backend_config::preferredFormat"] ++ [::core::mem::offset_of!(ma_decoding_backend_config, preferredFormat) - 0usize]; ++ ["Offset of field: ma_decoding_backend_config::seekPointCount"] ++ [::core::mem::offset_of!(ma_decoding_backend_config, seekPointCount) - 4usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_decoding_backend_config_init( ++ preferredFormat: ma_format, ++ seekPointCount: ma_uint32, ++ ) -> ma_decoding_backend_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoding_backend_vtable { ++ pub onInit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ onRead: ma_read_proc, ++ onSeek: ma_seek_proc, ++ onTell: ma_tell_proc, ++ pReadSeekTellUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_decoding_backend_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppBackend: *mut *mut ma_data_source, ++ ) -> ma_result, ++ >, ++ pub onInitFile: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_decoding_backend_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppBackend: *mut *mut ma_data_source, ++ ) -> ma_result, ++ >, ++ pub onInitFileW: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_decoding_backend_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppBackend: *mut *mut ma_data_source, ++ ) -> ma_result, ++ >, ++ pub onInitMemory: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pData: *const core::ffi::c_void, ++ dataSize: usize, ++ pConfig: *const ma_decoding_backend_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ppBackend: *mut *mut ma_data_source, ++ ) -> ma_result, ++ >, ++ pub onUninit: ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pBackend: *mut ma_data_source, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ), ++ >, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoding_backend_vtable"] ++ [::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_decoding_backend_vtable"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onInit"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onInit) - 0usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onInitFile"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onInitFile) - 8usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onInitFileW"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onInitFileW) - 16usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onInitMemory"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onInitMemory) - 24usize]; ++ ["Offset of field: ma_decoding_backend_vtable::onUninit"] ++ [::core::mem::offset_of!(ma_decoding_backend_vtable, onUninit) - 32usize]; ++}; ++pub type ma_decoder_read_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pDecoder: *mut ma_decoder, ++ pBufferOut: *mut core::ffi::c_void, ++ bytesToRead: usize, ++ pBytesRead: *mut usize, ++ ) -> ma_result, ++>; ++pub type ma_decoder_seek_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pDecoder: *mut ma_decoder, ++ byteOffset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result, ++>; ++pub type ma_decoder_tell_proc = ::core::option::Option< ++ unsafe extern "C" fn(pDecoder: *mut ma_decoder, pCursor: *mut ma_int64) -> ma_result, ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoder_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub pChannelMap: *mut ma_channel, ++ pub channelMixMode: ma_channel_mix_mode, ++ pub ditherMode: ma_dither_mode, ++ pub resampling: ma_resampler_config, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub encodingFormat: ma_encoding_format, ++ pub seekPointCount: ma_uint32, ++ pub ppCustomBackendVTables: *mut *mut ma_decoding_backend_vtable, ++ pub customBackendCount: ma_uint32, ++ pub pCustomBackendUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder_config"][::core::mem::size_of::() - 144usize]; ++ ["Alignment of ma_decoder_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder_config::format"] ++ [::core::mem::offset_of!(ma_decoder_config, format) - 0usize]; ++ ["Offset of field: ma_decoder_config::channels"] ++ [::core::mem::offset_of!(ma_decoder_config, channels) - 4usize]; ++ ["Offset of field: ma_decoder_config::sampleRate"] ++ [::core::mem::offset_of!(ma_decoder_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_decoder_config::pChannelMap"] ++ [::core::mem::offset_of!(ma_decoder_config, pChannelMap) - 16usize]; ++ ["Offset of field: ma_decoder_config::channelMixMode"] ++ [::core::mem::offset_of!(ma_decoder_config, channelMixMode) - 24usize]; ++ ["Offset of field: ma_decoder_config::ditherMode"] ++ [::core::mem::offset_of!(ma_decoder_config, ditherMode) - 28usize]; ++ ["Offset of field: ma_decoder_config::resampling"] ++ [::core::mem::offset_of!(ma_decoder_config, resampling) - 32usize]; ++ ["Offset of field: ma_decoder_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_decoder_config, allocationCallbacks) - 80usize]; ++ ["Offset of field: ma_decoder_config::encodingFormat"] ++ [::core::mem::offset_of!(ma_decoder_config, encodingFormat) - 112usize]; ++ ["Offset of field: ma_decoder_config::seekPointCount"] ++ [::core::mem::offset_of!(ma_decoder_config, seekPointCount) - 116usize]; ++ ["Offset of field: ma_decoder_config::ppCustomBackendVTables"] ++ [::core::mem::offset_of!(ma_decoder_config, ppCustomBackendVTables) - 120usize]; ++ ["Offset of field: ma_decoder_config::customBackendCount"] ++ [::core::mem::offset_of!(ma_decoder_config, customBackendCount) - 128usize]; ++ ["Offset of field: ma_decoder_config::pCustomBackendUserData"] ++ [::core::mem::offset_of!(ma_decoder_config, pCustomBackendUserData) - 136usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_decoder { ++ pub ds: ma_data_source_base, ++ pub pBackend: *mut ma_data_source, ++ pub pBackendVTable: *const ma_decoding_backend_vtable, ++ pub pBackendUserData: *mut core::ffi::c_void, ++ pub onRead: ma_decoder_read_proc, ++ pub onSeek: ma_decoder_seek_proc, ++ pub onTell: ma_decoder_tell_proc, ++ pub pUserData: *mut core::ffi::c_void, ++ pub readPointerInPCMFrames: ma_uint64, ++ pub outputFormat: ma_format, ++ pub outputChannels: ma_uint32, ++ pub outputSampleRate: ma_uint32, ++ pub converter: ma_data_converter, ++ pub pInputCache: *mut core::ffi::c_void, ++ pub inputCacheCap: ma_uint64, ++ pub inputCacheConsumed: ma_uint64, ++ pub inputCacheRemaining: ma_uint64, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub data: ma_decoder__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_decoder__bindgen_ty_1 { ++ pub vfs: ma_decoder__bindgen_ty_1__bindgen_ty_1, ++ pub memory: ma_decoder__bindgen_ty_1__bindgen_ty_2, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoder__bindgen_ty_1__bindgen_ty_1 { ++ pub pVFS: *mut ma_vfs, ++ pub file: ma_vfs_file, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_decoder__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_1::pVFS"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_1, pVFS) - 0usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_1::file"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_1, file) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_decoder__bindgen_ty_1__bindgen_ty_2 { ++ pub pData: *const ma_uint8, ++ pub dataSize: usize, ++ pub currentReadPos: usize, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_decoder__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_2::pData"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_2, pData) - 0usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_2::dataSize"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_2, dataSize) - 8usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1__bindgen_ty_2::currentReadPos"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1__bindgen_ty_2, currentReadPos) - 16usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder__bindgen_ty_1"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_decoder__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1::vfs"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1, vfs) - 0usize]; ++ ["Offset of field: ma_decoder__bindgen_ty_1::memory"] ++ [::core::mem::offset_of!(ma_decoder__bindgen_ty_1, memory) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_decoder"][::core::mem::size_of::() - 552usize]; ++ ["Alignment of ma_decoder"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_decoder::ds"][::core::mem::offset_of!(ma_decoder, ds) - 0usize]; ++ ["Offset of field: ma_decoder::pBackend"] ++ [::core::mem::offset_of!(ma_decoder, pBackend) - 72usize]; ++ ["Offset of field: ma_decoder::pBackendVTable"] ++ [::core::mem::offset_of!(ma_decoder, pBackendVTable) - 80usize]; ++ ["Offset of field: ma_decoder::pBackendUserData"] ++ [::core::mem::offset_of!(ma_decoder, pBackendUserData) - 88usize]; ++ ["Offset of field: ma_decoder::onRead"][::core::mem::offset_of!(ma_decoder, onRead) - 96usize]; ++ ["Offset of field: ma_decoder::onSeek"][::core::mem::offset_of!(ma_decoder, onSeek) - 104usize]; ++ ["Offset of field: ma_decoder::onTell"][::core::mem::offset_of!(ma_decoder, onTell) - 112usize]; ++ ["Offset of field: ma_decoder::pUserData"] ++ [::core::mem::offset_of!(ma_decoder, pUserData) - 120usize]; ++ ["Offset of field: ma_decoder::readPointerInPCMFrames"] ++ [::core::mem::offset_of!(ma_decoder, readPointerInPCMFrames) - 128usize]; ++ ["Offset of field: ma_decoder::outputFormat"] ++ [::core::mem::offset_of!(ma_decoder, outputFormat) - 136usize]; ++ ["Offset of field: ma_decoder::outputChannels"] ++ [::core::mem::offset_of!(ma_decoder, outputChannels) - 140usize]; ++ ["Offset of field: ma_decoder::outputSampleRate"] ++ [::core::mem::offset_of!(ma_decoder, outputSampleRate) - 144usize]; ++ ["Offset of field: ma_decoder::converter"] ++ [::core::mem::offset_of!(ma_decoder, converter) - 152usize]; ++ ["Offset of field: ma_decoder::pInputCache"] ++ [::core::mem::offset_of!(ma_decoder, pInputCache) - 464usize]; ++ ["Offset of field: ma_decoder::inputCacheCap"] ++ [::core::mem::offset_of!(ma_decoder, inputCacheCap) - 472usize]; ++ ["Offset of field: ma_decoder::inputCacheConsumed"] ++ [::core::mem::offset_of!(ma_decoder, inputCacheConsumed) - 480usize]; ++ ["Offset of field: ma_decoder::inputCacheRemaining"] ++ [::core::mem::offset_of!(ma_decoder, inputCacheRemaining) - 488usize]; ++ ["Offset of field: ma_decoder::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_decoder, allocationCallbacks) - 496usize]; ++ ["Offset of field: ma_decoder::data"][::core::mem::offset_of!(ma_decoder, data) - 528usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_decoder_config_init( ++ outputFormat: ma_format, ++ outputChannels: ma_uint32, ++ outputSampleRate: ma_uint32, ++ ) -> ma_decoder_config; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_config_init_default() -> ma_decoder_config; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init( ++ onRead: ma_decoder_read_proc, ++ onSeek: ma_decoder_seek_proc, ++ pUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_memory( ++ pData: *const core::ffi::c_void, ++ dataSize: usize, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_vfs( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_vfs_w( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_file( ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_init_file_w( ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_decoder_config, ++ pDecoder: *mut ma_decoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_uninit(pDecoder: *mut ma_decoder) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_read_pcm_frames( ++ pDecoder: *mut ma_decoder, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_seek_to_pcm_frame( ++ pDecoder: *mut ma_decoder, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_get_data_format( ++ pDecoder: *mut ma_decoder, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_get_cursor_in_pcm_frames( ++ pDecoder: *mut ma_decoder, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_get_length_in_pcm_frames( ++ pDecoder: *mut ma_decoder, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decoder_get_available_frames( ++ pDecoder: *mut ma_decoder, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decode_from_vfs( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *mut ma_decoder_config, ++ pFrameCountOut: *mut ma_uint64, ++ ppPCMFramesOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decode_file( ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *mut ma_decoder_config, ++ pFrameCountOut: *mut ma_uint64, ++ ppPCMFramesOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_decode_memory( ++ pData: *const core::ffi::c_void, ++ dataSize: usize, ++ pConfig: *mut ma_decoder_config, ++ pFrameCountOut: *mut ma_uint64, ++ ppPCMFramesOut: *mut *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++pub type ma_encoder_write_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pEncoder: *mut ma_encoder, ++ pBufferIn: *const core::ffi::c_void, ++ bytesToWrite: usize, ++ pBytesWritten: *mut usize, ++ ) -> ma_result, ++>; ++pub type ma_encoder_seek_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pEncoder: *mut ma_encoder, ++ offset: ma_int64, ++ origin: ma_seek_origin, ++ ) -> ma_result, ++>; ++pub type ma_encoder_init_proc = ++ ::core::option::Option ma_result>; ++pub type ma_encoder_uninit_proc = ++ ::core::option::Option; ++pub type ma_encoder_write_pcm_frames_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pEncoder: *mut ma_encoder, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesWritten: *mut ma_uint64, ++ ) -> ma_result, ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_encoder_config { ++ pub encodingFormat: ma_encoding_format, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub allocationCallbacks: ma_allocation_callbacks, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_encoder_config"][::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_encoder_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_encoder_config::encodingFormat"] ++ [::core::mem::offset_of!(ma_encoder_config, encodingFormat) - 0usize]; ++ ["Offset of field: ma_encoder_config::format"] ++ [::core::mem::offset_of!(ma_encoder_config, format) - 4usize]; ++ ["Offset of field: ma_encoder_config::channels"] ++ [::core::mem::offset_of!(ma_encoder_config, channels) - 8usize]; ++ ["Offset of field: ma_encoder_config::sampleRate"] ++ [::core::mem::offset_of!(ma_encoder_config, sampleRate) - 12usize]; ++ ["Offset of field: ma_encoder_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_encoder_config, allocationCallbacks) - 16usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_encoder_config_init( ++ encodingFormat: ma_encoding_format, ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_encoder_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_encoder { ++ pub config: ma_encoder_config, ++ pub onWrite: ma_encoder_write_proc, ++ pub onSeek: ma_encoder_seek_proc, ++ pub onInit: ma_encoder_init_proc, ++ pub onUninit: ma_encoder_uninit_proc, ++ pub onWritePCMFrames: ma_encoder_write_pcm_frames_proc, ++ pub pUserData: *mut core::ffi::c_void, ++ pub pInternalEncoder: *mut core::ffi::c_void, ++ pub data: ma_encoder__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_encoder__bindgen_ty_1 { ++ pub vfs: ma_encoder__bindgen_ty_1__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_encoder__bindgen_ty_1__bindgen_ty_1 { ++ pub pVFS: *mut ma_vfs, ++ pub file: ma_vfs_file, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_encoder__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_encoder__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_encoder__bindgen_ty_1__bindgen_ty_1::pVFS"] ++ [::core::mem::offset_of!(ma_encoder__bindgen_ty_1__bindgen_ty_1, pVFS) - 0usize]; ++ ["Offset of field: ma_encoder__bindgen_ty_1__bindgen_ty_1::file"] ++ [::core::mem::offset_of!(ma_encoder__bindgen_ty_1__bindgen_ty_1, file) - 8usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_encoder__bindgen_ty_1"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_encoder__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_encoder__bindgen_ty_1::vfs"] ++ [::core::mem::offset_of!(ma_encoder__bindgen_ty_1, vfs) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_encoder"][::core::mem::size_of::() - 120usize]; ++ ["Alignment of ma_encoder"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_encoder::config"][::core::mem::offset_of!(ma_encoder, config) - 0usize]; ++ ["Offset of field: ma_encoder::onWrite"] ++ [::core::mem::offset_of!(ma_encoder, onWrite) - 48usize]; ++ ["Offset of field: ma_encoder::onSeek"][::core::mem::offset_of!(ma_encoder, onSeek) - 56usize]; ++ ["Offset of field: ma_encoder::onInit"][::core::mem::offset_of!(ma_encoder, onInit) - 64usize]; ++ ["Offset of field: ma_encoder::onUninit"] ++ [::core::mem::offset_of!(ma_encoder, onUninit) - 72usize]; ++ ["Offset of field: ma_encoder::onWritePCMFrames"] ++ [::core::mem::offset_of!(ma_encoder, onWritePCMFrames) - 80usize]; ++ ["Offset of field: ma_encoder::pUserData"] ++ [::core::mem::offset_of!(ma_encoder, pUserData) - 88usize]; ++ ["Offset of field: ma_encoder::pInternalEncoder"] ++ [::core::mem::offset_of!(ma_encoder, pInternalEncoder) - 96usize]; ++ ["Offset of field: ma_encoder::data"][::core::mem::offset_of!(ma_encoder, data) - 104usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_encoder_init( ++ onWrite: ma_encoder_write_proc, ++ onSeek: ma_encoder_seek_proc, ++ pUserData: *mut core::ffi::c_void, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_init_vfs( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_init_vfs_w( ++ pVFS: *mut ma_vfs, ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_init_file( ++ pFilePath: *const core::ffi::c_char, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_init_file_w( ++ pFilePath: *const wchar_t, ++ pConfig: *const ma_encoder_config, ++ pEncoder: *mut ma_encoder, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_encoder_uninit(pEncoder: *mut ma_encoder); ++} ++unsafe extern "C" { ++ pub fn ma_encoder_write_pcm_frames( ++ pEncoder: *mut ma_encoder, ++ pFramesIn: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesWritten: *mut ma_uint64, ++ ) -> ma_result; ++} ++pub const ma_waveform_type_ma_waveform_type_sine: ma_waveform_type = 0; ++pub const ma_waveform_type_ma_waveform_type_square: ma_waveform_type = 1; ++pub const ma_waveform_type_ma_waveform_type_triangle: ma_waveform_type = 2; ++pub const ma_waveform_type_ma_waveform_type_sawtooth: ma_waveform_type = 3; ++pub type ma_waveform_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_waveform_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub type_: ma_waveform_type, ++ pub amplitude: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_waveform_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_waveform_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_waveform_config::format"] ++ [::core::mem::offset_of!(ma_waveform_config, format) - 0usize]; ++ ["Offset of field: ma_waveform_config::channels"] ++ [::core::mem::offset_of!(ma_waveform_config, channels) - 4usize]; ++ ["Offset of field: ma_waveform_config::sampleRate"] ++ [::core::mem::offset_of!(ma_waveform_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_waveform_config::type_"] ++ [::core::mem::offset_of!(ma_waveform_config, type_) - 12usize]; ++ ["Offset of field: ma_waveform_config::amplitude"] ++ [::core::mem::offset_of!(ma_waveform_config, amplitude) - 16usize]; ++ ["Offset of field: ma_waveform_config::frequency"] ++ [::core::mem::offset_of!(ma_waveform_config, frequency) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_waveform_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ type_: ma_waveform_type, ++ amplitude: f64, ++ frequency: f64, ++ ) -> ma_waveform_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_waveform { ++ pub ds: ma_data_source_base, ++ pub config: ma_waveform_config, ++ pub advance: f64, ++ pub time: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_waveform"][::core::mem::size_of::() - 120usize]; ++ ["Alignment of ma_waveform"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_waveform::ds"][::core::mem::offset_of!(ma_waveform, ds) - 0usize]; ++ ["Offset of field: ma_waveform::config"] ++ [::core::mem::offset_of!(ma_waveform, config) - 72usize]; ++ ["Offset of field: ma_waveform::advance"] ++ [::core::mem::offset_of!(ma_waveform, advance) - 104usize]; ++ ["Offset of field: ma_waveform::time"][::core::mem::offset_of!(ma_waveform, time) - 112usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_waveform_init( ++ pConfig: *const ma_waveform_config, ++ pWaveform: *mut ma_waveform, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_uninit(pWaveform: *mut ma_waveform); ++} ++unsafe extern "C" { ++ pub fn ma_waveform_read_pcm_frames( ++ pWaveform: *mut ma_waveform, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_seek_to_pcm_frame( ++ pWaveform: *mut ma_waveform, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_set_amplitude(pWaveform: *mut ma_waveform, amplitude: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_set_frequency(pWaveform: *mut ma_waveform, frequency: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_set_type(pWaveform: *mut ma_waveform, type_: ma_waveform_type) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_waveform_set_sample_rate( ++ pWaveform: *mut ma_waveform, ++ sampleRate: ma_uint32, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_pulsewave_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub dutyCycle: f64, ++ pub amplitude: f64, ++ pub frequency: f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_pulsewave_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_pulsewave_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_pulsewave_config::format"] ++ [::core::mem::offset_of!(ma_pulsewave_config, format) - 0usize]; ++ ["Offset of field: ma_pulsewave_config::channels"] ++ [::core::mem::offset_of!(ma_pulsewave_config, channels) - 4usize]; ++ ["Offset of field: ma_pulsewave_config::sampleRate"] ++ [::core::mem::offset_of!(ma_pulsewave_config, sampleRate) - 8usize]; ++ ["Offset of field: ma_pulsewave_config::dutyCycle"] ++ [::core::mem::offset_of!(ma_pulsewave_config, dutyCycle) - 16usize]; ++ ["Offset of field: ma_pulsewave_config::amplitude"] ++ [::core::mem::offset_of!(ma_pulsewave_config, amplitude) - 24usize]; ++ ["Offset of field: ma_pulsewave_config::frequency"] ++ [::core::mem::offset_of!(ma_pulsewave_config, frequency) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_pulsewave_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ dutyCycle: f64, ++ amplitude: f64, ++ frequency: f64, ++ ) -> ma_pulsewave_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_pulsewave { ++ pub waveform: ma_waveform, ++ pub config: ma_pulsewave_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_pulsewave"][::core::mem::size_of::() - 160usize]; ++ ["Alignment of ma_pulsewave"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_pulsewave::waveform"] ++ [::core::mem::offset_of!(ma_pulsewave, waveform) - 0usize]; ++ ["Offset of field: ma_pulsewave::config"] ++ [::core::mem::offset_of!(ma_pulsewave, config) - 120usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_pulsewave_init( ++ pConfig: *const ma_pulsewave_config, ++ pWaveform: *mut ma_pulsewave, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_uninit(pWaveform: *mut ma_pulsewave); ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_read_pcm_frames( ++ pWaveform: *mut ma_pulsewave, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_seek_to_pcm_frame( ++ pWaveform: *mut ma_pulsewave, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_set_amplitude(pWaveform: *mut ma_pulsewave, amplitude: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_set_frequency(pWaveform: *mut ma_pulsewave, frequency: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_set_sample_rate( ++ pWaveform: *mut ma_pulsewave, ++ sampleRate: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_pulsewave_set_duty_cycle(pWaveform: *mut ma_pulsewave, dutyCycle: f64) -> ma_result; ++} ++pub const ma_noise_type_ma_noise_type_white: ma_noise_type = 0; ++pub const ma_noise_type_ma_noise_type_pink: ma_noise_type = 1; ++pub const ma_noise_type_ma_noise_type_brownian: ma_noise_type = 2; ++pub type ma_noise_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_noise_config { ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub type_: ma_noise_type, ++ pub seed: ma_int32, ++ pub amplitude: f64, ++ pub duplicateChannels: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise_config"][::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_noise_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise_config::format"] ++ [::core::mem::offset_of!(ma_noise_config, format) - 0usize]; ++ ["Offset of field: ma_noise_config::channels"] ++ [::core::mem::offset_of!(ma_noise_config, channels) - 4usize]; ++ ["Offset of field: ma_noise_config::type_"] ++ [::core::mem::offset_of!(ma_noise_config, type_) - 8usize]; ++ ["Offset of field: ma_noise_config::seed"] ++ [::core::mem::offset_of!(ma_noise_config, seed) - 12usize]; ++ ["Offset of field: ma_noise_config::amplitude"] ++ [::core::mem::offset_of!(ma_noise_config, amplitude) - 16usize]; ++ ["Offset of field: ma_noise_config::duplicateChannels"] ++ [::core::mem::offset_of!(ma_noise_config, duplicateChannels) - 24usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_noise_config_init( ++ format: ma_format, ++ channels: ma_uint32, ++ type_: ma_noise_type, ++ seed: ma_int32, ++ amplitude: f64, ++ ) -> ma_noise_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_noise { ++ pub ds: ma_data_source_base, ++ pub config: ma_noise_config, ++ pub lcg: ma_lcg, ++ pub state: ma_noise__bindgen_ty_1, ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_noise__bindgen_ty_1 { ++ pub pink: ma_noise__bindgen_ty_1__bindgen_ty_1, ++ pub brownian: ma_noise__bindgen_ty_1__bindgen_ty_2, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_noise__bindgen_ty_1__bindgen_ty_1 { ++ pub bin: *mut *mut f64, ++ pub accumulation: *mut f64, ++ pub counter: *mut ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_noise__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1__bindgen_ty_1::bin"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1__bindgen_ty_1, bin) - 0usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1__bindgen_ty_1::accumulation"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1__bindgen_ty_1, accumulation) - 8usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1__bindgen_ty_1::counter"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1__bindgen_ty_1, counter) - 16usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_noise__bindgen_ty_1__bindgen_ty_2 { ++ pub accumulation: *mut f64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::size_of::() - 8usize]; ++ ["Alignment of ma_noise__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1__bindgen_ty_2::accumulation"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1__bindgen_ty_2, accumulation) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise__bindgen_ty_1"][::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_noise__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1::pink"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1, pink) - 0usize]; ++ ["Offset of field: ma_noise__bindgen_ty_1::brownian"] ++ [::core::mem::offset_of!(ma_noise__bindgen_ty_1, brownian) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_noise"][::core::mem::size_of::() - 152usize]; ++ ["Alignment of ma_noise"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_noise::ds"][::core::mem::offset_of!(ma_noise, ds) - 0usize]; ++ ["Offset of field: ma_noise::config"][::core::mem::offset_of!(ma_noise, config) - 72usize]; ++ ["Offset of field: ma_noise::lcg"][::core::mem::offset_of!(ma_noise, lcg) - 104usize]; ++ ["Offset of field: ma_noise::state"][::core::mem::offset_of!(ma_noise, state) - 112usize]; ++ ["Offset of field: ma_noise::_pHeap"][::core::mem::offset_of!(ma_noise, _pHeap) - 136usize]; ++ ["Offset of field: ma_noise::_ownsHeap"] ++ [::core::mem::offset_of!(ma_noise, _ownsHeap) - 144usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_noise_get_heap_size( ++ pConfig: *const ma_noise_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_init_preallocated( ++ pConfig: *const ma_noise_config, ++ pHeap: *mut core::ffi::c_void, ++ pNoise: *mut ma_noise, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_init( ++ pConfig: *const ma_noise_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNoise: *mut ma_noise, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_uninit( ++ pNoise: *mut ma_noise, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_noise_read_pcm_frames( ++ pNoise: *mut ma_noise, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_set_amplitude(pNoise: *mut ma_noise, amplitude: f64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_set_seed(pNoise: *mut ma_noise, seed: ma_int32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_noise_set_type(pNoise: *mut ma_noise, type_: ma_noise_type) -> ma_result; ++} ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM: ++ ma_resource_manager_data_source_flags = 1; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE: ++ ma_resource_manager_data_source_flags = 2; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC: ++ ma_resource_manager_data_source_flags = 4; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT: ++ ma_resource_manager_data_source_flags = 8; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH : ma_resource_manager_data_source_flags = 16 ; ++pub const ma_resource_manager_data_source_flags_MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_LOOPING: ++ ma_resource_manager_data_source_flags = 32; ++pub type ma_resource_manager_data_source_flags = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_pipeline_stage_notification { ++ pub pNotification: *mut ma_async_notification, ++ pub pFence: *mut ma_fence, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_pipeline_stage_notification"] ++ [::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_resource_manager_pipeline_stage_notification"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_pipeline_stage_notification::pNotification"][::core::mem::offset_of!( ++ ma_resource_manager_pipeline_stage_notification, ++ pNotification ++ ) - 0usize]; ++ ["Offset of field: ma_resource_manager_pipeline_stage_notification::pFence"] ++ [::core::mem::offset_of!(ma_resource_manager_pipeline_stage_notification, pFence) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_pipeline_notifications { ++ pub init: ma_resource_manager_pipeline_stage_notification, ++ pub done: ma_resource_manager_pipeline_stage_notification, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_pipeline_notifications"] ++ [::core::mem::size_of::() - 32usize]; ++ ["Alignment of ma_resource_manager_pipeline_notifications"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_pipeline_notifications::init"] ++ [::core::mem::offset_of!(ma_resource_manager_pipeline_notifications, init) - 0usize]; ++ ["Offset of field: ma_resource_manager_pipeline_notifications::done"] ++ [::core::mem::offset_of!(ma_resource_manager_pipeline_notifications, done) - 16usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resource_manager_pipeline_notifications_init() ++ -> ma_resource_manager_pipeline_notifications; ++} ++pub const ma_resource_manager_flags_MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING: ++ ma_resource_manager_flags = 1; ++pub const ma_resource_manager_flags_MA_RESOURCE_MANAGER_FLAG_NO_THREADING: ++ ma_resource_manager_flags = 2; ++pub type ma_resource_manager_flags = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_data_source_config { ++ pub pFilePath: *const core::ffi::c_char, ++ pub pFilePathW: *const wchar_t, ++ pub pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pub initialSeekPointInPCMFrames: ma_uint64, ++ pub rangeBegInPCMFrames: ma_uint64, ++ pub rangeEndInPCMFrames: ma_uint64, ++ pub loopPointBegInPCMFrames: ma_uint64, ++ pub loopPointEndInPCMFrames: ma_uint64, ++ pub flags: ma_uint32, ++ pub isLooping: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_source_config"] ++ [::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_resource_manager_data_source_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::pFilePath"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, pFilePath) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::pFilePathW"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, pFilePathW) - 8usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::pNotifications"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, pNotifications) - 16usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::initialSeekPointInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ initialSeekPointInPCMFrames ++ ) ++ - 24usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::rangeBegInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ rangeBegInPCMFrames ++ ) - 32usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::rangeEndInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ rangeEndInPCMFrames ++ ) - 40usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::loopPointBegInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ loopPointBegInPCMFrames ++ ) ++ - 48usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::loopPointEndInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_source_config, ++ loopPointEndInPCMFrames ++ ) ++ - 56usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, flags) - 64usize]; ++ ["Offset of field: ma_resource_manager_data_source_config::isLooping"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source_config, isLooping) - 68usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_config_init() -> ma_resource_manager_data_source_config; ++} ++pub const ma_resource_manager_data_supply_type_ma_resource_manager_data_supply_type_unknown: ++ ma_resource_manager_data_supply_type = 0; ++pub const ma_resource_manager_data_supply_type_ma_resource_manager_data_supply_type_encoded: ++ ma_resource_manager_data_supply_type = 1; ++pub const ma_resource_manager_data_supply_type_ma_resource_manager_data_supply_type_decoded: ++ ma_resource_manager_data_supply_type = 2; ++pub const ma_resource_manager_data_supply_type_ma_resource_manager_data_supply_type_decoded_paged : ma_resource_manager_data_supply_type = 3 ; ++pub type ma_resource_manager_data_supply_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_supply { ++ pub type_: ma_resource_manager_data_supply_type, ++ pub backend: ma_resource_manager_data_supply__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_resource_manager_data_supply__bindgen_ty_1 { ++ pub encoded: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1, ++ pub decoded: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ pub decodedPaged: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1 { ++ pub pData: *const core::ffi::c_void, ++ pub sizeInBytes: usize, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1"][::core::mem::size_of::< ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1, ++ >() - 16usize]; ++ ["Alignment of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1"] ++ [::core::mem::align_of::() ++ - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1::pData"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1, ++ pData ++ ) ++ - 0usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1::sizeInBytes"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_1, ++ sizeInBytes ++ ) ++ - 8usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2 { ++ pub pData: *const core::ffi::c_void, ++ pub totalFrameCount: ma_uint64, ++ pub decodedFrameCount: ma_uint64, ++ pub format: ma_format, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2"][::core::mem::size_of::< ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ >() - 40usize]; ++ ["Alignment of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2"] ++ [::core::mem::align_of::() ++ - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::pData"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ pData ++ ) ++ - 0usize]; ++ [ ++ "Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::totalFrameCount", ++ ][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ totalFrameCount ++ ) - 8usize]; ++ [ ++ "Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::decodedFrameCount", ++ ][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ decodedFrameCount ++ ) - 16usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::format"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ format ++ ) ++ - 24usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::channels"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ channels ++ ) ++ - 28usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2::sampleRate"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_2, ++ sampleRate ++ ) ++ - 32usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3 { ++ pub data: ma_paged_audio_buffer_data, ++ pub decodedFrameCount: ma_uint64, ++ pub sampleRate: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3"][::core::mem::size_of::< ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++ >() - 56usize]; ++ ["Alignment of ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3"] ++ [::core::mem::align_of::() ++ - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3::data"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++ data ++ ) ++ - 0usize]; ++ [ ++ "Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3::decodedFrameCount", ++ ][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++ decodedFrameCount ++ ) - 40usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3::sampleRate"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1__bindgen_ty_3, ++ sampleRate ++ ) ++ - 48usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply__bindgen_ty_1"] ++ [::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_resource_manager_data_supply__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1::encoded"] ++ [::core::mem::offset_of!(ma_resource_manager_data_supply__bindgen_ty_1, encoded) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1::decoded"] ++ [::core::mem::offset_of!(ma_resource_manager_data_supply__bindgen_ty_1, decoded) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_supply__bindgen_ty_1::decodedPaged"][::core::mem::offset_of!( ++ ma_resource_manager_data_supply__bindgen_ty_1, ++ decodedPaged ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_supply"] ++ [::core::mem::size_of::() - 64usize]; ++ ["Alignment of ma_resource_manager_data_supply"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_supply::type_"] ++ [::core::mem::offset_of!(ma_resource_manager_data_supply, type_) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_supply::backend"] ++ [::core::mem::offset_of!(ma_resource_manager_data_supply, backend) - 8usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_buffer_node { ++ pub hashedName32: ma_uint32, ++ pub refCount: ma_uint32, ++ pub result: ma_result, ++ pub executionCounter: ma_uint32, ++ pub executionPointer: ma_uint32, ++ pub isDataOwnedByResourceManager: ma_bool32, ++ pub data: ma_resource_manager_data_supply, ++ pub pParent: *mut ma_resource_manager_data_buffer_node, ++ pub pChildLo: *mut ma_resource_manager_data_buffer_node, ++ pub pChildHi: *mut ma_resource_manager_data_buffer_node, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_buffer_node"] ++ [::core::mem::size_of::() - 112usize]; ++ ["Alignment of ma_resource_manager_data_buffer_node"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::hashedName32"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, hashedName32) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::refCount"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, refCount) - 4usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::result"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, result) - 8usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::executionCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, executionCounter) - 12usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::executionPointer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, executionPointer) - 16usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::isDataOwnedByResourceManager"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer_node, ++ isDataOwnedByResourceManager ++ ) ++ - 20usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::data"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, data) - 24usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::pParent"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, pParent) - 88usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::pChildLo"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, pChildLo) - 96usize]; ++ ["Offset of field: ma_resource_manager_data_buffer_node::pChildHi"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer_node, pChildHi) - 104usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_buffer { ++ pub ds: ma_data_source_base, ++ pub pResourceManager: *mut ma_resource_manager, ++ pub pNode: *mut ma_resource_manager_data_buffer_node, ++ pub flags: ma_uint32, ++ pub executionCounter: ma_uint32, ++ pub executionPointer: ma_uint32, ++ pub seekTargetInPCMFrames: ma_uint64, ++ pub seekToCursorOnNextRead: ma_bool32, ++ pub result: ma_result, ++ pub isLooping: ma_bool32, ++ pub isConnectorInitialized: ma_atomic_bool32, ++ pub connector: ma_resource_manager_data_buffer__bindgen_ty_1, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_resource_manager_data_buffer__bindgen_ty_1 { ++ pub decoder: ma_decoder, ++ pub buffer: ma_audio_buffer, ++ pub pagedBuffer: ma_paged_audio_buffer, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_buffer__bindgen_ty_1"] ++ [::core::mem::size_of::() - 552usize]; ++ ["Alignment of ma_resource_manager_data_buffer__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_buffer__bindgen_ty_1::decoder"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer__bindgen_ty_1, decoder) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_buffer__bindgen_ty_1::buffer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer__bindgen_ty_1, buffer) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_buffer__bindgen_ty_1::pagedBuffer"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer__bindgen_ty_1, ++ pagedBuffer ++ ) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_buffer"] ++ [::core::mem::size_of::() - 680usize]; ++ ["Alignment of ma_resource_manager_data_buffer"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::ds"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, ds) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::pResourceManager"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, pResourceManager) - 72usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::pNode"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, pNode) - 80usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, flags) - 88usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::executionCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, executionCounter) - 92usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::executionPointer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, executionPointer) - 96usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::seekTargetInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer, ++ seekTargetInPCMFrames ++ ) - 104usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::seekToCursorOnNextRead"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer, ++ seekToCursorOnNextRead ++ ) - 112usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::result"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, result) - 116usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::isLooping"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, isLooping) - 120usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::isConnectorInitialized"][::core::mem::offset_of!( ++ ma_resource_manager_data_buffer, ++ isConnectorInitialized ++ ) - 124usize]; ++ ["Offset of field: ma_resource_manager_data_buffer::connector"] ++ [::core::mem::offset_of!(ma_resource_manager_data_buffer, connector) - 128usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_stream { ++ pub ds: ma_data_source_base, ++ pub pResourceManager: *mut ma_resource_manager, ++ pub flags: ma_uint32, ++ pub decoder: ma_decoder, ++ pub isDecoderInitialized: ma_bool32, ++ pub totalLengthInPCMFrames: ma_uint64, ++ pub relativeCursor: ma_uint32, ++ pub absoluteCursor: ma_uint64, ++ pub currentPageIndex: ma_uint32, ++ pub executionCounter: ma_uint32, ++ pub executionPointer: ma_uint32, ++ pub isLooping: ma_bool32, ++ pub pPageData: *mut core::ffi::c_void, ++ pub pageFrameCount: [ma_uint32; 2usize], ++ pub result: ma_result, ++ pub isDecoderAtEnd: ma_bool32, ++ pub isPageValid: [ma_bool32; 2usize], ++ pub seekCounter: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_stream"] ++ [::core::mem::size_of::() - 728usize]; ++ ["Alignment of ma_resource_manager_data_stream"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_stream::ds"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, ds) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_stream::pResourceManager"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, pResourceManager) - 72usize]; ++ ["Offset of field: ma_resource_manager_data_stream::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, flags) - 80usize]; ++ ["Offset of field: ma_resource_manager_data_stream::decoder"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, decoder) - 88usize]; ++ ["Offset of field: ma_resource_manager_data_stream::isDecoderInitialized"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, isDecoderInitialized) - 640usize]; ++ ["Offset of field: ma_resource_manager_data_stream::totalLengthInPCMFrames"][::core::mem::offset_of!( ++ ma_resource_manager_data_stream, ++ totalLengthInPCMFrames ++ ) - 648usize]; ++ ["Offset of field: ma_resource_manager_data_stream::relativeCursor"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, relativeCursor) - 656usize]; ++ ["Offset of field: ma_resource_manager_data_stream::absoluteCursor"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, absoluteCursor) - 664usize]; ++ ["Offset of field: ma_resource_manager_data_stream::currentPageIndex"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, currentPageIndex) - 672usize]; ++ ["Offset of field: ma_resource_manager_data_stream::executionCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, executionCounter) - 676usize]; ++ ["Offset of field: ma_resource_manager_data_stream::executionPointer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, executionPointer) - 680usize]; ++ ["Offset of field: ma_resource_manager_data_stream::isLooping"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, isLooping) - 684usize]; ++ ["Offset of field: ma_resource_manager_data_stream::pPageData"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, pPageData) - 688usize]; ++ ["Offset of field: ma_resource_manager_data_stream::pageFrameCount"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, pageFrameCount) - 696usize]; ++ ["Offset of field: ma_resource_manager_data_stream::result"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, result) - 704usize]; ++ ["Offset of field: ma_resource_manager_data_stream::isDecoderAtEnd"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, isDecoderAtEnd) - 708usize]; ++ ["Offset of field: ma_resource_manager_data_stream::isPageValid"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, isPageValid) - 712usize]; ++ ["Offset of field: ma_resource_manager_data_stream::seekCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_stream, seekCounter) - 720usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager_data_source { ++ pub backend: ma_resource_manager_data_source__bindgen_ty_1, ++ pub flags: ma_uint32, ++ pub executionCounter: ma_uint32, ++ pub executionPointer: ma_uint32, ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub union ma_resource_manager_data_source__bindgen_ty_1 { ++ pub buffer: ma_resource_manager_data_buffer, ++ pub stream: ma_resource_manager_data_stream, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_source__bindgen_ty_1"] ++ [::core::mem::size_of::() - 728usize]; ++ ["Alignment of ma_resource_manager_data_source__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_source__bindgen_ty_1::buffer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source__bindgen_ty_1, buffer) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_source__bindgen_ty_1::stream"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source__bindgen_ty_1, stream) - 0usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_data_source"] ++ [::core::mem::size_of::() - 744usize]; ++ ["Alignment of ma_resource_manager_data_source"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_data_source::backend"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source, backend) - 0usize]; ++ ["Offset of field: ma_resource_manager_data_source::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source, flags) - 728usize]; ++ ["Offset of field: ma_resource_manager_data_source::executionCounter"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source, executionCounter) - 732usize]; ++ ["Offset of field: ma_resource_manager_data_source::executionPointer"] ++ [::core::mem::offset_of!(ma_resource_manager_data_source, executionPointer) - 736usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_resource_manager_config { ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub pLog: *mut ma_log, ++ pub decodedFormat: ma_format, ++ pub decodedChannels: ma_uint32, ++ pub decodedSampleRate: ma_uint32, ++ pub jobThreadCount: ma_uint32, ++ pub jobThreadStackSize: usize, ++ pub jobQueueCapacity: ma_uint32, ++ pub flags: ma_uint32, ++ pub pVFS: *mut ma_vfs, ++ pub ppCustomDecodingBackendVTables: *mut *mut ma_decoding_backend_vtable, ++ pub customDecodingBackendCount: ma_uint32, ++ pub pCustomDecodingBackendUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager_config"] ++ [::core::mem::size_of::() - 104usize]; ++ ["Alignment of ma_resource_manager_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_resource_manager_config, allocationCallbacks) - 0usize]; ++ ["Offset of field: ma_resource_manager_config::pLog"] ++ [::core::mem::offset_of!(ma_resource_manager_config, pLog) - 32usize]; ++ ["Offset of field: ma_resource_manager_config::decodedFormat"] ++ [::core::mem::offset_of!(ma_resource_manager_config, decodedFormat) - 40usize]; ++ ["Offset of field: ma_resource_manager_config::decodedChannels"] ++ [::core::mem::offset_of!(ma_resource_manager_config, decodedChannels) - 44usize]; ++ ["Offset of field: ma_resource_manager_config::decodedSampleRate"] ++ [::core::mem::offset_of!(ma_resource_manager_config, decodedSampleRate) - 48usize]; ++ ["Offset of field: ma_resource_manager_config::jobThreadCount"] ++ [::core::mem::offset_of!(ma_resource_manager_config, jobThreadCount) - 52usize]; ++ ["Offset of field: ma_resource_manager_config::jobThreadStackSize"] ++ [::core::mem::offset_of!(ma_resource_manager_config, jobThreadStackSize) - 56usize]; ++ ["Offset of field: ma_resource_manager_config::jobQueueCapacity"] ++ [::core::mem::offset_of!(ma_resource_manager_config, jobQueueCapacity) - 64usize]; ++ ["Offset of field: ma_resource_manager_config::flags"] ++ [::core::mem::offset_of!(ma_resource_manager_config, flags) - 68usize]; ++ ["Offset of field: ma_resource_manager_config::pVFS"] ++ [::core::mem::offset_of!(ma_resource_manager_config, pVFS) - 72usize]; ++ ["Offset of field: ma_resource_manager_config::ppCustomDecodingBackendVTables"][::core::mem::offset_of!( ++ ma_resource_manager_config, ++ ppCustomDecodingBackendVTables ++ ) - 80usize]; ++ ["Offset of field: ma_resource_manager_config::customDecodingBackendCount"] ++ [::core::mem::offset_of!(ma_resource_manager_config, customDecodingBackendCount) - 88usize]; ++ ["Offset of field: ma_resource_manager_config::pCustomDecodingBackendUserData"][::core::mem::offset_of!( ++ ma_resource_manager_config, ++ pCustomDecodingBackendUserData ++ ) - 96usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resource_manager_config_init() -> ma_resource_manager_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_resource_manager { ++ pub config: ma_resource_manager_config, ++ pub pRootDataBufferNode: *mut ma_resource_manager_data_buffer_node, ++ pub dataBufferBSTLock: ma_mutex, ++ pub jobThreads: [ma_thread; 64usize], ++ pub jobQueue: ma_job_queue, ++ pub defaultVFS: ma_default_vfs, ++ pub log: ma_log, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_resource_manager"][::core::mem::size_of::() - 1096usize]; ++ ["Alignment of ma_resource_manager"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_resource_manager::config"] ++ [::core::mem::offset_of!(ma_resource_manager, config) - 0usize]; ++ ["Offset of field: ma_resource_manager::pRootDataBufferNode"] ++ [::core::mem::offset_of!(ma_resource_manager, pRootDataBufferNode) - 104usize]; ++ ["Offset of field: ma_resource_manager::dataBufferBSTLock"] ++ [::core::mem::offset_of!(ma_resource_manager, dataBufferBSTLock) - 112usize]; ++ ["Offset of field: ma_resource_manager::jobThreads"] ++ [::core::mem::offset_of!(ma_resource_manager, jobThreads) - 152usize]; ++ ["Offset of field: ma_resource_manager::jobQueue"] ++ [::core::mem::offset_of!(ma_resource_manager, jobQueue) - 664usize]; ++ ["Offset of field: ma_resource_manager::defaultVFS"] ++ [::core::mem::offset_of!(ma_resource_manager, defaultVFS) - 856usize]; ++ ["Offset of field: ma_resource_manager::log"] ++ [::core::mem::offset_of!(ma_resource_manager, log) - 952usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_resource_manager_init( ++ pConfig: *const ma_resource_manager_config, ++ pResourceManager: *mut ma_resource_manager, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_uninit(pResourceManager: *mut ma_resource_manager); ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_get_log(pResourceManager: *mut ma_resource_manager) -> *mut ma_log; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_file( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const core::ffi::c_char, ++ flags: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_file_w( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const wchar_t, ++ flags: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_decoded_data( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const core::ffi::c_char, ++ pData: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_decoded_data_w( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const wchar_t, ++ pData: *const core::ffi::c_void, ++ frameCount: ma_uint64, ++ format: ma_format, ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_encoded_data( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const core::ffi::c_char, ++ pData: *const core::ffi::c_void, ++ sizeInBytes: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_register_encoded_data_w( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const wchar_t, ++ pData: *const core::ffi::c_void, ++ sizeInBytes: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_unregister_file( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const core::ffi::c_char, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_unregister_file_w( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const wchar_t, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_unregister_data( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const core::ffi::c_char, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_unregister_data_w( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const wchar_t, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_init_ex( ++ pResourceManager: *mut ma_resource_manager, ++ pConfig: *const ma_resource_manager_data_source_config, ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_init( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const core::ffi::c_char, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_init_w( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const wchar_t, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_init_copy( ++ pResourceManager: *mut ma_resource_manager, ++ pExistingDataBuffer: *const ma_resource_manager_data_buffer, ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_uninit( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_read_pcm_frames( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_seek_to_pcm_frame( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_get_data_format( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_get_cursor_in_pcm_frames( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_get_length_in_pcm_frames( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_result( ++ pDataBuffer: *const ma_resource_manager_data_buffer, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_set_looping( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_is_looping( ++ pDataBuffer: *const ma_resource_manager_data_buffer, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_buffer_get_available_frames( ++ pDataBuffer: *mut ma_resource_manager_data_buffer, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_init_ex( ++ pResourceManager: *mut ma_resource_manager, ++ pConfig: *const ma_resource_manager_data_source_config, ++ pDataStream: *mut ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_init( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const core::ffi::c_char, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataStream: *mut ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_init_w( ++ pResourceManager: *mut ma_resource_manager, ++ pFilePath: *const wchar_t, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataStream: *mut ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_uninit( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_read_pcm_frames( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_seek_to_pcm_frame( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_get_data_format( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_get_cursor_in_pcm_frames( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_get_length_in_pcm_frames( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_result( ++ pDataStream: *const ma_resource_manager_data_stream, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_set_looping( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_is_looping( ++ pDataStream: *const ma_resource_manager_data_stream, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_stream_get_available_frames( ++ pDataStream: *mut ma_resource_manager_data_stream, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_init_ex( ++ pResourceManager: *mut ma_resource_manager, ++ pConfig: *const ma_resource_manager_data_source_config, ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_init( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const core::ffi::c_char, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_init_w( ++ pResourceManager: *mut ma_resource_manager, ++ pName: *const wchar_t, ++ flags: ma_uint32, ++ pNotifications: *const ma_resource_manager_pipeline_notifications, ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_init_copy( ++ pResourceManager: *mut ma_resource_manager, ++ pExistingDataSource: *const ma_resource_manager_data_source, ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_uninit( ++ pDataSource: *mut ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_read_pcm_frames( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_seek_to_pcm_frame( ++ pDataSource: *mut ma_resource_manager_data_source, ++ frameIndex: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_get_data_format( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_get_cursor_in_pcm_frames( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_get_length_in_pcm_frames( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_result( ++ pDataSource: *const ma_resource_manager_data_source, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_set_looping( ++ pDataSource: *mut ma_resource_manager_data_source, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_is_looping( ++ pDataSource: *const ma_resource_manager_data_source, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_data_source_get_available_frames( ++ pDataSource: *mut ma_resource_manager_data_source, ++ pAvailableFrames: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_post_job( ++ pResourceManager: *mut ma_resource_manager, ++ pJob: *const ma_job, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_post_job_quit( ++ pResourceManager: *mut ma_resource_manager, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_next_job( ++ pResourceManager: *mut ma_resource_manager, ++ pJob: *mut ma_job, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_process_job( ++ pResourceManager: *mut ma_resource_manager, ++ pJob: *mut ma_job, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_resource_manager_process_next_job( ++ pResourceManager: *mut ma_resource_manager, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_stack { ++ pub offset: usize, ++ pub sizeInBytes: usize, ++ pub _data: [core::ffi::c_uchar; 1usize], ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_stack"][::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_stack"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_stack::offset"][::core::mem::offset_of!(ma_stack, offset) - 0usize]; ++ ["Offset of field: ma_stack::sizeInBytes"] ++ [::core::mem::offset_of!(ma_stack, sizeInBytes) - 8usize]; ++ ["Offset of field: ma_stack::_data"][::core::mem::offset_of!(ma_stack, _data) - 16usize]; ++}; ++pub type ma_node = core::ffi::c_void; ++pub const ma_node_flags_MA_NODE_FLAG_PASSTHROUGH: ma_node_flags = 1; ++pub const ma_node_flags_MA_NODE_FLAG_CONTINUOUS_PROCESSING: ma_node_flags = 2; ++pub const ma_node_flags_MA_NODE_FLAG_ALLOW_NULL_INPUT: ma_node_flags = 4; ++pub const ma_node_flags_MA_NODE_FLAG_DIFFERENT_PROCESSING_RATES: ma_node_flags = 8; ++pub const ma_node_flags_MA_NODE_FLAG_SILENT_OUTPUT: ma_node_flags = 16; ++pub type ma_node_flags = core::ffi::c_uint; ++pub const ma_node_state_ma_node_state_started: ma_node_state = 0; ++pub const ma_node_state_ma_node_state_stopped: ma_node_state = 1; ++pub type ma_node_state = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_vtable { ++ pub onProcess: ::core::option::Option< ++ unsafe extern "C" fn( ++ pNode: *mut ma_node, ++ ppFramesIn: *mut *const f32, ++ pFrameCountIn: *mut ma_uint32, ++ ppFramesOut: *mut *mut f32, ++ pFrameCountOut: *mut ma_uint32, ++ ), ++ >, ++ pub onGetRequiredInputFrameCount: ::core::option::Option< ++ unsafe extern "C" fn( ++ pNode: *mut ma_node, ++ outputFrameCount: ma_uint32, ++ pInputFrameCount: *mut ma_uint32, ++ ) -> ma_result, ++ >, ++ pub inputBusCount: ma_uint8, ++ pub outputBusCount: ma_uint8, ++ pub flags: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_vtable"][::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_node_vtable"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_vtable::onProcess"] ++ [::core::mem::offset_of!(ma_node_vtable, onProcess) - 0usize]; ++ ["Offset of field: ma_node_vtable::onGetRequiredInputFrameCount"] ++ [::core::mem::offset_of!(ma_node_vtable, onGetRequiredInputFrameCount) - 8usize]; ++ ["Offset of field: ma_node_vtable::inputBusCount"] ++ [::core::mem::offset_of!(ma_node_vtable, inputBusCount) - 16usize]; ++ ["Offset of field: ma_node_vtable::outputBusCount"] ++ [::core::mem::offset_of!(ma_node_vtable, outputBusCount) - 17usize]; ++ ["Offset of field: ma_node_vtable::flags"] ++ [::core::mem::offset_of!(ma_node_vtable, flags) - 20usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_config { ++ pub vtable: *const ma_node_vtable, ++ pub initialState: ma_node_state, ++ pub inputBusCount: ma_uint32, ++ pub outputBusCount: ma_uint32, ++ pub pInputChannels: *const ma_uint32, ++ pub pOutputChannels: *const ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_config::vtable"] ++ [::core::mem::offset_of!(ma_node_config, vtable) - 0usize]; ++ ["Offset of field: ma_node_config::initialState"] ++ [::core::mem::offset_of!(ma_node_config, initialState) - 8usize]; ++ ["Offset of field: ma_node_config::inputBusCount"] ++ [::core::mem::offset_of!(ma_node_config, inputBusCount) - 12usize]; ++ ["Offset of field: ma_node_config::outputBusCount"] ++ [::core::mem::offset_of!(ma_node_config, outputBusCount) - 16usize]; ++ ["Offset of field: ma_node_config::pInputChannels"] ++ [::core::mem::offset_of!(ma_node_config, pInputChannels) - 24usize]; ++ ["Offset of field: ma_node_config::pOutputChannels"] ++ [::core::mem::offset_of!(ma_node_config, pOutputChannels) - 32usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_node_config_init() -> ma_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_output_bus { ++ pub pNode: *mut ma_node, ++ pub outputBusIndex: ma_uint8, ++ pub channels: ma_uint8, ++ pub inputNodeInputBusIndex: ma_uint8, ++ pub flags: ma_uint32, ++ pub refCount: ma_uint32, ++ pub isAttached: ma_bool32, ++ pub lock: ma_spinlock, ++ pub volume: f32, ++ pub pNext: *mut ma_node_output_bus, ++ pub pPrev: *mut ma_node_output_bus, ++ pub pInputNode: *mut ma_node, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_output_bus"][::core::mem::size_of::() - 56usize]; ++ ["Alignment of ma_node_output_bus"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_output_bus::pNode"] ++ [::core::mem::offset_of!(ma_node_output_bus, pNode) - 0usize]; ++ ["Offset of field: ma_node_output_bus::outputBusIndex"] ++ [::core::mem::offset_of!(ma_node_output_bus, outputBusIndex) - 8usize]; ++ ["Offset of field: ma_node_output_bus::channels"] ++ [::core::mem::offset_of!(ma_node_output_bus, channels) - 9usize]; ++ ["Offset of field: ma_node_output_bus::inputNodeInputBusIndex"] ++ [::core::mem::offset_of!(ma_node_output_bus, inputNodeInputBusIndex) - 10usize]; ++ ["Offset of field: ma_node_output_bus::flags"] ++ [::core::mem::offset_of!(ma_node_output_bus, flags) - 12usize]; ++ ["Offset of field: ma_node_output_bus::refCount"] ++ [::core::mem::offset_of!(ma_node_output_bus, refCount) - 16usize]; ++ ["Offset of field: ma_node_output_bus::isAttached"] ++ [::core::mem::offset_of!(ma_node_output_bus, isAttached) - 20usize]; ++ ["Offset of field: ma_node_output_bus::lock"] ++ [::core::mem::offset_of!(ma_node_output_bus, lock) - 24usize]; ++ ["Offset of field: ma_node_output_bus::volume"] ++ [::core::mem::offset_of!(ma_node_output_bus, volume) - 28usize]; ++ ["Offset of field: ma_node_output_bus::pNext"] ++ [::core::mem::offset_of!(ma_node_output_bus, pNext) - 32usize]; ++ ["Offset of field: ma_node_output_bus::pPrev"] ++ [::core::mem::offset_of!(ma_node_output_bus, pPrev) - 40usize]; ++ ["Offset of field: ma_node_output_bus::pInputNode"] ++ [::core::mem::offset_of!(ma_node_output_bus, pInputNode) - 48usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_input_bus { ++ pub head: ma_node_output_bus, ++ pub nextCounter: ma_uint32, ++ pub lock: ma_spinlock, ++ pub channels: ma_uint8, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_input_bus"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_node_input_bus"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_input_bus::head"] ++ [::core::mem::offset_of!(ma_node_input_bus, head) - 0usize]; ++ ["Offset of field: ma_node_input_bus::nextCounter"] ++ [::core::mem::offset_of!(ma_node_input_bus, nextCounter) - 56usize]; ++ ["Offset of field: ma_node_input_bus::lock"] ++ [::core::mem::offset_of!(ma_node_input_bus, lock) - 60usize]; ++ ["Offset of field: ma_node_input_bus::channels"] ++ [::core::mem::offset_of!(ma_node_input_bus, channels) - 64usize]; ++}; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_base { ++ pub pNodeGraph: *mut ma_node_graph, ++ pub vtable: *const ma_node_vtable, ++ pub inputBusCount: ma_uint32, ++ pub outputBusCount: ma_uint32, ++ pub pInputBuses: *mut ma_node_input_bus, ++ pub pOutputBuses: *mut ma_node_output_bus, ++ pub pCachedData: *mut f32, ++ pub cachedDataCapInFramesPerBus: ma_uint16, ++ pub cachedFrameCountOut: ma_uint16, ++ pub cachedFrameCountIn: ma_uint16, ++ pub consumedFrameCountIn: ma_uint16, ++ pub state: ma_node_state, ++ pub stateTimes: [ma_uint64; 2usize], ++ pub localTime: ma_uint64, ++ pub _inputBuses: [ma_node_input_bus; 2usize], ++ pub _outputBuses: [ma_node_output_bus; 2usize], ++ pub _pHeap: *mut core::ffi::c_void, ++ pub _ownsHeap: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_base"][::core::mem::size_of::() - 360usize]; ++ ["Alignment of ma_node_base"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_base::pNodeGraph"] ++ [::core::mem::offset_of!(ma_node_base, pNodeGraph) - 0usize]; ++ ["Offset of field: ma_node_base::vtable"] ++ [::core::mem::offset_of!(ma_node_base, vtable) - 8usize]; ++ ["Offset of field: ma_node_base::inputBusCount"] ++ [::core::mem::offset_of!(ma_node_base, inputBusCount) - 16usize]; ++ ["Offset of field: ma_node_base::outputBusCount"] ++ [::core::mem::offset_of!(ma_node_base, outputBusCount) - 20usize]; ++ ["Offset of field: ma_node_base::pInputBuses"] ++ [::core::mem::offset_of!(ma_node_base, pInputBuses) - 24usize]; ++ ["Offset of field: ma_node_base::pOutputBuses"] ++ [::core::mem::offset_of!(ma_node_base, pOutputBuses) - 32usize]; ++ ["Offset of field: ma_node_base::pCachedData"] ++ [::core::mem::offset_of!(ma_node_base, pCachedData) - 40usize]; ++ ["Offset of field: ma_node_base::cachedDataCapInFramesPerBus"] ++ [::core::mem::offset_of!(ma_node_base, cachedDataCapInFramesPerBus) - 48usize]; ++ ["Offset of field: ma_node_base::cachedFrameCountOut"] ++ [::core::mem::offset_of!(ma_node_base, cachedFrameCountOut) - 50usize]; ++ ["Offset of field: ma_node_base::cachedFrameCountIn"] ++ [::core::mem::offset_of!(ma_node_base, cachedFrameCountIn) - 52usize]; ++ ["Offset of field: ma_node_base::consumedFrameCountIn"] ++ [::core::mem::offset_of!(ma_node_base, consumedFrameCountIn) - 54usize]; ++ ["Offset of field: ma_node_base::state"] ++ [::core::mem::offset_of!(ma_node_base, state) - 56usize]; ++ ["Offset of field: ma_node_base::stateTimes"] ++ [::core::mem::offset_of!(ma_node_base, stateTimes) - 64usize]; ++ ["Offset of field: ma_node_base::localTime"] ++ [::core::mem::offset_of!(ma_node_base, localTime) - 80usize]; ++ ["Offset of field: ma_node_base::_inputBuses"] ++ [::core::mem::offset_of!(ma_node_base, _inputBuses) - 88usize]; ++ ["Offset of field: ma_node_base::_outputBuses"] ++ [::core::mem::offset_of!(ma_node_base, _outputBuses) - 232usize]; ++ ["Offset of field: ma_node_base::_pHeap"] ++ [::core::mem::offset_of!(ma_node_base, _pHeap) - 344usize]; ++ ["Offset of field: ma_node_base::_ownsHeap"] ++ [::core::mem::offset_of!(ma_node_base, _ownsHeap) - 352usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_node_get_heap_size( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_node_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_init_preallocated( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_node_config, ++ pHeap: *mut core::ffi::c_void, ++ pNode: *mut ma_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_uninit( ++ pNode: *mut ma_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_node_get_node_graph(pNode: *const ma_node) -> *mut ma_node_graph; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_input_bus_count(pNode: *const ma_node) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_output_bus_count(pNode: *const ma_node) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_input_channels(pNode: *const ma_node, inputBusIndex: ma_uint32) ++ -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_output_channels( ++ pNode: *const ma_node, ++ outputBusIndex: ma_uint32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_attach_output_bus( ++ pNode: *mut ma_node, ++ outputBusIndex: ma_uint32, ++ pOtherNode: *mut ma_node, ++ otherNodeInputBusIndex: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_detach_output_bus(pNode: *mut ma_node, outputBusIndex: ma_uint32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_detach_all_output_buses(pNode: *mut ma_node) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_set_output_bus_volume( ++ pNode: *mut ma_node, ++ outputBusIndex: ma_uint32, ++ volume: f32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_output_bus_volume(pNode: *const ma_node, outputBusIndex: ma_uint32) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_node_set_state(pNode: *mut ma_node, state: ma_node_state) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_state(pNode: *const ma_node) -> ma_node_state; ++} ++unsafe extern "C" { ++ pub fn ma_node_set_state_time( ++ pNode: *mut ma_node, ++ state: ma_node_state, ++ globalTime: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_state_time(pNode: *const ma_node, state: ma_node_state) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_state_by_time(pNode: *const ma_node, globalTime: ma_uint64) ++ -> ma_node_state; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_state_by_time_range( ++ pNode: *const ma_node, ++ globalTimeBeg: ma_uint64, ++ globalTimeEnd: ma_uint64, ++ ) -> ma_node_state; ++} ++unsafe extern "C" { ++ pub fn ma_node_get_time(pNode: *const ma_node) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_node_set_time(pNode: *mut ma_node, localTime: ma_uint64) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_graph_config { ++ pub channels: ma_uint32, ++ pub processingSizeInFrames: ma_uint32, ++ pub preMixStackSizeInBytes: usize, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_graph_config"][::core::mem::size_of::() - 16usize]; ++ ["Alignment of ma_node_graph_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_graph_config::channels"] ++ [::core::mem::offset_of!(ma_node_graph_config, channels) - 0usize]; ++ ["Offset of field: ma_node_graph_config::processingSizeInFrames"] ++ [::core::mem::offset_of!(ma_node_graph_config, processingSizeInFrames) - 4usize]; ++ ["Offset of field: ma_node_graph_config::preMixStackSizeInBytes"] ++ [::core::mem::offset_of!(ma_node_graph_config, preMixStackSizeInBytes) - 8usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_node_graph_config_init(channels: ma_uint32) -> ma_node_graph_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_node_graph { ++ pub base: ma_node_base, ++ pub endpoint: ma_node_base, ++ pub pProcessingCache: *mut f32, ++ pub processingCacheFramesRemaining: ma_uint32, ++ pub processingSizeInFrames: ma_uint32, ++ pub isReading: ma_bool32, ++ pub pPreMixStack: *mut ma_stack, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_node_graph"][::core::mem::size_of::() - 752usize]; ++ ["Alignment of ma_node_graph"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_node_graph::base"][::core::mem::offset_of!(ma_node_graph, base) - 0usize]; ++ ["Offset of field: ma_node_graph::endpoint"] ++ [::core::mem::offset_of!(ma_node_graph, endpoint) - 360usize]; ++ ["Offset of field: ma_node_graph::pProcessingCache"] ++ [::core::mem::offset_of!(ma_node_graph, pProcessingCache) - 720usize]; ++ ["Offset of field: ma_node_graph::processingCacheFramesRemaining"] ++ [::core::mem::offset_of!(ma_node_graph, processingCacheFramesRemaining) - 728usize]; ++ ["Offset of field: ma_node_graph::processingSizeInFrames"] ++ [::core::mem::offset_of!(ma_node_graph, processingSizeInFrames) - 732usize]; ++ ["Offset of field: ma_node_graph::isReading"] ++ [::core::mem::offset_of!(ma_node_graph, isReading) - 736usize]; ++ ["Offset of field: ma_node_graph::pPreMixStack"] ++ [::core::mem::offset_of!(ma_node_graph, pPreMixStack) - 744usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_node_graph_init( ++ pConfig: *const ma_node_graph_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNodeGraph: *mut ma_node_graph, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_uninit( ++ pNodeGraph: *mut ma_node_graph, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_get_endpoint(pNodeGraph: *mut ma_node_graph) -> *mut ma_node; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_read_pcm_frames( ++ pNodeGraph: *mut ma_node_graph, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_get_channels(pNodeGraph: *const ma_node_graph) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_get_time(pNodeGraph: *const ma_node_graph) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_node_graph_set_time( ++ pNodeGraph: *mut ma_node_graph, ++ globalTime: ma_uint64, ++ ) -> ma_result; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_node_config { ++ pub nodeConfig: ma_node_config, ++ pub pDataSource: *mut ma_data_source, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_node_config"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_data_source_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_data_source_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_data_source_node_config::pDataSource"] ++ [::core::mem::offset_of!(ma_data_source_node_config, pDataSource) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_source_node_config_init( ++ pDataSource: *mut ma_data_source, ++ ) -> ma_data_source_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_data_source_node { ++ pub base: ma_node_base, ++ pub pDataSource: *mut ma_data_source, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_data_source_node"][::core::mem::size_of::() - 368usize]; ++ ["Alignment of ma_data_source_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_data_source_node::base"] ++ [::core::mem::offset_of!(ma_data_source_node, base) - 0usize]; ++ ["Offset of field: ma_data_source_node::pDataSource"] ++ [::core::mem::offset_of!(ma_data_source_node, pDataSource) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_data_source_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_data_source_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pDataSourceNode: *mut ma_data_source_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_node_uninit( ++ pDataSourceNode: *mut ma_data_source_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_data_source_node_set_looping( ++ pDataSourceNode: *mut ma_data_source_node, ++ isLooping: ma_bool32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_data_source_node_is_looping(pDataSourceNode: *mut ma_data_source_node) -> ma_bool32; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_splitter_node_config { ++ pub nodeConfig: ma_node_config, ++ pub channels: ma_uint32, ++ pub outputBusCount: ma_uint32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_splitter_node_config"] ++ [::core::mem::size_of::() - 48usize]; ++ ["Alignment of ma_splitter_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_splitter_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_splitter_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_splitter_node_config::channels"] ++ [::core::mem::offset_of!(ma_splitter_node_config, channels) - 40usize]; ++ ["Offset of field: ma_splitter_node_config::outputBusCount"] ++ [::core::mem::offset_of!(ma_splitter_node_config, outputBusCount) - 44usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_splitter_node_config_init(channels: ma_uint32) -> ma_splitter_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_splitter_node { ++ pub base: ma_node_base, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_splitter_node"][::core::mem::size_of::() - 360usize]; ++ ["Alignment of ma_splitter_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_splitter_node::base"] ++ [::core::mem::offset_of!(ma_splitter_node, base) - 0usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_splitter_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_splitter_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pSplitterNode: *mut ma_splitter_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_splitter_node_uninit( ++ pSplitterNode: *mut ma_splitter_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_biquad_node_config { ++ pub nodeConfig: ma_node_config, ++ pub biquad: ma_biquad_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad_node_config"][::core::mem::size_of::() - 96usize]; ++ ["Alignment of ma_biquad_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_biquad_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_biquad_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_biquad_node_config::biquad"] ++ [::core::mem::offset_of!(ma_biquad_node_config, biquad) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_biquad_node_config_init( ++ channels: ma_uint32, ++ b0: f32, ++ b1: f32, ++ b2: f32, ++ a0: f32, ++ a1: f32, ++ a2: f32, ++ ) -> ma_biquad_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_biquad_node { ++ pub baseNode: ma_node_base, ++ pub biquad: ma_biquad, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_biquad_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_biquad_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_biquad_node::baseNode"] ++ [::core::mem::offset_of!(ma_biquad_node, baseNode) - 0usize]; ++ ["Offset of field: ma_biquad_node::biquad"] ++ [::core::mem::offset_of!(ma_biquad_node, biquad) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_biquad_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_biquad_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_biquad_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_node_reinit( ++ pConfig: *const ma_biquad_config, ++ pNode: *mut ma_biquad_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_biquad_node_uninit( ++ pNode: *mut ma_biquad_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub lpf: ma_lpf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_lpf_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_lpf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_lpf_node_config::lpf"] ++ [::core::mem::offset_of!(ma_lpf_node_config, lpf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_lpf_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_lpf_node { ++ pub baseNode: ma_node_base, ++ pub lpf: ma_lpf, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_lpf_node"][::core::mem::size_of::() - 416usize]; ++ ["Alignment of ma_lpf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_lpf_node::baseNode"] ++ [::core::mem::offset_of!(ma_lpf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_lpf_node::lpf"][::core::mem::offset_of!(ma_lpf_node, lpf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_lpf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_lpf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_lpf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_node_reinit(pConfig: *const ma_lpf_config, pNode: *mut ma_lpf_node) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_lpf_node_uninit( ++ pNode: *mut ma_lpf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub hpf: ma_hpf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_hpf_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_hpf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_hpf_node_config::hpf"] ++ [::core::mem::offset_of!(ma_hpf_node_config, hpf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_hpf_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hpf_node { ++ pub baseNode: ma_node_base, ++ pub hpf: ma_hpf, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hpf_node"][::core::mem::size_of::() - 416usize]; ++ ["Alignment of ma_hpf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hpf_node::baseNode"] ++ [::core::mem::offset_of!(ma_hpf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_hpf_node::hpf"][::core::mem::offset_of!(ma_hpf_node, hpf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hpf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_hpf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_hpf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_node_reinit(pConfig: *const ma_hpf_config, pNode: *mut ma_hpf_node) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hpf_node_uninit( ++ pNode: *mut ma_hpf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub bpf: ma_bpf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_bpf_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_bpf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_bpf_node_config::bpf"] ++ [::core::mem::offset_of!(ma_bpf_node_config, bpf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ cutoffFrequency: f64, ++ order: ma_uint32, ++ ) -> ma_bpf_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_bpf_node { ++ pub baseNode: ma_node_base, ++ pub bpf: ma_bpf, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_bpf_node"][::core::mem::size_of::() - 400usize]; ++ ["Alignment of ma_bpf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_bpf_node::baseNode"] ++ [::core::mem::offset_of!(ma_bpf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_bpf_node::bpf"][::core::mem::offset_of!(ma_bpf_node, bpf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_bpf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_bpf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_bpf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_node_reinit(pConfig: *const ma_bpf_config, pNode: *mut ma_bpf_node) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_bpf_node_uninit( ++ pNode: *mut ma_bpf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_notch_node_config { ++ pub nodeConfig: ma_node_config, ++ pub notch: ma_notch_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_notch_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_notch_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_notch_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_notch_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_notch_node_config::notch"] ++ [::core::mem::offset_of!(ma_notch_node_config, notch) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_notch_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ q: f64, ++ frequency: f64, ++ ) -> ma_notch_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_notch_node { ++ pub baseNode: ma_node_base, ++ pub notch: ma_notch2, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_notch_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_notch_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_notch_node::baseNode"] ++ [::core::mem::offset_of!(ma_notch_node, baseNode) - 0usize]; ++ ["Offset of field: ma_notch_node::notch"] ++ [::core::mem::offset_of!(ma_notch_node, notch) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_notch_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_notch_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_notch_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch_node_reinit( ++ pConfig: *const ma_notch_config, ++ pNode: *mut ma_notch_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_notch_node_uninit( ++ pNode: *mut ma_notch_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_peak_node_config { ++ pub nodeConfig: ma_node_config, ++ pub peak: ma_peak_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_peak_node_config"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_peak_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_peak_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_peak_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_peak_node_config::peak"] ++ [::core::mem::offset_of!(ma_peak_node_config, peak) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_peak_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ q: f64, ++ frequency: f64, ++ ) -> ma_peak_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_peak_node { ++ pub baseNode: ma_node_base, ++ pub peak: ma_peak2, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_peak_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_peak_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_peak_node::baseNode"] ++ [::core::mem::offset_of!(ma_peak_node, baseNode) - 0usize]; ++ ["Offset of field: ma_peak_node::peak"][::core::mem::offset_of!(ma_peak_node, peak) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_peak_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_peak_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_peak_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak_node_reinit( ++ pConfig: *const ma_peak_config, ++ pNode: *mut ma_peak_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_peak_node_uninit( ++ pNode: *mut ma_peak_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_loshelf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub loshelf: ma_loshelf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_loshelf_node_config"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_loshelf_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_loshelf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_loshelf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_loshelf_node_config::loshelf"] ++ [::core::mem::offset_of!(ma_loshelf_node_config, loshelf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_loshelf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ q: f64, ++ frequency: f64, ++ ) -> ma_loshelf_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_loshelf_node { ++ pub baseNode: ma_node_base, ++ pub loshelf: ma_loshelf2, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_loshelf_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_loshelf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_loshelf_node::baseNode"] ++ [::core::mem::offset_of!(ma_loshelf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_loshelf_node::loshelf"] ++ [::core::mem::offset_of!(ma_loshelf_node, loshelf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_loshelf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_loshelf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_loshelf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf_node_reinit( ++ pConfig: *const ma_loshelf_config, ++ pNode: *mut ma_loshelf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_loshelf_node_uninit( ++ pNode: *mut ma_loshelf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_hishelf_node_config { ++ pub nodeConfig: ma_node_config, ++ pub hishelf: ma_hishelf_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hishelf_node_config"][::core::mem::size_of::() - 80usize]; ++ ["Alignment of ma_hishelf_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hishelf_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_hishelf_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_hishelf_node_config::hishelf"] ++ [::core::mem::offset_of!(ma_hishelf_node_config, hishelf) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hishelf_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ gainDB: f64, ++ q: f64, ++ frequency: f64, ++ ) -> ma_hishelf_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_hishelf_node { ++ pub baseNode: ma_node_base, ++ pub hishelf: ma_hishelf2, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_hishelf_node"][::core::mem::size_of::() - 424usize]; ++ ["Alignment of ma_hishelf_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_hishelf_node::baseNode"] ++ [::core::mem::offset_of!(ma_hishelf_node, baseNode) - 0usize]; ++ ["Offset of field: ma_hishelf_node::hishelf"] ++ [::core::mem::offset_of!(ma_hishelf_node, hishelf) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_hishelf_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_hishelf_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pNode: *mut ma_hishelf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf_node_reinit( ++ pConfig: *const ma_hishelf_config, ++ pNode: *mut ma_hishelf_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_hishelf_node_uninit( ++ pNode: *mut ma_hishelf_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_delay_node_config { ++ pub nodeConfig: ma_node_config, ++ pub delay: ma_delay_config, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_delay_node_config"][::core::mem::size_of::() - 72usize]; ++ ["Alignment of ma_delay_node_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_delay_node_config::nodeConfig"] ++ [::core::mem::offset_of!(ma_delay_node_config, nodeConfig) - 0usize]; ++ ["Offset of field: ma_delay_node_config::delay"] ++ [::core::mem::offset_of!(ma_delay_node_config, delay) - 40usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_delay_node_config_init( ++ channels: ma_uint32, ++ sampleRate: ma_uint32, ++ delayInFrames: ma_uint32, ++ decay: f32, ++ ) -> ma_delay_node_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_delay_node { ++ pub baseNode: ma_node_base, ++ pub delay: ma_delay, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_delay_node"][::core::mem::size_of::() - 408usize]; ++ ["Alignment of ma_delay_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_delay_node::baseNode"] ++ [::core::mem::offset_of!(ma_delay_node, baseNode) - 0usize]; ++ ["Offset of field: ma_delay_node::delay"] ++ [::core::mem::offset_of!(ma_delay_node, delay) - 360usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_delay_node_init( ++ pNodeGraph: *mut ma_node_graph, ++ pConfig: *const ma_delay_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pDelayNode: *mut ma_delay_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_uninit( ++ pDelayNode: *mut ma_delay_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_set_wet(pDelayNode: *mut ma_delay_node, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_get_wet(pDelayNode: *const ma_delay_node) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_set_dry(pDelayNode: *mut ma_delay_node, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_get_dry(pDelayNode: *const ma_delay_node) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_set_decay(pDelayNode: *mut ma_delay_node, value: f32); ++} ++unsafe extern "C" { ++ pub fn ma_delay_node_get_decay(pDelayNode: *const ma_delay_node) -> f32; ++} ++pub const ma_sound_flags_MA_SOUND_FLAG_STREAM: ma_sound_flags = 1; ++pub const ma_sound_flags_MA_SOUND_FLAG_DECODE: ma_sound_flags = 2; ++pub const ma_sound_flags_MA_SOUND_FLAG_ASYNC: ma_sound_flags = 4; ++pub const ma_sound_flags_MA_SOUND_FLAG_WAIT_INIT: ma_sound_flags = 8; ++pub const ma_sound_flags_MA_SOUND_FLAG_UNKNOWN_LENGTH: ma_sound_flags = 16; ++pub const ma_sound_flags_MA_SOUND_FLAG_LOOPING: ma_sound_flags = 32; ++pub const ma_sound_flags_MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT: ma_sound_flags = 4096; ++pub const ma_sound_flags_MA_SOUND_FLAG_NO_PITCH: ma_sound_flags = 8192; ++pub const ma_sound_flags_MA_SOUND_FLAG_NO_SPATIALIZATION: ma_sound_flags = 16384; ++pub type ma_sound_flags = core::ffi::c_uint; ++pub const ma_engine_node_type_ma_engine_node_type_sound: ma_engine_node_type = 0; ++pub const ma_engine_node_type_ma_engine_node_type_group: ma_engine_node_type = 1; ++pub type ma_engine_node_type = core::ffi::c_uint; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_engine_node_config { ++ pub pEngine: *mut ma_engine, ++ pub type_: ma_engine_node_type, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub volumeSmoothTimeInPCMFrames: ma_uint32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub isPitchDisabled: ma_bool8, ++ pub isSpatializationDisabled: ma_bool8, ++ pub pinnedListenerIndex: ma_uint8, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine_node_config"][::core::mem::size_of::() - 40usize]; ++ ["Alignment of ma_engine_node_config"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine_node_config::pEngine"] ++ [::core::mem::offset_of!(ma_engine_node_config, pEngine) - 0usize]; ++ ["Offset of field: ma_engine_node_config::type_"] ++ [::core::mem::offset_of!(ma_engine_node_config, type_) - 8usize]; ++ ["Offset of field: ma_engine_node_config::channelsIn"] ++ [::core::mem::offset_of!(ma_engine_node_config, channelsIn) - 12usize]; ++ ["Offset of field: ma_engine_node_config::channelsOut"] ++ [::core::mem::offset_of!(ma_engine_node_config, channelsOut) - 16usize]; ++ ["Offset of field: ma_engine_node_config::sampleRate"] ++ [::core::mem::offset_of!(ma_engine_node_config, sampleRate) - 20usize]; ++ ["Offset of field: ma_engine_node_config::volumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_engine_node_config, volumeSmoothTimeInPCMFrames) - 24usize]; ++ ["Offset of field: ma_engine_node_config::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_engine_node_config, monoExpansionMode) - 28usize]; ++ ["Offset of field: ma_engine_node_config::isPitchDisabled"] ++ [::core::mem::offset_of!(ma_engine_node_config, isPitchDisabled) - 32usize]; ++ ["Offset of field: ma_engine_node_config::isSpatializationDisabled"] ++ [::core::mem::offset_of!(ma_engine_node_config, isSpatializationDisabled) - 33usize]; ++ ["Offset of field: ma_engine_node_config::pinnedListenerIndex"] ++ [::core::mem::offset_of!(ma_engine_node_config, pinnedListenerIndex) - 34usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_engine_node_config_init( ++ pEngine: *mut ma_engine, ++ type_: ma_engine_node_type, ++ flags: ma_uint32, ++ ) -> ma_engine_node_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_engine_node { ++ pub baseNode: ma_node_base, ++ pub pEngine: *mut ma_engine, ++ pub sampleRate: ma_uint32, ++ pub volumeSmoothTimeInPCMFrames: ma_uint32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub fader: ma_fader, ++ pub resampler: ma_linear_resampler, ++ pub spatializer: ma_spatializer, ++ pub panner: ma_panner, ++ pub volumeGainer: ma_gainer, ++ pub volume: ma_atomic_float, ++ pub pitch: f32, ++ pub oldPitch: f32, ++ pub oldDopplerPitch: f32, ++ pub isPitchDisabled: ma_bool32, ++ pub isSpatializationDisabled: ma_bool32, ++ pub pinnedListenerIndex: ma_uint32, ++ pub fadeSettings: ma_engine_node__bindgen_ty_1, ++ pub _ownsHeap: ma_bool8, ++ pub _pHeap: *mut core::ffi::c_void, ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_engine_node__bindgen_ty_1 { ++ pub volumeBeg: ma_atomic_float, ++ pub volumeEnd: ma_atomic_float, ++ pub fadeLengthInFrames: ma_atomic_uint64, ++ pub absoluteGlobalTimeInFrames: ma_atomic_uint64, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine_node__bindgen_ty_1"] ++ [::core::mem::size_of::() - 24usize]; ++ ["Alignment of ma_engine_node__bindgen_ty_1"] ++ [::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine_node__bindgen_ty_1::volumeBeg"] ++ [::core::mem::offset_of!(ma_engine_node__bindgen_ty_1, volumeBeg) - 0usize]; ++ ["Offset of field: ma_engine_node__bindgen_ty_1::volumeEnd"] ++ [::core::mem::offset_of!(ma_engine_node__bindgen_ty_1, volumeEnd) - 4usize]; ++ ["Offset of field: ma_engine_node__bindgen_ty_1::fadeLengthInFrames"] ++ [::core::mem::offset_of!(ma_engine_node__bindgen_ty_1, fadeLengthInFrames) - 8usize]; ++ ["Offset of field: ma_engine_node__bindgen_ty_1::absoluteGlobalTimeInFrames"][::core::mem::offset_of!( ++ ma_engine_node__bindgen_ty_1, ++ absoluteGlobalTimeInFrames ++ ) - 16usize]; ++}; ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine_node"][::core::mem::size_of::() - 896usize]; ++ ["Alignment of ma_engine_node"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine_node::baseNode"] ++ [::core::mem::offset_of!(ma_engine_node, baseNode) - 0usize]; ++ ["Offset of field: ma_engine_node::pEngine"] ++ [::core::mem::offset_of!(ma_engine_node, pEngine) - 360usize]; ++ ["Offset of field: ma_engine_node::sampleRate"] ++ [::core::mem::offset_of!(ma_engine_node, sampleRate) - 368usize]; ++ ["Offset of field: ma_engine_node::volumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_engine_node, volumeSmoothTimeInPCMFrames) - 372usize]; ++ ["Offset of field: ma_engine_node::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_engine_node, monoExpansionMode) - 376usize]; ++ ["Offset of field: ma_engine_node::fader"] ++ [::core::mem::offset_of!(ma_engine_node, fader) - 384usize]; ++ ["Offset of field: ma_engine_node::resampler"] ++ [::core::mem::offset_of!(ma_engine_node, resampler) - 424usize]; ++ ["Offset of field: ma_engine_node::spatializer"] ++ [::core::mem::offset_of!(ma_engine_node, spatializer) - 560usize]; ++ ["Offset of field: ma_engine_node::panner"] ++ [::core::mem::offset_of!(ma_engine_node, panner) - 760usize]; ++ ["Offset of field: ma_engine_node::volumeGainer"] ++ [::core::mem::offset_of!(ma_engine_node, volumeGainer) - 776usize]; ++ ["Offset of field: ma_engine_node::volume"] ++ [::core::mem::offset_of!(ma_engine_node, volume) - 824usize]; ++ ["Offset of field: ma_engine_node::pitch"] ++ [::core::mem::offset_of!(ma_engine_node, pitch) - 828usize]; ++ ["Offset of field: ma_engine_node::oldPitch"] ++ [::core::mem::offset_of!(ma_engine_node, oldPitch) - 832usize]; ++ ["Offset of field: ma_engine_node::oldDopplerPitch"] ++ [::core::mem::offset_of!(ma_engine_node, oldDopplerPitch) - 836usize]; ++ ["Offset of field: ma_engine_node::isPitchDisabled"] ++ [::core::mem::offset_of!(ma_engine_node, isPitchDisabled) - 840usize]; ++ ["Offset of field: ma_engine_node::isSpatializationDisabled"] ++ [::core::mem::offset_of!(ma_engine_node, isSpatializationDisabled) - 844usize]; ++ ["Offset of field: ma_engine_node::pinnedListenerIndex"] ++ [::core::mem::offset_of!(ma_engine_node, pinnedListenerIndex) - 848usize]; ++ ["Offset of field: ma_engine_node::fadeSettings"] ++ [::core::mem::offset_of!(ma_engine_node, fadeSettings) - 856usize]; ++ ["Offset of field: ma_engine_node::_ownsHeap"] ++ [::core::mem::offset_of!(ma_engine_node, _ownsHeap) - 880usize]; ++ ["Offset of field: ma_engine_node::_pHeap"] ++ [::core::mem::offset_of!(ma_engine_node, _pHeap) - 888usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_engine_node_get_heap_size( ++ pConfig: *const ma_engine_node_config, ++ pHeapSizeInBytes: *mut usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_node_init_preallocated( ++ pConfig: *const ma_engine_node_config, ++ pHeap: *mut core::ffi::c_void, ++ pEngineNode: *mut ma_engine_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_node_init( ++ pConfig: *const ma_engine_node_config, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ pEngineNode: *mut ma_engine_node, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_node_uninit( ++ pEngineNode: *mut ma_engine_node, ++ pAllocationCallbacks: *const ma_allocation_callbacks, ++ ); ++} ++pub type ma_sound_end_proc = ::core::option::Option< ++ unsafe extern "C" fn(pUserData: *mut core::ffi::c_void, pSound: *mut ma_sound), ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_sound_config { ++ pub pFilePath: *const core::ffi::c_char, ++ pub pFilePathW: *const wchar_t, ++ pub pDataSource: *mut ma_data_source, ++ pub pInitialAttachment: *mut ma_node, ++ pub initialAttachmentInputBusIndex: ma_uint32, ++ pub channelsIn: ma_uint32, ++ pub channelsOut: ma_uint32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub flags: ma_uint32, ++ pub volumeSmoothTimeInPCMFrames: ma_uint32, ++ pub initialSeekPointInPCMFrames: ma_uint64, ++ pub rangeBegInPCMFrames: ma_uint64, ++ pub rangeEndInPCMFrames: ma_uint64, ++ pub loopPointBegInPCMFrames: ma_uint64, ++ pub loopPointEndInPCMFrames: ma_uint64, ++ pub endCallback: ma_sound_end_proc, ++ pub pEndCallbackUserData: *mut core::ffi::c_void, ++ pub initNotifications: ma_resource_manager_pipeline_notifications, ++ pub pDoneFence: *mut ma_fence, ++ pub isLooping: ma_bool32, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_sound_config"][::core::mem::size_of::() - 160usize]; ++ ["Alignment of ma_sound_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_sound_config::pFilePath"] ++ [::core::mem::offset_of!(ma_sound_config, pFilePath) - 0usize]; ++ ["Offset of field: ma_sound_config::pFilePathW"] ++ [::core::mem::offset_of!(ma_sound_config, pFilePathW) - 8usize]; ++ ["Offset of field: ma_sound_config::pDataSource"] ++ [::core::mem::offset_of!(ma_sound_config, pDataSource) - 16usize]; ++ ["Offset of field: ma_sound_config::pInitialAttachment"] ++ [::core::mem::offset_of!(ma_sound_config, pInitialAttachment) - 24usize]; ++ ["Offset of field: ma_sound_config::initialAttachmentInputBusIndex"] ++ [::core::mem::offset_of!(ma_sound_config, initialAttachmentInputBusIndex) - 32usize]; ++ ["Offset of field: ma_sound_config::channelsIn"] ++ [::core::mem::offset_of!(ma_sound_config, channelsIn) - 36usize]; ++ ["Offset of field: ma_sound_config::channelsOut"] ++ [::core::mem::offset_of!(ma_sound_config, channelsOut) - 40usize]; ++ ["Offset of field: ma_sound_config::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_sound_config, monoExpansionMode) - 44usize]; ++ ["Offset of field: ma_sound_config::flags"] ++ [::core::mem::offset_of!(ma_sound_config, flags) - 48usize]; ++ ["Offset of field: ma_sound_config::volumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, volumeSmoothTimeInPCMFrames) - 52usize]; ++ ["Offset of field: ma_sound_config::initialSeekPointInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, initialSeekPointInPCMFrames) - 56usize]; ++ ["Offset of field: ma_sound_config::rangeBegInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, rangeBegInPCMFrames) - 64usize]; ++ ["Offset of field: ma_sound_config::rangeEndInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, rangeEndInPCMFrames) - 72usize]; ++ ["Offset of field: ma_sound_config::loopPointBegInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, loopPointBegInPCMFrames) - 80usize]; ++ ["Offset of field: ma_sound_config::loopPointEndInPCMFrames"] ++ [::core::mem::offset_of!(ma_sound_config, loopPointEndInPCMFrames) - 88usize]; ++ ["Offset of field: ma_sound_config::endCallback"] ++ [::core::mem::offset_of!(ma_sound_config, endCallback) - 96usize]; ++ ["Offset of field: ma_sound_config::pEndCallbackUserData"] ++ [::core::mem::offset_of!(ma_sound_config, pEndCallbackUserData) - 104usize]; ++ ["Offset of field: ma_sound_config::initNotifications"] ++ [::core::mem::offset_of!(ma_sound_config, initNotifications) - 112usize]; ++ ["Offset of field: ma_sound_config::pDoneFence"] ++ [::core::mem::offset_of!(ma_sound_config, pDoneFence) - 144usize]; ++ ["Offset of field: ma_sound_config::isLooping"] ++ [::core::mem::offset_of!(ma_sound_config, isLooping) - 152usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_sound_config_init() -> ma_sound_config; ++} ++unsafe extern "C" { ++ pub fn ma_sound_config_init_2(pEngine: *mut ma_engine) -> ma_sound_config; ++} ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_sound { ++ pub engineNode: ma_engine_node, ++ pub pDataSource: *mut ma_data_source, ++ pub seekTarget: ma_uint64, ++ pub atEnd: ma_bool32, ++ pub endCallback: ma_sound_end_proc, ++ pub pEndCallbackUserData: *mut core::ffi::c_void, ++ pub ownsDataSource: ma_bool8, ++ pub pResourceManagerDataSource: *mut ma_resource_manager_data_source, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_sound"][::core::mem::size_of::() - 952usize]; ++ ["Alignment of ma_sound"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_sound::engineNode"] ++ [::core::mem::offset_of!(ma_sound, engineNode) - 0usize]; ++ ["Offset of field: ma_sound::pDataSource"] ++ [::core::mem::offset_of!(ma_sound, pDataSource) - 896usize]; ++ ["Offset of field: ma_sound::seekTarget"] ++ [::core::mem::offset_of!(ma_sound, seekTarget) - 904usize]; ++ ["Offset of field: ma_sound::atEnd"][::core::mem::offset_of!(ma_sound, atEnd) - 912usize]; ++ ["Offset of field: ma_sound::endCallback"] ++ [::core::mem::offset_of!(ma_sound, endCallback) - 920usize]; ++ ["Offset of field: ma_sound::pEndCallbackUserData"] ++ [::core::mem::offset_of!(ma_sound, pEndCallbackUserData) - 928usize]; ++ ["Offset of field: ma_sound::ownsDataSource"] ++ [::core::mem::offset_of!(ma_sound, ownsDataSource) - 936usize]; ++ ["Offset of field: ma_sound::pResourceManagerDataSource"] ++ [::core::mem::offset_of!(ma_sound, pResourceManagerDataSource) - 944usize]; ++}; ++#[repr(C)] ++#[derive(Copy, Clone)] ++pub struct ma_sound_inlined { ++ pub sound: ma_sound, ++ pub pNext: *mut ma_sound_inlined, ++ pub pPrev: *mut ma_sound_inlined, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_sound_inlined"][::core::mem::size_of::() - 968usize]; ++ ["Alignment of ma_sound_inlined"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_sound_inlined::sound"] ++ [::core::mem::offset_of!(ma_sound_inlined, sound) - 0usize]; ++ ["Offset of field: ma_sound_inlined::pNext"] ++ [::core::mem::offset_of!(ma_sound_inlined, pNext) - 952usize]; ++ ["Offset of field: ma_sound_inlined::pPrev"] ++ [::core::mem::offset_of!(ma_sound_inlined, pPrev) - 960usize]; ++}; ++pub type ma_sound_group_config = ma_sound_config; ++pub type ma_sound_group = ma_sound; ++unsafe extern "C" { ++ pub fn ma_sound_group_config_init() -> ma_sound_group_config; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_config_init_2(pEngine: *mut ma_engine) -> ma_sound_group_config; ++} ++pub type ma_engine_process_proc = ::core::option::Option< ++ unsafe extern "C" fn( ++ pUserData: *mut core::ffi::c_void, ++ pFramesOut: *mut f32, ++ frameCount: ma_uint64, ++ ), ++>; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_engine_config { ++ pub pResourceManager: *mut ma_resource_manager, ++ pub pContext: *mut ma_context, ++ pub pDevice: *mut ma_device, ++ pub pPlaybackDeviceID: *mut ma_device_id, ++ pub dataCallback: ma_device_data_proc, ++ pub notificationCallback: ma_device_notification_proc, ++ pub pLog: *mut ma_log, ++ pub listenerCount: ma_uint32, ++ pub channels: ma_uint32, ++ pub sampleRate: ma_uint32, ++ pub periodSizeInFrames: ma_uint32, ++ pub periodSizeInMilliseconds: ma_uint32, ++ pub gainSmoothTimeInFrames: ma_uint32, ++ pub gainSmoothTimeInMilliseconds: ma_uint32, ++ pub defaultVolumeSmoothTimeInPCMFrames: ma_uint32, ++ pub preMixStackSizeInBytes: ma_uint32, ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub noAutoStart: ma_bool32, ++ pub noDevice: ma_bool32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub pResourceManagerVFS: *mut ma_vfs, ++ pub onProcess: ma_engine_process_proc, ++ pub pProcessUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine_config"][::core::mem::size_of::() - 168usize]; ++ ["Alignment of ma_engine_config"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine_config::pResourceManager"] ++ [::core::mem::offset_of!(ma_engine_config, pResourceManager) - 0usize]; ++ ["Offset of field: ma_engine_config::pContext"] ++ [::core::mem::offset_of!(ma_engine_config, pContext) - 8usize]; ++ ["Offset of field: ma_engine_config::pDevice"] ++ [::core::mem::offset_of!(ma_engine_config, pDevice) - 16usize]; ++ ["Offset of field: ma_engine_config::pPlaybackDeviceID"] ++ [::core::mem::offset_of!(ma_engine_config, pPlaybackDeviceID) - 24usize]; ++ ["Offset of field: ma_engine_config::dataCallback"] ++ [::core::mem::offset_of!(ma_engine_config, dataCallback) - 32usize]; ++ ["Offset of field: ma_engine_config::notificationCallback"] ++ [::core::mem::offset_of!(ma_engine_config, notificationCallback) - 40usize]; ++ ["Offset of field: ma_engine_config::pLog"] ++ [::core::mem::offset_of!(ma_engine_config, pLog) - 48usize]; ++ ["Offset of field: ma_engine_config::listenerCount"] ++ [::core::mem::offset_of!(ma_engine_config, listenerCount) - 56usize]; ++ ["Offset of field: ma_engine_config::channels"] ++ [::core::mem::offset_of!(ma_engine_config, channels) - 60usize]; ++ ["Offset of field: ma_engine_config::sampleRate"] ++ [::core::mem::offset_of!(ma_engine_config, sampleRate) - 64usize]; ++ ["Offset of field: ma_engine_config::periodSizeInFrames"] ++ [::core::mem::offset_of!(ma_engine_config, periodSizeInFrames) - 68usize]; ++ ["Offset of field: ma_engine_config::periodSizeInMilliseconds"] ++ [::core::mem::offset_of!(ma_engine_config, periodSizeInMilliseconds) - 72usize]; ++ ["Offset of field: ma_engine_config::gainSmoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_engine_config, gainSmoothTimeInFrames) - 76usize]; ++ ["Offset of field: ma_engine_config::gainSmoothTimeInMilliseconds"] ++ [::core::mem::offset_of!(ma_engine_config, gainSmoothTimeInMilliseconds) - 80usize]; ++ ["Offset of field: ma_engine_config::defaultVolumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_engine_config, defaultVolumeSmoothTimeInPCMFrames) - 84usize]; ++ ["Offset of field: ma_engine_config::preMixStackSizeInBytes"] ++ [::core::mem::offset_of!(ma_engine_config, preMixStackSizeInBytes) - 88usize]; ++ ["Offset of field: ma_engine_config::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_engine_config, allocationCallbacks) - 96usize]; ++ ["Offset of field: ma_engine_config::noAutoStart"] ++ [::core::mem::offset_of!(ma_engine_config, noAutoStart) - 128usize]; ++ ["Offset of field: ma_engine_config::noDevice"] ++ [::core::mem::offset_of!(ma_engine_config, noDevice) - 132usize]; ++ ["Offset of field: ma_engine_config::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_engine_config, monoExpansionMode) - 136usize]; ++ ["Offset of field: ma_engine_config::pResourceManagerVFS"] ++ [::core::mem::offset_of!(ma_engine_config, pResourceManagerVFS) - 144usize]; ++ ["Offset of field: ma_engine_config::onProcess"] ++ [::core::mem::offset_of!(ma_engine_config, onProcess) - 152usize]; ++ ["Offset of field: ma_engine_config::pProcessUserData"] ++ [::core::mem::offset_of!(ma_engine_config, pProcessUserData) - 160usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_engine_config_init() -> ma_engine_config; ++} ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct ma_engine { ++ pub nodeGraph: ma_node_graph, ++ pub pResourceManager: *mut ma_resource_manager, ++ pub pDevice: *mut ma_device, ++ pub pLog: *mut ma_log, ++ pub sampleRate: ma_uint32, ++ pub listenerCount: ma_uint32, ++ pub listeners: [ma_spatializer_listener; 4usize], ++ pub allocationCallbacks: ma_allocation_callbacks, ++ pub ownsResourceManager: ma_bool8, ++ pub ownsDevice: ma_bool8, ++ pub inlinedSoundLock: ma_spinlock, ++ pub pInlinedSoundHead: *mut ma_sound_inlined, ++ pub inlinedSoundCount: ma_uint32, ++ pub gainSmoothTimeInFrames: ma_uint32, ++ pub defaultVolumeSmoothTimeInPCMFrames: ma_uint32, ++ pub monoExpansionMode: ma_mono_expansion_mode, ++ pub onProcess: ma_engine_process_proc, ++ pub pProcessUserData: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of ma_engine"][::core::mem::size_of::() - 1312usize]; ++ ["Alignment of ma_engine"][::core::mem::align_of::() - 8usize]; ++ ["Offset of field: ma_engine::nodeGraph"] ++ [::core::mem::offset_of!(ma_engine, nodeGraph) - 0usize]; ++ ["Offset of field: ma_engine::pResourceManager"] ++ [::core::mem::offset_of!(ma_engine, pResourceManager) - 752usize]; ++ ["Offset of field: ma_engine::pDevice"][::core::mem::offset_of!(ma_engine, pDevice) - 760usize]; ++ ["Offset of field: ma_engine::pLog"][::core::mem::offset_of!(ma_engine, pLog) - 768usize]; ++ ["Offset of field: ma_engine::sampleRate"] ++ [::core::mem::offset_of!(ma_engine, sampleRate) - 776usize]; ++ ["Offset of field: ma_engine::listenerCount"] ++ [::core::mem::offset_of!(ma_engine, listenerCount) - 780usize]; ++ ["Offset of field: ma_engine::listeners"] ++ [::core::mem::offset_of!(ma_engine, listeners) - 784usize]; ++ ["Offset of field: ma_engine::allocationCallbacks"] ++ [::core::mem::offset_of!(ma_engine, allocationCallbacks) - 1232usize]; ++ ["Offset of field: ma_engine::ownsResourceManager"] ++ [::core::mem::offset_of!(ma_engine, ownsResourceManager) - 1264usize]; ++ ["Offset of field: ma_engine::ownsDevice"] ++ [::core::mem::offset_of!(ma_engine, ownsDevice) - 1265usize]; ++ ["Offset of field: ma_engine::inlinedSoundLock"] ++ [::core::mem::offset_of!(ma_engine, inlinedSoundLock) - 1268usize]; ++ ["Offset of field: ma_engine::pInlinedSoundHead"] ++ [::core::mem::offset_of!(ma_engine, pInlinedSoundHead) - 1272usize]; ++ ["Offset of field: ma_engine::inlinedSoundCount"] ++ [::core::mem::offset_of!(ma_engine, inlinedSoundCount) - 1280usize]; ++ ["Offset of field: ma_engine::gainSmoothTimeInFrames"] ++ [::core::mem::offset_of!(ma_engine, gainSmoothTimeInFrames) - 1284usize]; ++ ["Offset of field: ma_engine::defaultVolumeSmoothTimeInPCMFrames"] ++ [::core::mem::offset_of!(ma_engine, defaultVolumeSmoothTimeInPCMFrames) - 1288usize]; ++ ["Offset of field: ma_engine::monoExpansionMode"] ++ [::core::mem::offset_of!(ma_engine, monoExpansionMode) - 1292usize]; ++ ["Offset of field: ma_engine::onProcess"] ++ [::core::mem::offset_of!(ma_engine, onProcess) - 1296usize]; ++ ["Offset of field: ma_engine::pProcessUserData"] ++ [::core::mem::offset_of!(ma_engine, pProcessUserData) - 1304usize]; ++}; ++unsafe extern "C" { ++ pub fn ma_engine_init(pConfig: *const ma_engine_config, pEngine: *mut ma_engine) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_uninit(pEngine: *mut ma_engine); ++} ++unsafe extern "C" { ++ pub fn ma_engine_read_pcm_frames( ++ pEngine: *mut ma_engine, ++ pFramesOut: *mut core::ffi::c_void, ++ frameCount: ma_uint64, ++ pFramesRead: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_node_graph(pEngine: *mut ma_engine) -> *mut ma_node_graph; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_resource_manager(pEngine: *mut ma_engine) -> *mut ma_resource_manager; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_device(pEngine: *mut ma_engine) -> *mut ma_device; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_log(pEngine: *mut ma_engine) -> *mut ma_log; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_endpoint(pEngine: *mut ma_engine) -> *mut ma_node; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_time_in_pcm_frames(pEngine: *const ma_engine) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_time_in_milliseconds(pEngine: *const ma_engine) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_time_in_pcm_frames( ++ pEngine: *mut ma_engine, ++ globalTime: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_time_in_milliseconds( ++ pEngine: *mut ma_engine, ++ globalTime: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_time(pEngine: *const ma_engine) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_time(pEngine: *mut ma_engine, globalTime: ma_uint64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_channels(pEngine: *const ma_engine) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_sample_rate(pEngine: *const ma_engine) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_start(pEngine: *mut ma_engine) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_stop(pEngine: *mut ma_engine) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_volume(pEngine: *mut ma_engine, volume: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_volume(pEngine: *mut ma_engine) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_set_gain_db(pEngine: *mut ma_engine, gainDB: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_gain_db(pEngine: *mut ma_engine) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_get_listener_count(pEngine: *const ma_engine) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_find_closest_listener( ++ pEngine: *const ma_engine, ++ absolutePosX: f32, ++ absolutePosY: f32, ++ absolutePosZ: f32, ++ ) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_position( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_position( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_direction( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_direction( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_velocity( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_velocity( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_cone( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_cone( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_world_up( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ x: f32, ++ y: f32, ++ z: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_get_world_up( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_set_enabled( ++ pEngine: *mut ma_engine, ++ listenerIndex: ma_uint32, ++ isEnabled: ma_bool32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_engine_listener_is_enabled( ++ pEngine: *const ma_engine, ++ listenerIndex: ma_uint32, ++ ) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_engine_play_sound_ex( ++ pEngine: *mut ma_engine, ++ pFilePath: *const core::ffi::c_char, ++ pNode: *mut ma_node, ++ nodeInputBusIndex: ma_uint32, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_engine_play_sound( ++ pEngine: *mut ma_engine, ++ pFilePath: *const core::ffi::c_char, ++ pGroup: *mut ma_sound_group, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_from_file( ++ pEngine: *mut ma_engine, ++ pFilePath: *const core::ffi::c_char, ++ flags: ma_uint32, ++ pGroup: *mut ma_sound_group, ++ pDoneFence: *mut ma_fence, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_from_file_w( ++ pEngine: *mut ma_engine, ++ pFilePath: *const wchar_t, ++ flags: ma_uint32, ++ pGroup: *mut ma_sound_group, ++ pDoneFence: *mut ma_fence, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_copy( ++ pEngine: *mut ma_engine, ++ pExistingSound: *const ma_sound, ++ flags: ma_uint32, ++ pGroup: *mut ma_sound_group, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_from_data_source( ++ pEngine: *mut ma_engine, ++ pDataSource: *mut ma_data_source, ++ flags: ma_uint32, ++ pGroup: *mut ma_sound_group, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_init_ex( ++ pEngine: *mut ma_engine, ++ pConfig: *const ma_sound_config, ++ pSound: *mut ma_sound, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_uninit(pSound: *mut ma_sound); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_engine(pSound: *const ma_sound) -> *mut ma_engine; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_data_source(pSound: *const ma_sound) -> *mut ma_data_source; ++} ++unsafe extern "C" { ++ pub fn ma_sound_start(pSound: *mut ma_sound) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_stop(pSound: *mut ma_sound) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_stop_with_fade_in_pcm_frames( ++ pSound: *mut ma_sound, ++ fadeLengthInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_stop_with_fade_in_milliseconds( ++ pSound: *mut ma_sound, ++ fadeLengthInFrames: ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_volume(pSound: *mut ma_sound, volume: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_volume(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_pan(pSound: *mut ma_sound, pan: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_pan(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_pan_mode(pSound: *mut ma_sound, panMode: ma_pan_mode); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_pan_mode(pSound: *const ma_sound) -> ma_pan_mode; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_pitch(pSound: *mut ma_sound, pitch: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_pitch(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_spatialization_enabled(pSound: *mut ma_sound, enabled: ma_bool32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_is_spatialization_enabled(pSound: *const ma_sound) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_pinned_listener_index(pSound: *mut ma_sound, listenerIndex: ma_uint32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_pinned_listener_index(pSound: *const ma_sound) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_listener_index(pSound: *const ma_sound) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_direction_to_listener(pSound: *const ma_sound) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_position(pSound: *mut ma_sound, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_position(pSound: *const ma_sound) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_direction(pSound: *mut ma_sound, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_direction(pSound: *const ma_sound) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_velocity(pSound: *mut ma_sound, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_velocity(pSound: *const ma_sound) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_attenuation_model( ++ pSound: *mut ma_sound, ++ attenuationModel: ma_attenuation_model, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_attenuation_model(pSound: *const ma_sound) -> ma_attenuation_model; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_positioning(pSound: *mut ma_sound, positioning: ma_positioning); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_positioning(pSound: *const ma_sound) -> ma_positioning; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_rolloff(pSound: *mut ma_sound, rolloff: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_rolloff(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_min_gain(pSound: *mut ma_sound, minGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_min_gain(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_max_gain(pSound: *mut ma_sound, maxGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_max_gain(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_min_distance(pSound: *mut ma_sound, minDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_min_distance(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_max_distance(pSound: *mut ma_sound, maxDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_max_distance(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_cone( ++ pSound: *mut ma_sound, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_cone( ++ pSound: *const ma_sound, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_doppler_factor(pSound: *mut ma_sound, dopplerFactor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_doppler_factor(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_directional_attenuation_factor( ++ pSound: *mut ma_sound, ++ directionalAttenuationFactor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_directional_attenuation_factor(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_fade_in_pcm_frames( ++ pSound: *mut ma_sound, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_fade_in_milliseconds( ++ pSound: *mut ma_sound, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_fade_start_in_pcm_frames( ++ pSound: *mut ma_sound, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInFrames: ma_uint64, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_fade_start_in_milliseconds( ++ pSound: *mut ma_sound, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInMilliseconds: ma_uint64, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_current_fade_volume(pSound: *const ma_sound) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_start_time_in_pcm_frames( ++ pSound: *mut ma_sound, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_start_time_in_milliseconds( ++ pSound: *mut ma_sound, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_stop_time_in_pcm_frames( ++ pSound: *mut ma_sound, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_stop_time_in_milliseconds( ++ pSound: *mut ma_sound, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_stop_time_with_fade_in_pcm_frames( ++ pSound: *mut ma_sound, ++ stopAbsoluteGlobalTimeInFrames: ma_uint64, ++ fadeLengthInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_stop_time_with_fade_in_milliseconds( ++ pSound: *mut ma_sound, ++ stopAbsoluteGlobalTimeInMilliseconds: ma_uint64, ++ fadeLengthInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_is_playing(pSound: *const ma_sound) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_time_in_pcm_frames(pSound: *const ma_sound) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_time_in_milliseconds(pSound: *const ma_sound) -> ma_uint64; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_looping(pSound: *mut ma_sound, isLooping: ma_bool32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_is_looping(pSound: *const ma_sound) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_at_end(pSound: *const ma_sound) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_seek_to_pcm_frame(pSound: *mut ma_sound, frameIndex: ma_uint64) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_seek_to_second(pSound: *mut ma_sound, seekPointInSeconds: f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_data_format( ++ pSound: *const ma_sound, ++ pFormat: *mut ma_format, ++ pChannels: *mut ma_uint32, ++ pSampleRate: *mut ma_uint32, ++ pChannelMap: *mut ma_channel, ++ channelMapCap: usize, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_cursor_in_pcm_frames( ++ pSound: *const ma_sound, ++ pCursor: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_length_in_pcm_frames( ++ pSound: *const ma_sound, ++ pLength: *mut ma_uint64, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_cursor_in_seconds(pSound: *const ma_sound, pCursor: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_get_length_in_seconds(pSound: *const ma_sound, pLength: *mut f32) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_set_end_callback( ++ pSound: *mut ma_sound, ++ callback: ma_sound_end_proc, ++ pUserData: *mut core::ffi::c_void, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_init( ++ pEngine: *mut ma_engine, ++ flags: ma_uint32, ++ pParentGroup: *mut ma_sound_group, ++ pGroup: *mut ma_sound_group, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_init_ex( ++ pEngine: *mut ma_engine, ++ pConfig: *const ma_sound_group_config, ++ pGroup: *mut ma_sound_group, ++ ) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_uninit(pGroup: *mut ma_sound_group); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_engine(pGroup: *const ma_sound_group) -> *mut ma_engine; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_start(pGroup: *mut ma_sound_group) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_stop(pGroup: *mut ma_sound_group) -> ma_result; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_volume(pGroup: *mut ma_sound_group, volume: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_volume(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_pan(pGroup: *mut ma_sound_group, pan: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_pan(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_pan_mode(pGroup: *mut ma_sound_group, panMode: ma_pan_mode); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_pan_mode(pGroup: *const ma_sound_group) -> ma_pan_mode; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_pitch(pGroup: *mut ma_sound_group, pitch: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_pitch(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_spatialization_enabled( ++ pGroup: *mut ma_sound_group, ++ enabled: ma_bool32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_is_spatialization_enabled(pGroup: *const ma_sound_group) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_pinned_listener_index( ++ pGroup: *mut ma_sound_group, ++ listenerIndex: ma_uint32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_pinned_listener_index(pGroup: *const ma_sound_group) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_listener_index(pGroup: *const ma_sound_group) -> ma_uint32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_direction_to_listener(pGroup: *const ma_sound_group) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_position(pGroup: *mut ma_sound_group, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_position(pGroup: *const ma_sound_group) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_direction(pGroup: *mut ma_sound_group, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_direction(pGroup: *const ma_sound_group) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_velocity(pGroup: *mut ma_sound_group, x: f32, y: f32, z: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_velocity(pGroup: *const ma_sound_group) -> ma_vec3f; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_attenuation_model( ++ pGroup: *mut ma_sound_group, ++ attenuationModel: ma_attenuation_model, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_attenuation_model( ++ pGroup: *const ma_sound_group, ++ ) -> ma_attenuation_model; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_positioning(pGroup: *mut ma_sound_group, positioning: ma_positioning); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_positioning(pGroup: *const ma_sound_group) -> ma_positioning; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_rolloff(pGroup: *mut ma_sound_group, rolloff: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_rolloff(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_min_gain(pGroup: *mut ma_sound_group, minGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_min_gain(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_max_gain(pGroup: *mut ma_sound_group, maxGain: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_max_gain(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_min_distance(pGroup: *mut ma_sound_group, minDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_min_distance(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_max_distance(pGroup: *mut ma_sound_group, maxDistance: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_max_distance(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_cone( ++ pGroup: *mut ma_sound_group, ++ innerAngleInRadians: f32, ++ outerAngleInRadians: f32, ++ outerGain: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_cone( ++ pGroup: *const ma_sound_group, ++ pInnerAngleInRadians: *mut f32, ++ pOuterAngleInRadians: *mut f32, ++ pOuterGain: *mut f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_doppler_factor(pGroup: *mut ma_sound_group, dopplerFactor: f32); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_doppler_factor(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_directional_attenuation_factor( ++ pGroup: *mut ma_sound_group, ++ directionalAttenuationFactor: f32, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_directional_attenuation_factor(pGroup: *const ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_fade_in_pcm_frames( ++ pGroup: *mut ma_sound_group, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_fade_in_milliseconds( ++ pGroup: *mut ma_sound_group, ++ volumeBeg: f32, ++ volumeEnd: f32, ++ fadeLengthInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_current_fade_volume(pGroup: *mut ma_sound_group) -> f32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_start_time_in_pcm_frames( ++ pGroup: *mut ma_sound_group, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_start_time_in_milliseconds( ++ pGroup: *mut ma_sound_group, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_stop_time_in_pcm_frames( ++ pGroup: *mut ma_sound_group, ++ absoluteGlobalTimeInFrames: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_set_stop_time_in_milliseconds( ++ pGroup: *mut ma_sound_group, ++ absoluteGlobalTimeInMilliseconds: ma_uint64, ++ ); ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_is_playing(pGroup: *const ma_sound_group) -> ma_bool32; ++} ++unsafe extern "C" { ++ pub fn ma_sound_group_get_time_in_pcm_frames(pGroup: *const ma_sound_group) -> ma_uint64; ++} ++pub type __builtin_va_list = [__va_list_tag; 1usize]; ++#[repr(C)] ++#[derive(Debug, Copy, Clone)] ++pub struct __va_list_tag { ++ pub gp_offset: core::ffi::c_uint, ++ pub fp_offset: core::ffi::c_uint, ++ pub overflow_arg_area: *mut core::ffi::c_void, ++ pub reg_save_area: *mut core::ffi::c_void, ++} ++#[allow(clippy::unnecessary_operation, clippy::identity_op)] ++const _: () = { ++ ["Size of __va_list_tag"][::core::mem::size_of::<__va_list_tag>() - 24usize]; ++ ["Alignment of __va_list_tag"][::core::mem::align_of::<__va_list_tag>() - 8usize]; ++ ["Offset of field: __va_list_tag::gp_offset"] ++ [::core::mem::offset_of!(__va_list_tag, gp_offset) - 0usize]; ++ ["Offset of field: __va_list_tag::fp_offset"] ++ [::core::mem::offset_of!(__va_list_tag, fp_offset) - 4usize]; ++ ["Offset of field: __va_list_tag::overflow_arg_area"] ++ [::core::mem::offset_of!(__va_list_tag, overflow_arg_area) - 8usize]; ++ ["Offset of field: __va_list_tag::reg_save_area"] ++ [::core::mem::offset_of!(__va_list_tag, reg_save_area) - 16usize]; ++}; diff --git a/crates/pi-voice/BUILD.bazel b/crates/pi-voice/BUILD.bazel index 0e45353d2..dd0033f88 100644 --- a/crates/pi-voice/BUILD.bazel +++ b/crates/pi-voice/BUILD.bazel @@ -27,3 +27,12 @@ rust_test( proc_macro_deps = all_crate_deps(proc_macro_dev = True), deps = all_crate_deps(normal_dev = True), ) + +# Direct C/Rust ABI comparison for miniaudio's opaque device state. This test +# needs the patched maudio-sys C probe, so it is intentionally Bazel-only. +rust_test( + name = "maudio_layout_test", + srcs = ["bazel/maudio_layout.rs"], + edition = "2024", + deps = ["@crates//:maudio"], +) diff --git a/crates/pi-voice/bazel/maudio_layout.rs b/crates/pi-voice/bazel/maudio_layout.rs new file mode 100644 index 000000000..267823f5d --- /dev/null +++ b/crates/pi-voice/bazel/maudio_layout.rs @@ -0,0 +1,39 @@ +use std::mem::{align_of, size_of}; + +use maudio::maudio_sys::ffi::{ma_context, ma_device, ma_mutex}; + +unsafe extern "C" { + fn omp_maudio_sizeof_mutex() -> usize; + fn omp_maudio_alignof_mutex() -> usize; + fn omp_maudio_sizeof_context() -> usize; + fn omp_maudio_alignof_context() -> usize; + fn omp_maudio_sizeof_device() -> usize; + fn omp_maudio_alignof_device() -> usize; +} + +fn c_layout( + size: unsafe extern "C" fn() -> usize, + align: unsafe extern "C" fn() -> usize, +) -> (usize, usize) { + // SAFETY: The patched maudio-sys C object defines both argument-free probes. + unsafe { (size(), align()) } +} + +#[test] +fn rust_bindings_match_compiled_miniaudio_layouts() { + assert_eq!( + (size_of::(), align_of::()), + c_layout(omp_maudio_sizeof_mutex, omp_maudio_alignof_mutex), + "ma_mutex Rust/C layout mismatch", + ); + assert_eq!( + (size_of::(), align_of::()), + c_layout(omp_maudio_sizeof_context, omp_maudio_alignof_context), + "ma_context Rust/C layout mismatch", + ); + assert_eq!( + (size_of::(), align_of::()), + c_layout(omp_maudio_sizeof_device, omp_maudio_alignof_device), + "ma_device Rust/C layout mismatch", + ); +} diff --git a/crates/pi-voice/src/audio.rs b/crates/pi-voice/src/audio.rs index abd025b6f..563abbdd0 100644 --- a/crates/pi-voice/src/audio.rs +++ b/crates/pi-voice/src/audio.rs @@ -374,6 +374,16 @@ mod tests { } } + #[test] + fn opt_in_default_playback_initializes_and_stops() { + if env::var_os("OMP_NATIVE_AUDIO_PLAYBACK_TEST").is_none() { + return; + } + + let mut stream = PlaybackStream::start(16_000).expect("default playback device starts"); + stream.stop().expect("default playback device stops"); + } + #[test] fn opt_in_default_capture_receives_frames() { if env::var_os("OMP_NATIVE_AUDIO_CAPTURE_TEST").is_none() { diff --git a/packages/natives/CHANGELOG.md b/packages/natives/CHANGELOG.md index ead6da3d9..550b7f234 100644 --- a/packages/natives/CHANGELOG.md +++ b/packages/natives/CHANGELOG.md @@ -2,6 +2,11 @@ ## [Unreleased] +### Fixed + +- Fixed `/live` corrupting the heap when opening PulseAudio on Linux ARM64 by shipping target-specific miniaudio Rust layouts for GNU and musl native addons. +- Fixed local Bazel addon builds on NixOS by exposing system CMake tools to sandboxed build scripts and forcing bundled Opus into the library directory expected by `audiopus_sys`. + ## [17.2.1] - 2026-07-30 ### Fixed