diff --git a/litert-sys/src/bindings/aarch64-unknown-linux-ohos.rs b/litert-sys/src/bindings/aarch64-unknown-linux-ohos.rs new file mode 100644 index 0000000..3a5b0d4 --- /dev/null +++ b/litert-sys/src/bindings/aarch64-unknown-linux-ohos.rs @@ -0,0 +1,3165 @@ +/* automatically generated by rust-bindgen 0.69.5 */ + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { + *byte |= mask; + } else { + *byte &= !mask; + } + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } +} +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData, [T; 0]); +impl __IncompleteArrayField { + #[inline] + pub const fn new() -> Self { + __IncompleteArrayField(::std::marker::PhantomData, []) + } + #[inline] + pub fn as_ptr(&self) -> *const T { + self as *const _ as *const T + } + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + self as *mut _ as *mut T + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + ::std::slice::from_raw_parts(self.as_ptr(), len) + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) + } +} +impl ::std::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + fmt.write_str("__IncompleteArrayField") + } +} +pub const LITERT_HAS_SYNC_FENCE_SUPPORT: u32 = 1; +pub const LITERT_HAS_AHWB_SUPPORT_DEFAULT: u32 = 0; +pub const LITERT_HAS_OPENGL_SUPPORT_DEFAULT: u32 = 0; +pub const LITERT_HAS_ION_SUPPORT_DEFAULT: u32 = 0; +pub const LITERT_HAS_DMABUF_SUPPORT_DEFAULT: u32 = 0; +pub const LITERT_HAS_FASTRPC_SUPPORT_DEFAULT: u32 = 0; +pub const LITERT_HAS_METAL_SUPPORT_DEFAULT: u32 = 0; +pub const LITERT_HAS_OPENCL_SUPPORT_DEFAULT: u32 = 1; +pub const LITERT_HAS_VULKAN_SUPPORT_DEFAULT: u32 = 1; +pub const LITERT_HAS_WEBGPU_SUPPORT_DEFAULT: u32 = 1; +pub const LITERT_HAS_METAL_SUPPORT: u32 = 0; +pub const LITERT_HAS_OPENCL_SUPPORT: u32 = 1; +pub const LITERT_HAS_WEBGPU_SUPPORT: u32 = 1; +pub const LITERT_HAS_VULKAN_SUPPORT: u32 = 1; +pub const LITERT_HAS_OPENGL_SUPPORT: u32 = 0; +pub const LITERT_HAS_AHWB_SUPPORT: u32 = 0; +pub const LITERT_HAS_ION_SUPPORT: u32 = 0; +pub const LITERT_HAS_DMABUF_SUPPORT: u32 = 0; +pub const LITERT_HAS_FASTRPC_SUPPORT: u32 = 0; +pub const LITERT_API_VERSION_MAJOR: u32 = 0; +pub const LITERT_API_VERSION_MINOR: u32 = 1; +pub const LITERT_API_VERSION_PATCH: u32 = 0; +pub const LITERT_TENSOR_MAX_RANK: u32 = 8; +pub const LITERT_HOST_MEMORY_BUFFER_ALIGNMENT: u32 = 64; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtAcceleratorT { + _unused: [u8; 0], +} +pub type LiteRtAccelerator = *mut LiteRtAcceleratorT; +pub type LiteRtAcceleratorConst = *const LiteRtAcceleratorT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtDelegateWrapperT { + _unused: [u8; 0], +} +pub type LiteRtDelegateWrapper = *mut LiteRtDelegateWrapperT; +pub type LiteRtDelegateWrapperConst = *const LiteRtDelegateWrapperT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtCompiledModelT { + _unused: [u8; 0], +} +pub type LiteRtCompiledModel = *mut LiteRtCompiledModelT; +pub type LiteRtCompiledModelConst = *const LiteRtCompiledModelT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtEnvironmentT { + _unused: [u8; 0], +} +pub type LiteRtEnvironment = *mut LiteRtEnvironmentT; +pub type LiteRtEnvironmentConst = *const LiteRtEnvironmentT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtEnvironmentOptionsT { + _unused: [u8; 0], +} +pub type LiteRtEnvironmentOptions = *mut LiteRtEnvironmentOptionsT; +pub type LiteRtEnvironmentOptionsConst = *const LiteRtEnvironmentOptionsT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtEventT { + _unused: [u8; 0], +} +pub type LiteRtEvent = *mut LiteRtEventT; +pub type LiteRtEventConst = *const LiteRtEventT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtLoggerT { + _unused: [u8; 0], +} +pub type LiteRtLogger = *mut LiteRtLoggerT; +pub type LiteRtLoggerConst = *const LiteRtLoggerT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtMetricsT { + _unused: [u8; 0], +} +pub type LiteRtMetrics = *mut LiteRtMetricsT; +pub type LiteRtMetricsConst = *const LiteRtMetricsT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtWeightsT { + _unused: [u8; 0], +} +pub type LiteRtWeights = *mut LiteRtWeightsT; +pub type LiteRtWeightsConst = *const LiteRtWeightsT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtTensorT { + _unused: [u8; 0], +} +pub type LiteRtTensor = *mut LiteRtTensorT; +pub type LiteRtTensorConst = *const LiteRtTensorT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtOpT { + _unused: [u8; 0], +} +pub type LiteRtOp = *mut LiteRtOpT; +pub type LiteRtOpConst = *const LiteRtOpT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtSubgraphT { + _unused: [u8; 0], +} +pub type LiteRtSubgraph = *mut LiteRtSubgraphT; +pub type LiteRtSubgraphConst = *const LiteRtSubgraphT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtSignatureT { + _unused: [u8; 0], +} +pub type LiteRtSignature = *mut LiteRtSignatureT; +pub type LiteRtSignatureConst = *const LiteRtSignatureT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtModelT { + _unused: [u8; 0], +} +pub type LiteRtModel = *mut LiteRtModelT; +pub type LiteRtModelConst = *const LiteRtModelT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtOpListT { + _unused: [u8; 0], +} +pub type LiteRtOpList = *mut LiteRtOpListT; +pub type LiteRtOpListConst = *const LiteRtOpListT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtBuilderT { + _unused: [u8; 0], +} +pub type LiteRtBuilder = *mut LiteRtBuilderT; +pub type LiteRtBuilderConst = *const LiteRtBuilderT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtOpaqueOptionsT { + _unused: [u8; 0], +} +pub type LiteRtOpaqueOptions = *mut LiteRtOpaqueOptionsT; +pub type LiteRtOpaqueOptionsConst = *const LiteRtOpaqueOptionsT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtOptionsT { + _unused: [u8; 0], +} +pub type LiteRtOptions = *mut LiteRtOptionsT; +pub type LiteRtOptionsConst = *const LiteRtOptionsT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtTensorBufferT { + _unused: [u8; 0], +} +pub type LiteRtTensorBuffer = *mut LiteRtTensorBufferT; +pub type LiteRtTensorBufferConst = *const LiteRtTensorBufferT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtTensorBufferRequirementsT { + _unused: [u8; 0], +} +pub type LiteRtTensorBufferRequirements = *mut LiteRtTensorBufferRequirementsT; +pub type LiteRtTensorBufferRequirementsConst = *const LiteRtTensorBufferRequirementsT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtProfilerT { + _unused: [u8; 0], +} +pub type LiteRtProfiler = *mut LiteRtProfilerT; +pub type LiteRtProfilerConst = *const LiteRtProfilerT; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtExternalLiteRtBufferContextT { + _unused: [u8; 0], +} +pub type LiteRtExternalLiteRtBufferContext = *mut LiteRtExternalLiteRtBufferContextT; +pub type LiteRtExternalLiteRtBufferContextConst = *const LiteRtExternalLiteRtBufferContextT; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct LiteRtApiVersion { + pub major: ::std::os::raw::c_int, + pub minor: ::std::os::raw::c_int, + pub patch: ::std::os::raw::c_int, +} +extern "C" { + pub fn LiteRtCompareApiVersion( + version: LiteRtApiVersion, + reference: LiteRtApiVersion, + ) -> ::std::os::raw::c_int; +} +pub const kLiteRtStatusOk: LiteRtStatus = 0; +pub const kLiteRtStatusErrorInvalidArgument: LiteRtStatus = 1; +pub const kLiteRtStatusErrorMemoryAllocationFailure: LiteRtStatus = 2; +pub const kLiteRtStatusErrorRuntimeFailure: LiteRtStatus = 3; +pub const kLiteRtStatusErrorMissingInputTensor: LiteRtStatus = 4; +pub const kLiteRtStatusErrorUnsupported: LiteRtStatus = 5; +pub const kLiteRtStatusErrorNotFound: LiteRtStatus = 6; +pub const kLiteRtStatusErrorTimeoutExpired: LiteRtStatus = 7; +pub const kLiteRtStatusErrorWrongVersion: LiteRtStatus = 8; +pub const kLiteRtStatusErrorUnknown: LiteRtStatus = 9; +pub const kLiteRtStatusErrorAlreadyExists: LiteRtStatus = 10; +pub const kLiteRtStatusCancelled: LiteRtStatus = 100; +pub const kLiteRtStatusErrorFileIO: LiteRtStatus = 500; +pub const kLiteRtStatusErrorInvalidFlatbuffer: LiteRtStatus = 501; +pub const kLiteRtStatusErrorDynamicLoading: LiteRtStatus = 502; +pub const kLiteRtStatusErrorSerialization: LiteRtStatus = 503; +pub const kLiteRtStatusErrorCompilation: LiteRtStatus = 504; +pub const kLiteRtStatusErrorIndexOOB: LiteRtStatus = 1000; +pub const kLiteRtStatusErrorInvalidIrType: LiteRtStatus = 1001; +pub const kLiteRtStatusErrorInvalidGraphInvariant: LiteRtStatus = 1002; +pub const kLiteRtStatusErrorGraphModification: LiteRtStatus = 1003; +pub const kLiteRtStatusErrorInvalidToolConfig: LiteRtStatus = 1500; +pub const kLiteRtStatusLegalizeNoMatch: LiteRtStatus = 2000; +pub const kLiteRtStatusErrorInvalidLegalization: LiteRtStatus = 2001; +pub const kLiteRtStatusPatternNoMatch: LiteRtStatus = 3000; +pub const kLiteRtStatusInvalidTransformation: LiteRtStatus = 3001; +pub const kLiteRtStatusErrorUnsupportedRuntimeVersion: LiteRtStatus = 4000; +pub const kLiteRtStatusErrorUnsupportedCompilerVersion: LiteRtStatus = 4001; +pub const kLiteRtStatusErrorIncompatibleByteCodeVersion: LiteRtStatus = 4002; +pub const kLiteRtStatusErrorUnsupportedOpShapeInferer: LiteRtStatus = 5000; +pub const kLiteRtStatusErrorShapeInferenceFailed: LiteRtStatus = 5001; +pub type LiteRtStatus = ::std::os::raw::c_uint; +extern "C" { + pub fn LiteRtGetStatusString(status: LiteRtStatus) -> *const ::std::os::raw::c_char; +} +pub const kLiteRtHwAcceleratorNone: LiteRtHwAccelerators = 0; +pub const kLiteRtHwAcceleratorCpu: LiteRtHwAccelerators = 1; +pub const kLiteRtHwAcceleratorGpu: LiteRtHwAccelerators = 2; +pub const kLiteRtHwAcceleratorNpu: LiteRtHwAccelerators = 4; +pub type LiteRtHwAccelerators = ::std::os::raw::c_int; +pub const kLiteRtDelegatePrecisionDefault: LiteRtDelegatePrecision = 0; +pub const kLiteRtDelegatePrecisionFp16: LiteRtDelegatePrecision = 1; +pub const kLiteRtDelegatePrecisionFp32: LiteRtDelegatePrecision = 2; +pub type LiteRtDelegatePrecision = ::std::os::raw::c_uint; +pub const kLiteRtGpuPriorityDefault: LiteRtGpuPriority = 0; +pub const kLiteRtGpuPriorityLow: LiteRtGpuPriority = 1; +pub const kLiteRtGpuPriorityNormal: LiteRtGpuPriority = 2; +pub const kLiteRtGpuPriorityHigh: LiteRtGpuPriority = 3; +pub type LiteRtGpuPriority = ::std::os::raw::c_uint; +pub const kLiteRtDelegateBufferStorageTypeDefault: LiteRtDelegateBufferStorageType = 0; +pub const kLiteRtDelegateBufferStorageTypeBuffer: LiteRtDelegateBufferStorageType = 1; +pub const kLiteRtDelegateBufferStorageTypeTexture2D: LiteRtDelegateBufferStorageType = 2; +pub type LiteRtDelegateBufferStorageType = ::std::os::raw::c_uint; +pub const kLiteRtTensorBufferLockModeRead: LiteRtTensorBufferLockMode = 0; +pub const kLiteRtTensorBufferLockModeWrite: LiteRtTensorBufferLockMode = 1; +pub const kLiteRtTensorBufferLockModeReadWrite: LiteRtTensorBufferLockMode = 2; +pub type LiteRtTensorBufferLockMode = ::std::os::raw::c_uint; +pub const kLiteRtGpuBackendAutomatic: LiteRtGpuBackend = 0; +pub const kLiteRtGpuBackendOpenCl: LiteRtGpuBackend = 1; +pub const kLiteRtGpuBackendWebGpu: LiteRtGpuBackend = 2; +pub const kLiteRtGpuBackendOpenGl: LiteRtGpuBackend = 3; +pub type LiteRtGpuBackend = ::std::os::raw::c_uint; +pub const kLiteRtGpuWaitTypeDefault: LiteRtGpuWaitType = 0; +pub const kLiteRtGpuWaitTypePassive: LiteRtGpuWaitType = 1; +pub const kLiteRtGpuWaitTypeActive: LiteRtGpuWaitType = 2; +pub const kLiteRtGpuWaitTypeDoNotWait: LiteRtGpuWaitType = 3; +pub type LiteRtGpuWaitType = ::std::os::raw::c_uint; +pub const kLiteRtErrorReporterModeNone: LiteRtErrorReporterMode = 0; +pub const kLiteRtErrorReporterModeStderr: LiteRtErrorReporterMode = 1; +pub const kLiteRtErrorReporterModeBuffer: LiteRtErrorReporterMode = 2; +pub type LiteRtErrorReporterMode = ::std::os::raw::c_uint; +pub type LiteRtHwAcceleratorSet = ::std::os::raw::c_int; +pub type LiteRtParamIndex = usize; +pub const kLiteRtAnyTypeNone: LiteRtAnyType = 0; +pub const kLiteRtAnyTypeBool: LiteRtAnyType = 1; +pub const kLiteRtAnyTypeInt: LiteRtAnyType = 2; +pub const kLiteRtAnyTypeReal: LiteRtAnyType = 3; +pub const kLiteRtAnyTypeString: LiteRtAnyType = 8; +pub const kLiteRtAnyTypeVoidPtr: LiteRtAnyType = 9; +pub type LiteRtAnyType = ::std::os::raw::c_uint; +#[doc = " An object that holds various value type.\n\n @note This concrete type is part of the public API and is ABI stable."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct LiteRtAny { + pub type_: LiteRtAnyType, + pub __bindgen_anon_1: LiteRtAny__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union LiteRtAny__bindgen_ty_1 { + pub bool_value: bool, + pub int_value: i64, + pub real_value: f64, + pub str_value: *const ::std::os::raw::c_char, + pub ptr_value: *const ::std::os::raw::c_void, +} +impl Default for LiteRtAny__bindgen_ty_1 { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +impl Default for LiteRtAny { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[doc = " The shape information for tensor types of fixed rank.\n\n @note This concrete type is part of the public API and is ABI stable."] +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct LiteRtLayout { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub dimensions: [i32; 8usize], + pub strides: [u32; 8usize], +} +impl LiteRtLayout { + #[inline] + pub fn rank(&self) -> ::std::os::raw::c_uint { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 7u8) as u32) } + } + #[inline] + pub fn set_rank(&mut self, val: ::std::os::raw::c_uint) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 7u8, val as u64) + } + } + #[inline] + pub fn has_strides(&self) -> bool { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) } + } + #[inline] + pub fn set_has_strides(&mut self, val: bool) { + unsafe { + let val: u8 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + rank: ::std::os::raw::c_uint, + has_strides: bool, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 7u8, { + let rank: u32 = unsafe { ::std::mem::transmute(rank) }; + rank as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let has_strides: u8 = unsafe { ::std::mem::transmute(has_strides) }; + has_strides as u64 + }); + __bindgen_bitfield_unit + } +} +extern "C" { + pub fn LiteRtGetNumLayoutElements( + layout: *const LiteRtLayout, + num_elements: *mut usize, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtIsSameLayout( + layout1: *const LiteRtLayout, + layout2: *const LiteRtLayout, + result: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorName( + tensor: LiteRtTensor, + name: *mut *const ::std::os::raw::c_char, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorIndex(tensor: LiteRtTensor, tensor_index: *mut u32) -> LiteRtStatus; +} +pub const kLiteRtElementTypeNone: LiteRtElementType = 0; +pub const kLiteRtElementTypeBool: LiteRtElementType = 6; +pub const kLiteRtElementTypeInt2: LiteRtElementType = 20; +pub const kLiteRtElementTypeInt4: LiteRtElementType = 18; +pub const kLiteRtElementTypeInt8: LiteRtElementType = 9; +pub const kLiteRtElementTypeInt16: LiteRtElementType = 7; +pub const kLiteRtElementTypeInt32: LiteRtElementType = 2; +pub const kLiteRtElementTypeInt64: LiteRtElementType = 4; +pub const kLiteRtElementTypeUInt8: LiteRtElementType = 3; +pub const kLiteRtElementTypeUInt16: LiteRtElementType = 17; +pub const kLiteRtElementTypeUInt32: LiteRtElementType = 16; +pub const kLiteRtElementTypeUInt64: LiteRtElementType = 13; +pub const kLiteRtElementTypeFloat16: LiteRtElementType = 10; +pub const kLiteRtElementTypeBFloat16: LiteRtElementType = 19; +pub const kLiteRtElementTypeFloat32: LiteRtElementType = 1; +pub const kLiteRtElementTypeFloat64: LiteRtElementType = 11; +pub const kLiteRtElementTypeComplex64: LiteRtElementType = 8; +pub const kLiteRtElementTypeComplex128: LiteRtElementType = 12; +pub const kLiteRtElementTypeTfResource: LiteRtElementType = 14; +pub const kLiteRtElementTypeTfString: LiteRtElementType = 5; +pub const kLiteRtElementTypeTfVariant: LiteRtElementType = 15; +pub type LiteRtElementType = ::std::os::raw::c_uint; +#[doc = " Tensor type when its rank is dynamic.\n\n @note This concrete type is part of the public API and is ABI stable."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtUnrankedTensorType { + pub element_type: LiteRtElementType, +} +impl Default for LiteRtUnrankedTensorType { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[doc = " Tensor type when its rank is static but dimensions may be dynamic.\n\n @note This concrete type is part of the public API and is ABI stable."] +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtRankedTensorType { + pub element_type: LiteRtElementType, + pub layout: LiteRtLayout, +} +impl Default for LiteRtRankedTensorType { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub const kLiteRtRankedTensorType: LiteRtTensorTypeId = 0; +pub const kLiteRtUnrankedTensorType: LiteRtTensorTypeId = 1; +pub type LiteRtTensorTypeId = ::std::os::raw::c_uint; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct LiteRtQuantizationPerTensor { + pub scale: f32, + pub zero_point: i64, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtQuantizationPerChannel { + pub quantized_dimension: i32, + pub num_channels: u64, + pub scales: *mut f32, + pub zero_points: *mut i64, +} +impl Default for LiteRtQuantizationPerChannel { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub const kLiteRtQuantizationNone: LiteRtQuantizationTypeId = 0; +pub const kLiteRtQuantizationPerTensor: LiteRtQuantizationTypeId = 1; +pub const kLiteRtQuantizationPerChannel: LiteRtQuantizationTypeId = 2; +pub const kLiteRtQuantizationBlockWise: LiteRtQuantizationTypeId = 3; +pub type LiteRtQuantizationTypeId = ::std::os::raw::c_uint; +extern "C" { + pub fn LiteRtGetQuantizationTypeId( + tensor: LiteRtTensor, + q_type_id: *mut LiteRtQuantizationTypeId, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetPerTensorQuantization( + tensor: LiteRtTensor, + per_tensor_quantization: *mut LiteRtQuantizationPerTensor, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetPerChannelQuantization( + tensor: LiteRtTensor, + per_channel_quantization: *mut LiteRtQuantizationPerChannel, + ) -> LiteRtStatus; +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtTensorDefiningOp { + pub op: LiteRtOp, + pub op_output_index: LiteRtParamIndex, +} +impl Default for LiteRtTensorDefiningOp { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtTensorUserOp { + pub op: LiteRtOp, + pub op_input_index: LiteRtParamIndex, +} +impl Default for LiteRtTensorUserOp { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct LiteRtModelSerializationOptions { + pub bytecode_alignment: usize, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct AHardwareBuffer { + _unused: [u8; 0], +} +pub type LiteRtHostMemoryDeallocator = + ::std::option::Option; +pub type LiteRtAhwbDeallocator = + ::std::option::Option; +pub type LiteRtIonDeallocator = + ::std::option::Option; +pub type LiteRtDmaBufDeallocator = + ::std::option::Option; +pub type LiteRtFastRpcDeallocator = + ::std::option::Option; +pub type LiteRtOpenClDeallocator = + ::std::option::Option; +pub type LiteRtGlBufferDeallocator = + ::std::option::Option; +pub type LiteRtGlTextureDeallocator = + ::std::option::Option; +pub type LiteRtWebGpuBufferDeallocator = + ::std::option::Option; +pub type LiteRtWebGpuTextureDeallocator = + ::std::option::Option; +pub type LiteRtMetalDeallocator = + ::std::option::Option; +pub type LiteRtVulkanMemoryDeallocator = + ::std::option::Option; +pub const kLiteRtTensorBufferTypeUnknown: LiteRtTensorBufferType = 0; +pub const kLiteRtTensorBufferTypeHostMemory: LiteRtTensorBufferType = 1; +pub const kLiteRtTensorBufferTypeAhwb: LiteRtTensorBufferType = 2; +pub const kLiteRtTensorBufferTypeIon: LiteRtTensorBufferType = 3; +pub const kLiteRtTensorBufferTypeDmaBuf: LiteRtTensorBufferType = 4; +pub const kLiteRtTensorBufferTypeFastRpc: LiteRtTensorBufferType = 5; +pub const kLiteRtTensorBufferTypeGlBuffer: LiteRtTensorBufferType = 6; +pub const kLiteRtTensorBufferTypeGlTexture: LiteRtTensorBufferType = 7; +pub const kLiteRtTensorBufferTypeOpenClBuffer: LiteRtTensorBufferType = 10; +pub const kLiteRtTensorBufferTypeOpenClBufferFp16: LiteRtTensorBufferType = 11; +pub const kLiteRtTensorBufferTypeOpenClTexture: LiteRtTensorBufferType = 12; +pub const kLiteRtTensorBufferTypeOpenClTextureFp16: LiteRtTensorBufferType = 13; +pub const kLiteRtTensorBufferTypeOpenClBufferPacked: LiteRtTensorBufferType = 14; +pub const kLiteRtTensorBufferTypeOpenClImageBuffer: LiteRtTensorBufferType = 15; +pub const kLiteRtTensorBufferTypeOpenClImageBufferFp16: LiteRtTensorBufferType = 16; +pub const kLiteRtTensorBufferTypeWebGpuBuffer: LiteRtTensorBufferType = 20; +pub const kLiteRtTensorBufferTypeWebGpuBufferFp16: LiteRtTensorBufferType = 21; +pub const kLiteRtTensorBufferTypeWebGpuTexture: LiteRtTensorBufferType = 22; +pub const kLiteRtTensorBufferTypeWebGpuTextureFp16: LiteRtTensorBufferType = 23; +pub const kLiteRtTensorBufferTypeWebGpuImageBuffer: LiteRtTensorBufferType = 24; +pub const kLiteRtTensorBufferTypeWebGpuImageBufferFp16: LiteRtTensorBufferType = 25; +pub const kLiteRtTensorBufferTypeWebGpuBufferPacked: LiteRtTensorBufferType = 26; +pub const kLiteRtTensorBufferTypeMetalBuffer: LiteRtTensorBufferType = 30; +pub const kLiteRtTensorBufferTypeMetalBufferFp16: LiteRtTensorBufferType = 31; +pub const kLiteRtTensorBufferTypeMetalTexture: LiteRtTensorBufferType = 32; +pub const kLiteRtTensorBufferTypeMetalTextureFp16: LiteRtTensorBufferType = 33; +pub const kLiteRtTensorBufferTypeMetalBufferPacked: LiteRtTensorBufferType = 34; +pub const kLiteRtTensorBufferTypeVulkanBuffer: LiteRtTensorBufferType = 40; +pub const kLiteRtTensorBufferTypeVulkanBufferFp16: LiteRtTensorBufferType = 41; +pub const kLiteRtTensorBufferTypeVulkanTexture: LiteRtTensorBufferType = 42; +pub const kLiteRtTensorBufferTypeVulkanTextureFp16: LiteRtTensorBufferType = 43; +pub const kLiteRtTensorBufferTypeVulkanImageBuffer: LiteRtTensorBufferType = 44; +pub const kLiteRtTensorBufferTypeVulkanImageBufferFp16: LiteRtTensorBufferType = 45; +pub const kLiteRtTensorBufferTypeVulkanBufferPacked: LiteRtTensorBufferType = 46; +pub const kLiteRtTensorBufferTypeUserCustomBuffer: LiteRtTensorBufferType = 100; +pub const kLiteRtTensorBufferTypeOpenVINOTensorBuffer: LiteRtTensorBufferType = 100; +pub const kLiteRtTensorBufferTypeUserCustomBufferEnd: LiteRtTensorBufferType = 199; +pub type LiteRtTensorBufferType = ::std::os::raw::c_uint; +pub type LiteRtGpuDeviceId = *mut ::std::os::raw::c_void; +pub type LiteRtGpuQueueId = *mut ::std::os::raw::c_void; +pub type HwMemoryHandle = *mut ::std::os::raw::c_void; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct HwMemoryInfo { + pub memory_handle: HwMemoryHandle, + pub raw_handle: *mut ::std::os::raw::c_void, +} +impl Default for HwMemoryInfo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type HwMemoryInfoPtr = *mut HwMemoryInfo; +pub type CreateCustomTensorBuffer = ::std::option::Option< + unsafe extern "C" fn( + device_id: LiteRtGpuDeviceId, + queue_id: LiteRtGpuQueueId, + tensor_type: *const LiteRtRankedTensorType, + buffer_type: LiteRtTensorBufferType, + bytes: usize, + packed_bytes: usize, + hw_memory_info: *mut HwMemoryInfoPtr, + ) -> LiteRtStatus, +>; +pub type ImportCustomTensorBuffer = ::std::option::Option< + unsafe extern "C" fn( + device_id: LiteRtGpuDeviceId, + queue_id: LiteRtGpuQueueId, + tensor_type: *const LiteRtRankedTensorType, + buffer_type: LiteRtTensorBufferType, + hw_buffer_handle: HwMemoryHandle, + bytes: usize, + packed_bytes: usize, + hw_memory_info: *mut HwMemoryInfoPtr, + ) -> LiteRtStatus, +>; +pub type DestroyCustomTensorBuffer = + ::std::option::Option LiteRtStatus>; +pub type LockCustomTensorBuffer = ::std::option::Option< + unsafe extern "C" fn( + hw_memory_info: HwMemoryInfoPtr, + mode: LiteRtTensorBufferLockMode, + host_memory_ptr: *mut *mut ::std::os::raw::c_void, + ) -> LiteRtStatus, +>; +pub type UnlockCustomTensorBuffer = + ::std::option::Option LiteRtStatus>; +pub type ClearCustomTensorBuffer = + ::std::option::Option LiteRtStatus>; +pub const kLiteRtEnvOptionTagCompilerPluginLibraryDir: LiteRtEnvOptionTag = 0; +pub const kLiteRtEnvOptionTagDispatchLibraryDir: LiteRtEnvOptionTag = 1; +pub const kLiteRtEnvOptionTagOpenClDeviceId: LiteRtEnvOptionTag = 2; +pub const kLiteRtEnvOptionTagOpenClPlatformId: LiteRtEnvOptionTag = 3; +pub const kLiteRtEnvOptionTagOpenClContext: LiteRtEnvOptionTag = 4; +pub const kLiteRtEnvOptionTagOpenClCommandQueue: LiteRtEnvOptionTag = 5; +pub const kLiteRtEnvOptionTagEglDisplay: LiteRtEnvOptionTag = 6; +pub const kLiteRtEnvOptionTagEglContext: LiteRtEnvOptionTag = 7; +pub const kLiteRtEnvOptionTagWebGpuDevice: LiteRtEnvOptionTag = 8; +pub const kLiteRtEnvOptionTagWebGpuQueue: LiteRtEnvOptionTag = 9; +pub const kLiteRtEnvOptionTagMetalDevice: LiteRtEnvOptionTag = 10; +pub const kLiteRtEnvOptionTagMetalCommandQueue: LiteRtEnvOptionTag = 11; +pub const kLiteRtEnvOptionTagVulkanEnvironment: LiteRtEnvOptionTag = 12; +pub const kLiteRtEnvOptionTagCallbackOnGpuEnvDestroy: LiteRtEnvOptionTag = 14; +pub const kLiteRtEnvOptionTagCallbackUserDataOnGpuEnvDestroy: LiteRtEnvOptionTag = 15; +pub const kLiteRtEnvOptionTagMagicNumberConfigs: LiteRtEnvOptionTag = 16; +pub const kLiteRtEnvOptionTagMagicNumberVerifications: LiteRtEnvOptionTag = 17; +pub const kLiteRtEnvOptionTagCompilerCacheDir: LiteRtEnvOptionTag = 18; +pub const kLiteRtEnvOptionTagWebGpuInstance: LiteRtEnvOptionTag = 19; +pub const kLiteRtEnvOptionTagWebGpuProcs: LiteRtEnvOptionTag = 20; +pub const kLiteRtEnvOptionTagCustomTensorBufferHandlers_deprecated: LiteRtEnvOptionTag = 21; +pub const kLiteRtEnvOptionTagRuntimeLibraryDir: LiteRtEnvOptionTag = 22; +#[doc = " \\internal This is for internal use only, for a custom runtime."] +pub const kLiteRtEnvOptionTagSystemRuntimeHandle: LiteRtEnvOptionTag = 23; +#[doc = " \\internal This is for internal use only, for a custom runtime."] +pub const kLiteRtEnvOptionTagAutoRegisterAccelerators: LiteRtEnvOptionTag = 24; +#[doc = " \\internal This is for internal use only, for a custom runtime."] +pub const kLiteRtEnvOptionTagMinLoggerSeverity: LiteRtEnvOptionTag = 25; +#[doc = " \\internal This is for internal use only, for a custom runtime."] +pub const kLiteRtEnvOptionTagNull: LiteRtEnvOptionTag = 255; +pub type LiteRtEnvOptionTag = ::std::os::raw::c_uint; +#[doc = " An object that holds option data for the LiteRtEnvironment.\n\n @note This concrete type is part of the public API and is ABI stable."] +#[repr(C)] +#[derive(Copy, Clone)] +pub struct LiteRtEnvOption { + pub tag: LiteRtEnvOptionTag, + pub value: LiteRtAny, +} +impl Default for LiteRtEnvOption { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtMagicNumberConfig { + pub magic_number: i64, + pub target_number: i64, + pub signature_prefix: *const ::std::os::raw::c_char, +} +impl Default for LiteRtMagicNumberConfig { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug)] +pub struct LiteRtMagicNumberConfigs { + pub num_configs: i64, + pub configs: __IncompleteArrayField, +} +impl Default for LiteRtMagicNumberConfigs { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtMagicNumberVerification { + pub signature: *const ::std::os::raw::c_char, + pub test_signature: *const ::std::os::raw::c_char, + pub is_superset: bool, +} +impl Default for LiteRtMagicNumberVerification { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug)] +pub struct LiteRtMagicNumberVerifications { + pub num_verifications: i64, + pub verifications: __IncompleteArrayField, +} +impl Default for LiteRtMagicNumberVerifications { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct LiteRtCustomTensorBufferHandlers { + pub create_func: CreateCustomTensorBuffer, + pub destroy_func: DestroyCustomTensorBuffer, + pub lock_func: LockCustomTensorBuffer, + pub unlock_func: UnlockCustomTensorBuffer, + pub clear_func: ClearCustomTensorBuffer, + pub import_func: ImportCustomTensorBuffer, +} +extern "C" { + pub fn LiteRtGetEnvironmentOptionsValue( + options: LiteRtEnvironmentOptions, + tag: LiteRtEnvOptionTag, + value: *mut LiteRtAny, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtSetEnvironmentOptionsValue( + options: LiteRtEnvironmentOptions, + env_option: LiteRtEnvOption, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateEnvironment( + num_options: ::std::os::raw::c_int, + options: *const LiteRtEnvOption, + environment: *mut LiteRtEnvironment, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtDestroyEnvironment(environment: LiteRtEnvironment); +} +extern "C" { + pub fn LiteRtGetEnvironmentOptions( + environment: LiteRtEnvironment, + options: *mut LiteRtEnvironmentOptions, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtAddEnvironmentOptions( + environment: LiteRtEnvironment, + num_options: ::std::os::raw::c_int, + options: *const LiteRtEnvOption, + overwrite: bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGpuEnvironmentCreate( + environment: LiteRtEnvironment, + num_options: ::std::os::raw::c_int, + options: *const LiteRtEnvOption, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtEnvironmentSupportsClGlInterop( + environment: LiteRtEnvironment, + is_supported: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtEnvironmentSupportsAhwbClInterop( + environment: LiteRtEnvironment, + is_supported: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtEnvironmentSupportsAhwbGlInterop( + environment: LiteRtEnvironment, + is_supported: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtEnvironmentHasGpuEnvironment( + environment: LiteRtEnvironment, + has_gpu_environment: *mut bool, + ); +} +extern "C" { + pub fn LiteRtCreateOpaqueOptions( + payload_identifier: *const ::std::os::raw::c_char, + payload_data: *mut ::std::os::raw::c_void, + payload_destructor: ::std::option::Option< + unsafe extern "C" fn(payload_data: *mut ::std::os::raw::c_void), + >, + options: *mut LiteRtOpaqueOptions, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtDestroyOpaqueOptions(options: LiteRtOpaqueOptions); +} +extern "C" { + pub fn LiteRtGetOpaqueOptionsIdentifier( + options: LiteRtOpaqueOptions, + payload_identifier: *mut *const ::std::os::raw::c_char, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetOpaqueOptionsData( + options: LiteRtOpaqueOptions, + payload_data: *mut *mut ::std::os::raw::c_void, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtFindOpaqueOptionsData( + options: LiteRtOpaqueOptions, + payload_identifier: *const ::std::os::raw::c_char, + payload_data: *mut *mut ::std::os::raw::c_void, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetNextOpaqueOptions(options: *mut LiteRtOpaqueOptions) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtAppendOpaqueOptions( + options: *mut LiteRtOpaqueOptions, + appended_options: LiteRtOpaqueOptions, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtPopOpaqueOptions(options: *mut LiteRtOpaqueOptions) -> LiteRtStatus; +} +pub type LiteRtOpaqueOptionsHashFunc = + ::std::option::Option u64>; +extern "C" { + pub fn LiteRtSetOpaqueOptionsHash( + options: LiteRtOpaqueOptions, + payload_hash_func: LiteRtOpaqueOptionsHashFunc, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetOpaqueOptionsHash(options: LiteRtOpaqueOptions, hash: *mut u64) + -> LiteRtStatus; +} +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct LiteRtCustomOpKernel { + pub Init: ::std::option::Option< + unsafe extern "C" fn( + user_data: *mut ::std::os::raw::c_void, + init_data: *const ::std::os::raw::c_void, + init_data_size: usize, + ) -> LiteRtStatus, + >, + pub GetOutputLayouts: ::std::option::Option< + unsafe extern "C" fn( + user_data: *mut ::std::os::raw::c_void, + num_inputs: usize, + input_layouts: *const LiteRtLayout, + num_outputs: usize, + output_layouts: *mut LiteRtLayout, + ) -> LiteRtStatus, + >, + pub Run: ::std::option::Option< + unsafe extern "C" fn( + user_data: *mut ::std::os::raw::c_void, + num_inputs: usize, + inputs: *const LiteRtTensorBuffer, + num_outputs: usize, + outputs: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus, + >, + pub Destroy: ::std::option::Option< + unsafe extern "C" fn(user_data: *mut ::std::os::raw::c_void) -> LiteRtStatus, + >, +} +extern "C" { + pub fn LiteRtCreateOptions(options: *mut LiteRtOptions) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtDestroyOptions(options: LiteRtOptions); +} +extern "C" { + pub fn LiteRtSetOptionsHardwareAccelerators( + options: LiteRtOptions, + hardware_accelerators: LiteRtHwAcceleratorSet, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetOptionsHardwareAccelerators( + options: LiteRtOptions, + hardware_accelerators: *mut LiteRtHwAcceleratorSet, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtAddOpaqueOptions( + options: LiteRtOptions, + opaque_options: LiteRtOpaqueOptions, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetOpaqueOptions( + options: LiteRtOptions, + opaque_options: *mut LiteRtOpaqueOptions, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtAddCustomOpKernelOption( + options: LiteRtOptions, + custom_op_name: *const ::std::os::raw::c_char, + custom_op_version: ::std::os::raw::c_int, + custom_op_kernel: *const LiteRtCustomOpKernel, + custom_op_kernel_user_data: *mut ::std::os::raw::c_void, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtAddExternalTensorBinding( + options: LiteRtOptions, + signature_name: *const ::std::os::raw::c_char, + tensor_name: *const ::std::os::raw::c_char, + data: *mut ::std::os::raw::c_void, + size_bytes: ::std::os::raw::c_int, + ) -> LiteRtStatus; +} +pub const kLiteRtOpCodeTflAdd: LiteRtOpCode = 0; +pub const kLiteRtOpCodeTflAveragePool2d: LiteRtOpCode = 1; +pub const kLiteRtOpCodeTflConcatenation: LiteRtOpCode = 2; +pub const kLiteRtOpCodeTflConv2d: LiteRtOpCode = 3; +pub const kLiteRtOpCodeTflDepthwiseConv2d: LiteRtOpCode = 4; +pub const kLiteRtOpCodeTflDepthToSpace: LiteRtOpCode = 5; +pub const kLiteRtOpCodeTflDequantize: LiteRtOpCode = 6; +pub const kLiteRtOpCodeTflEmbeddingLookup: LiteRtOpCode = 7; +pub const kLiteRtOpCodeTflFloor: LiteRtOpCode = 8; +pub const kLiteRtOpCodeTflFullyConnected: LiteRtOpCode = 9; +pub const kLiteRtOpCodeTflHashtableLookup: LiteRtOpCode = 10; +pub const kLiteRtOpCodeTflL2Normalization: LiteRtOpCode = 11; +pub const kLiteRtOpCodeTflL2Pool2d: LiteRtOpCode = 12; +pub const kLiteRtOpCodeTflLocalResponseNormalization: LiteRtOpCode = 13; +pub const kLiteRtOpCodeTflLogistic: LiteRtOpCode = 14; +pub const kLiteRtOpCodeTflLshProjection: LiteRtOpCode = 15; +pub const kLiteRtOpCodeTflLstm: LiteRtOpCode = 16; +pub const kLiteRtOpCodeTflMaxPool2d: LiteRtOpCode = 17; +pub const kLiteRtOpCodeTflMul: LiteRtOpCode = 18; +pub const kLiteRtOpCodeTflRelu: LiteRtOpCode = 19; +pub const kLiteRtOpCodeTflReluN1To1: LiteRtOpCode = 20; +pub const kLiteRtOpCodeTflRelu6: LiteRtOpCode = 21; +pub const kLiteRtOpCodeTflReshape: LiteRtOpCode = 22; +pub const kLiteRtOpCodeTflResizeBilinear: LiteRtOpCode = 23; +pub const kLiteRtOpCodeTflRnn: LiteRtOpCode = 24; +pub const kLiteRtOpCodeTflSoftmax: LiteRtOpCode = 25; +pub const kLiteRtOpCodeTflSpaceToDepth: LiteRtOpCode = 26; +pub const kLiteRtOpCodeTflSvdf: LiteRtOpCode = 27; +pub const kLiteRtOpCodeTflTanh: LiteRtOpCode = 28; +pub const kLiteRtOpCodeTflConcatEmbeddings: LiteRtOpCode = 29; +pub const kLiteRtOpCodeTflSkipGram: LiteRtOpCode = 30; +pub const kLiteRtOpCodeTflCall: LiteRtOpCode = 31; +pub const kLiteRtOpCodeTflCustom: LiteRtOpCode = 32; +pub const kLiteRtOpCodeTflEmbeddingLookupSparse: LiteRtOpCode = 33; +pub const kLiteRtOpCodeTflPad: LiteRtOpCode = 34; +pub const kLiteRtOpCodeTflUnidirectionalSequenceRnn: LiteRtOpCode = 35; +pub const kLiteRtOpCodeTflGather: LiteRtOpCode = 36; +pub const kLiteRtOpCodeTflBatchToSpaceNd: LiteRtOpCode = 37; +pub const kLiteRtOpCodeTflSpaceToBatchNd: LiteRtOpCode = 38; +pub const kLiteRtOpCodeTflTranspose: LiteRtOpCode = 39; +pub const kLiteRtOpCodeTflMean: LiteRtOpCode = 40; +pub const kLiteRtOpCodeTflSub: LiteRtOpCode = 41; +pub const kLiteRtOpCodeTflDiv: LiteRtOpCode = 42; +pub const kLiteRtOpCodeTflSqueeze: LiteRtOpCode = 43; +pub const kLiteRtOpCodeTflUnidirectionalSequenceLstm: LiteRtOpCode = 44; +pub const kLiteRtOpCodeTflStridedSlice: LiteRtOpCode = 45; +pub const kLiteRtOpCodeTflBidirectionalSequenceRnn: LiteRtOpCode = 46; +pub const kLiteRtOpCodeTflExp: LiteRtOpCode = 47; +pub const kLiteRtOpCodeTflTopkV2: LiteRtOpCode = 48; +pub const kLiteRtOpCodeTflSplit: LiteRtOpCode = 49; +pub const kLiteRtOpCodeTflLogSoftmax: LiteRtOpCode = 50; +pub const kLiteRtOpCodeTflDelegate: LiteRtOpCode = 51; +pub const kLiteRtOpCodeTflBidirectionalSequenceLstm: LiteRtOpCode = 52; +pub const kLiteRtOpCodeTflCast: LiteRtOpCode = 53; +pub const kLiteRtOpCodeTflPrelu: LiteRtOpCode = 54; +pub const kLiteRtOpCodeTflMaximum: LiteRtOpCode = 55; +pub const kLiteRtOpCodeTflArgMax: LiteRtOpCode = 56; +pub const kLiteRtOpCodeTflMinimum: LiteRtOpCode = 57; +pub const kLiteRtOpCodeTflLess: LiteRtOpCode = 58; +pub const kLiteRtOpCodeTflNeg: LiteRtOpCode = 59; +pub const kLiteRtOpCodeTflPadv2: LiteRtOpCode = 60; +pub const kLiteRtOpCodeTflGreater: LiteRtOpCode = 61; +pub const kLiteRtOpCodeTflGreaterEqual: LiteRtOpCode = 62; +pub const kLiteRtOpCodeTflLessEqual: LiteRtOpCode = 63; +pub const kLiteRtOpCodeTflSelect: LiteRtOpCode = 64; +pub const kLiteRtOpCodeTflSlice: LiteRtOpCode = 65; +pub const kLiteRtOpCodeTflSin: LiteRtOpCode = 66; +pub const kLiteRtOpCodeTflTransposeConv: LiteRtOpCode = 67; +pub const kLiteRtOpCodeTflSparseToDense: LiteRtOpCode = 68; +pub const kLiteRtOpCodeTflTile: LiteRtOpCode = 69; +pub const kLiteRtOpCodeTflExpandDims: LiteRtOpCode = 70; +pub const kLiteRtOpCodeTflEqual: LiteRtOpCode = 71; +pub const kLiteRtOpCodeTflNotEqual: LiteRtOpCode = 72; +pub const kLiteRtOpCodeTflLog: LiteRtOpCode = 73; +pub const kLiteRtOpCodeTflSum: LiteRtOpCode = 74; +pub const kLiteRtOpCodeTflSqrt: LiteRtOpCode = 75; +pub const kLiteRtOpCodeTflRsqrt: LiteRtOpCode = 76; +pub const kLiteRtOpCodeTflShape: LiteRtOpCode = 77; +pub const kLiteRtOpCodeTflPow: LiteRtOpCode = 78; +pub const kLiteRtOpCodeTflArgMin: LiteRtOpCode = 79; +pub const kLiteRtOpCodeTflFakeQuant: LiteRtOpCode = 80; +pub const kLiteRtOpCodeTflReduceProd: LiteRtOpCode = 81; +pub const kLiteRtOpCodeTflReduceMax: LiteRtOpCode = 82; +pub const kLiteRtOpCodeTflPack: LiteRtOpCode = 83; +pub const kLiteRtOpCodeTflLogicalOr: LiteRtOpCode = 84; +pub const kLiteRtOpCodeTflOneHot: LiteRtOpCode = 85; +pub const kLiteRtOpCodeTflLogicalAnd: LiteRtOpCode = 86; +pub const kLiteRtOpCodeTflLogicalNot: LiteRtOpCode = 87; +pub const kLiteRtOpCodeTflUnpack: LiteRtOpCode = 88; +pub const kLiteRtOpCodeTflReduceMin: LiteRtOpCode = 89; +pub const kLiteRtOpCodeTflFloorDiv: LiteRtOpCode = 90; +pub const kLiteRtOpCodeTflReduceAny: LiteRtOpCode = 91; +pub const kLiteRtOpCodeTflSquare: LiteRtOpCode = 92; +pub const kLiteRtOpCodeTflZerosLike: LiteRtOpCode = 93; +pub const kLiteRtOpCodeTflFill: LiteRtOpCode = 94; +pub const kLiteRtOpCodeTflFloorMod: LiteRtOpCode = 95; +pub const kLiteRtOpCodeTflRange: LiteRtOpCode = 96; +pub const kLiteRtOpCodeTflResizeNearestNeighbor: LiteRtOpCode = 97; +pub const kLiteRtOpCodeTflLeakyRelu: LiteRtOpCode = 98; +pub const kLiteRtOpCodeTflSquaredDifference: LiteRtOpCode = 99; +pub const kLiteRtOpCodeTflMirrorPad: LiteRtOpCode = 100; +pub const kLiteRtOpCodeTflAbs: LiteRtOpCode = 101; +pub const kLiteRtOpCodeTflSplitV: LiteRtOpCode = 102; +pub const kLiteRtOpCodeTflUnique: LiteRtOpCode = 103; +pub const kLiteRtOpCodeTflCeil: LiteRtOpCode = 104; +pub const kLiteRtOpCodeTflReverseV2: LiteRtOpCode = 105; +pub const kLiteRtOpCodeTflAddN: LiteRtOpCode = 106; +pub const kLiteRtOpCodeTflGatherNd: LiteRtOpCode = 107; +pub const kLiteRtOpCodeTflCos: LiteRtOpCode = 108; +pub const kLiteRtOpCodeTflWhere: LiteRtOpCode = 109; +pub const kLiteRtOpCodeTflRank: LiteRtOpCode = 110; +pub const kLiteRtOpCodeTflElu: LiteRtOpCode = 111; +pub const kLiteRtOpCodeTflReverseSequence: LiteRtOpCode = 112; +pub const kLiteRtOpCodeTflMatrixDiag: LiteRtOpCode = 113; +pub const kLiteRtOpCodeTflQuantize: LiteRtOpCode = 114; +pub const kLiteRtOpCodeTflMatrixSetDiag: LiteRtOpCode = 115; +pub const kLiteRtOpCodeTflRound: LiteRtOpCode = 116; +pub const kLiteRtOpCodeTflHardSwish: LiteRtOpCode = 117; +pub const kLiteRtOpCodeTflIf: LiteRtOpCode = 118; +pub const kLiteRtOpCodeTflWhile: LiteRtOpCode = 119; +pub const kLiteRtOpCodeTflNonMaxSuppressionV4: LiteRtOpCode = 120; +pub const kLiteRtOpCodeTflNonMaxSuppressionV5: LiteRtOpCode = 121; +pub const kLiteRtOpCodeTflScatterNd: LiteRtOpCode = 122; +pub const kLiteRtOpCodeTflSelectV2: LiteRtOpCode = 123; +pub const kLiteRtOpCodeTflDensify: LiteRtOpCode = 124; +pub const kLiteRtOpCodeTflSegmentSum: LiteRtOpCode = 125; +pub const kLiteRtOpCodeTflBatchMatmul: LiteRtOpCode = 126; +pub const kLiteRtOpCodeTflPlaceholderForGreaterOpCodeTfls: LiteRtOpCode = 127; +pub const kLiteRtOpCodeTflCumsum: LiteRtOpCode = 128; +pub const kLiteRtOpCodeTflCallOnce: LiteRtOpCode = 129; +pub const kLiteRtOpCodeTflBroadcastTo: LiteRtOpCode = 130; +pub const kLiteRtOpCodeTflRfft2d: LiteRtOpCode = 131; +pub const kLiteRtOpCodeTflConv3d: LiteRtOpCode = 132; +pub const kLiteRtOpCodeTflImag: LiteRtOpCode = 133; +pub const kLiteRtOpCodeTflReal: LiteRtOpCode = 134; +pub const kLiteRtOpCodeTflComplexAbs: LiteRtOpCode = 135; +pub const kLiteRtOpCodeTflHashtable: LiteRtOpCode = 136; +pub const kLiteRtOpCodeTflHashtableFind: LiteRtOpCode = 137; +pub const kLiteRtOpCodeTflHashtableImport: LiteRtOpCode = 138; +pub const kLiteRtOpCodeTflHashtableSize: LiteRtOpCode = 139; +pub const kLiteRtOpCodeTflReduceAll: LiteRtOpCode = 140; +pub const kLiteRtOpCodeTflConv3dTranspose: LiteRtOpCode = 141; +pub const kLiteRtOpCodeTflVarHandle: LiteRtOpCode = 142; +pub const kLiteRtOpCodeTflReadVariable: LiteRtOpCode = 143; +pub const kLiteRtOpCodeTflAssignVariable: LiteRtOpCode = 144; +pub const kLiteRtOpCodeTflBroadcastArgs: LiteRtOpCode = 145; +pub const kLiteRtOpCodeTflRandomStandardNormal: LiteRtOpCode = 146; +pub const kLiteRtOpCodeTflBucketize: LiteRtOpCode = 147; +pub const kLiteRtOpCodeTflRandomUniform: LiteRtOpCode = 148; +pub const kLiteRtOpCodeTflMultinomial: LiteRtOpCode = 149; +pub const kLiteRtOpCodeTflGelu: LiteRtOpCode = 150; +pub const kLiteRtOpCodeTflDynamicUpdateSlice: LiteRtOpCode = 151; +pub const kLiteRtOpCodeTflRelu0To1: LiteRtOpCode = 152; +pub const kLiteRtOpCodeTflUnsortedSegmentProd: LiteRtOpCode = 153; +pub const kLiteRtOpCodeTflUnsortedSegmentMax: LiteRtOpCode = 154; +pub const kLiteRtOpCodeTflUnsortedSegmentSum: LiteRtOpCode = 155; +pub const kLiteRtOpCodeTflAtan2: LiteRtOpCode = 156; +pub const kLiteRtOpCodeTflUnsortedSegmentMin: LiteRtOpCode = 157; +pub const kLiteRtOpCodeTflSign: LiteRtOpCode = 158; +pub const kLiteRtOpCodeTflBitcast: LiteRtOpCode = 159; +pub const kLiteRtOpCodeTflBitwiseXor: LiteRtOpCode = 160; +pub const kLiteRtOpCodeTflRightShift: LiteRtOpCode = 161; +pub const kLiteRtOpCodeShloLogistic: LiteRtOpCode = 162; +pub const kLiteRtOpCodeShloAdd: LiteRtOpCode = 163; +pub const kLiteRtOpCodeShloDivide: LiteRtOpCode = 164; +pub const kLiteRtOpCodeShloMultiply: LiteRtOpCode = 165; +pub const kLiteRtOpCodeShloMaximum: LiteRtOpCode = 166; +pub const kLiteRtOpCodeShloReshape: LiteRtOpCode = 167; +pub const kLiteRtOpCodeShloClamp: LiteRtOpCode = 168; +pub const kLiteRtOpCodeShloConcatenate: LiteRtOpCode = 169; +pub const kLiteRtOpCodeShloBroadcastInDim: LiteRtOpCode = 170; +pub const kLiteRtOpCodeShloConvolution: LiteRtOpCode = 171; +pub const kLiteRtOpCodeShloSlice: LiteRtOpCode = 172; +pub const kLiteRtOpCodeShloCustomCall: LiteRtOpCode = 173; +pub const kLiteRtOpCodeShloReduce: LiteRtOpCode = 174; +pub const kLiteRtOpCodeShloAbs: LiteRtOpCode = 175; +pub const kLiteRtOpCodeShloAnd: LiteRtOpCode = 176; +pub const kLiteRtOpCodeShloCosine: LiteRtOpCode = 177; +pub const kLiteRtOpCodeShloExponential: LiteRtOpCode = 178; +pub const kLiteRtOpCodeShloFloor: LiteRtOpCode = 179; +pub const kLiteRtOpCodeShloLog: LiteRtOpCode = 180; +pub const kLiteRtOpCodeShloMinimum: LiteRtOpCode = 181; +pub const kLiteRtOpCodeShloNegate: LiteRtOpCode = 182; +pub const kLiteRtOpCodeShloOr: LiteRtOpCode = 183; +pub const kLiteRtOpCodeShloPower: LiteRtOpCode = 184; +pub const kLiteRtOpCodeShloRemainder: LiteRtOpCode = 185; +pub const kLiteRtOpCodeShloRsqrt: LiteRtOpCode = 186; +pub const kLiteRtOpCodeShloSelect: LiteRtOpCode = 187; +pub const kLiteRtOpCodeShloSubtract: LiteRtOpCode = 188; +pub const kLiteRtOpCodeShloTanh: LiteRtOpCode = 189; +pub const kLiteRtOpCodeShloScatter: LiteRtOpCode = 190; +pub const kLiteRtOpCodeShloCompare: LiteRtOpCode = 191; +pub const kLiteRtOpCodeShloConvert: LiteRtOpCode = 192; +pub const kLiteRtOpCodeShloDynamicSlice: LiteRtOpCode = 193; +pub const kLiteRtOpCodeShloDynamicUpdateSlice: LiteRtOpCode = 194; +pub const kLiteRtOpCodeShloPad: LiteRtOpCode = 195; +pub const kLiteRtOpCodeShloIota: LiteRtOpCode = 196; +pub const kLiteRtOpCodeShloGeneral: LiteRtOpCode = 197; +pub const kLiteRtOpCodeShloWindow: LiteRtOpCode = 198; +pub const kLiteRtOpCodeShloSort: LiteRtOpCode = 199; +pub const kLiteRtOpCodeShloWhile: LiteRtOpCode = 200; +pub const kLiteRtOpCodeShloGather: LiteRtOpCode = 201; +pub const kLiteRtOpCodeShloTranspose: LiteRtOpCode = 202; +pub const kLiteRtOpCodeTflDilate: LiteRtOpCode = 203; +pub const kLiteRtOpCodeShloRngBitGenerator: LiteRtOpCode = 204; +pub const kLiteRtOpCodeTflReduceWindow: LiteRtOpCode = 205; +pub const kLiteRtOpCodeShloComposite: LiteRtOpCode = 206; +pub type LiteRtOpCode = ::std::os::raw::c_uint; +extern "C" { + pub fn LiteRtGetTensorTypeId( + tensor: LiteRtTensor, + type_id: *mut LiteRtTensorTypeId, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetUnrankedTensorType( + tensor: LiteRtTensor, + unranked_tensor_type: *mut LiteRtUnrankedTensorType, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetRankedTensorType( + tensor: LiteRtTensor, + ranked_tensor_type: *mut LiteRtRankedTensorType, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetNumTensorUses( + tensor: LiteRtTensor, + num_uses: *mut LiteRtParamIndex, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorUse( + tensor: LiteRtTensor, + use_index: LiteRtParamIndex, + user: *mut LiteRtOp, + user_arg_index: *mut LiteRtParamIndex, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorDefiningOp( + tensor: LiteRtTensor, + has_defining_op: *mut bool, + defining_op: *mut LiteRtTensorDefiningOp, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorWeights( + tensor: LiteRtTensor, + weights: *mut LiteRtWeights, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetWeightsBytes( + weights: LiteRtWeights, + addr: *mut *const ::std::os::raw::c_void, + size: *mut usize, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetWeightsBufferId(weights: LiteRtWeights, buffer_id: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetOpCode(op: LiteRtOp, code: *mut LiteRtOpCode) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetCustomCode( + op: LiteRtOp, + code: *mut *const ::std::os::raw::c_char, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetNumOpInputs(op: LiteRtOp, num_inputs: *mut LiteRtParamIndex) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetOpInput( + op: LiteRtOp, + input_index: LiteRtParamIndex, + input: *mut LiteRtTensor, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetNumOpOutputs(op: LiteRtOp, num_outputs: *mut LiteRtParamIndex) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetOpOutput( + op: LiteRtOp, + output_index: LiteRtParamIndex, + output: *mut LiteRtTensor, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetNumSubgraphInputs( + subgraph: LiteRtSubgraph, + num_inputs: *mut LiteRtParamIndex, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSubgraphInput( + subgraph: LiteRtSubgraph, + input_index: LiteRtParamIndex, + input: *mut LiteRtTensor, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetNumSubgraphOutputs( + subgraph: LiteRtSubgraph, + num_outputs: *mut LiteRtParamIndex, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSubgraphOutput( + subgraph: LiteRtSubgraph, + output_index: LiteRtParamIndex, + output: *mut LiteRtTensor, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetNumSubgraphOps( + subgraph: LiteRtSubgraph, + num_ops: *mut LiteRtParamIndex, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSubgraphOp( + subgraph: LiteRtSubgraph, + op_index: LiteRtParamIndex, + op: *mut LiteRtOp, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSignatureKey( + signature: LiteRtSignature, + signature_key: *mut *const ::std::os::raw::c_char, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSignatureSubgraph( + signature: LiteRtSignature, + subgraph: *mut LiteRtSubgraph, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetNumSignatureInputs( + signature: LiteRtSignature, + num_inputs: *mut LiteRtParamIndex, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSignatureInputName( + signature: LiteRtSignature, + input_idx: LiteRtParamIndex, + input_name: *mut *const ::std::os::raw::c_char, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSignatureInputTensor( + signature: LiteRtSignature, + input_name: *const ::std::os::raw::c_char, + tensor: *mut LiteRtTensor, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSignatureInputTensorByIndex( + signature: LiteRtSignature, + input_idx: LiteRtParamIndex, + tensor: *mut LiteRtTensor, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetNumSignatureOutputs( + signature: LiteRtSignature, + num_outputs: *mut LiteRtParamIndex, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSignatureOutputName( + signature: LiteRtSignature, + output_idx: LiteRtParamIndex, + output_name: *mut *const ::std::os::raw::c_char, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSignatureOutputTensor( + signature: LiteRtSignature, + output_name: *const ::std::os::raw::c_char, + tensor: *mut LiteRtTensor, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSignatureOutputTensorByIndex( + signature: LiteRtSignature, + output_idx: LiteRtParamIndex, + tensor: *mut LiteRtTensor, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateModelFromFile( + filename: *const ::std::os::raw::c_char, + model: *mut LiteRtModel, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateModelFromBuffer( + buffer_addr: *const ::std::os::raw::c_void, + buffer_size: usize, + model: *mut LiteRtModel, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetModelMetadata( + model: LiteRtModel, + metadata_key: *const ::std::os::raw::c_char, + metadata_buffer: *mut *const ::std::os::raw::c_void, + metadata_buffer_size: *mut usize, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtAddModelMetadata( + model: LiteRtModel, + metadata_key: *const ::std::os::raw::c_char, + metadata_buffer: *const ::std::os::raw::c_void, + metadata_buffer_size: usize, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetMainModelSubgraphIndex( + model: LiteRtModel, + main_subgraph_index: *mut LiteRtParamIndex, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetNumModelSubgraphs( + model: LiteRtModel, + num_subgraphs: *mut LiteRtParamIndex, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetModelSubgraph( + model: LiteRtModel, + subgraph_index: LiteRtParamIndex, + subgraph: *mut LiteRtSubgraph, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetNumModelSignatures( + model: LiteRtModel, + num_signatures: *mut LiteRtParamIndex, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetModelSignature( + model: LiteRtModel, + signature_index: LiteRtParamIndex, + signature: *mut LiteRtSignature, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtDestroyModel(model: LiteRtModel); +} +extern "C" { + pub fn LiteRtPushOp( + op_list: LiteRtOpList, + op: LiteRtOp, + partition_index: LiteRtParamIndex, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtSerializeModelWithSignatures( + model: LiteRtModel, + buf: *mut *mut u8, + size: *mut usize, + offset: *mut usize, + destroy_model: bool, + signatures: *mut *mut ::std::os::raw::c_char, + num_signatures: LiteRtParamIndex, + options: LiteRtModelSerializationOptions, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtSerializeModel( + model: LiteRtModel, + buf: *mut *mut u8, + size: *mut usize, + offset: *mut usize, + destroy_model: bool, + options: LiteRtModelSerializationOptions, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetAddFusedActivationOption( + op: LiteRtOp, + fused_activation: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildAddOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + fused_activation: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetBatchMatmulAdjXOption(op: LiteRtOp, adj_x: *mut bool) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetBatchMatmulAdjYOption(op: LiteRtOp, adj_y: *mut bool) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetBatchMatmulAsymmetricQuantizeInputOption( + op: LiteRtOp, + asymmetric_quantize_input: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildBatchMatmulOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + adj_x: *mut bool, + adj_y: *mut bool, + asymmetric_quantize_input: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConcatenationFusedActivationOption( + op: LiteRtOp, + fused_activation: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConcatenationAxisOption(op: LiteRtOp, axis: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildConcatenationOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + fused_activation: *mut u32, + axis: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetDivFusedActivationOption( + op: LiteRtOp, + fused_activation: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildDivOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + fused_activation: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetFullyConnectedFusedActivationOption( + op: LiteRtOp, + fused_activation: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetFullyConnectedWeightsFormatOption( + op: LiteRtOp, + weights_format: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetFullyConnectedKeepNumDimsOption( + op: LiteRtOp, + keep_num_dims: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtFullyConnectedGetQuantizedBiasTypeOption( + op: LiteRtOp, + quantized_bias_type: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetFullyConnectedAsymmetricQuantizeInputOption( + op: LiteRtOp, + asymmetric_quantize_input: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildFullyConnectedOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + fused_activation: *mut u32, + weights_format: *mut u32, + keep_num_dims: *mut bool, + quantized_bias_type: *mut u32, + asymmetric_quantize_input: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetMulFusedActivationOption( + op: LiteRtOp, + fused_activation: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildMulOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + fused_activation: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSoftmaxBetaOption(op: LiteRtOp, beta: *mut f32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildSoftmaxOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + beta: *mut f32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetStridedSliceBeginMaskOption(op: LiteRtOp, begin_mask: *mut i32) + -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetStridedSliceEndMaskOption(op: LiteRtOp, end_mask: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetStridedSliceEllipsisMaskOption( + op: LiteRtOp, + ellipsis_mask: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetStridedSliceNewAxisMaskOption( + op: LiteRtOp, + new_axis_mask: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetStridedSliceShrinkAxisMaskOption( + op: LiteRtOp, + shrink_axis_mask: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetStridedSliceOffsetOption(op: LiteRtOp, offset: *mut bool) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildStridedSliceOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + begin_mask: *mut i32, + end_mask: *mut i32, + ellipsis_mask: *mut i32, + new_axis_mask: *mut i32, + shrink_axis_mask: *mut i32, + offset: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSubFusedActivationOption( + op: LiteRtOp, + fused_activation: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildSubOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + fused_activation: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetReshapeNewShapeOption( + op: LiteRtOp, + new_shape: *mut *const i32, + new_shape_size: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildReshapeOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + new_shape: *mut i32, + new_shape_size: i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSumKeepDimsOption(op: LiteRtOp, keepdims: *mut bool) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildSumOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + keepdims: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetReduceMaxKeepDimsOption(op: LiteRtOp, keepdims: *mut bool) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildReduceMaxOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + keepdims: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetReduceMinKeepDimsOption(op: LiteRtOp, keepdims: *mut bool) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildReduceMinOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + keepdims: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetReduceAnyKeepDimsOption(op: LiteRtOp, keepdims: *mut bool) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildReduceAnyOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + keepdims: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetReduceAllKeepDimsOption(op: LiteRtOp, keepdims: *mut bool) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildReduceAllOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + keepdims: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetPackAxisOption(op: LiteRtOp, axis: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetPackValuesCountOption(op: LiteRtOp, values_count: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildPackOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + axis: *mut i32, + values_count: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetUnpackAxisOption(op: LiteRtOp, axis: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetUnpackNumOption(op: LiteRtOp, num: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildUnpackOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + axis: *mut i32, + num: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetGatherAxisOption(op: LiteRtOp, axis: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetGatherBatchDimsOption(op: LiteRtOp, batch_dims: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildGatherOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + axis: *mut i32, + batch_dims: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetMeanKeepDimsOption(op: LiteRtOp, keepdims: *mut bool) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildMeanOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + keepdims: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSplitNumSplitsOption(op: LiteRtOp, num_splits: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildSplitOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + num_splits: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSHLOCompositeOpName( + op: LiteRtOp, + name: *mut *const ::std::os::raw::c_char, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSHLOCompositeOpDecompositionSubgraphIndex( + op: LiteRtOp, + decomposition_subgraph_index: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSHLOCompositeOpAttributes( + op: LiteRtOp, + attributes: *mut *const u8, + attributes_size: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSHLOCompositeOpVersion(op: LiteRtOp, version: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConv2dPaddingOption(op: LiteRtOp, padding: *mut u32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConv2dStrideWOption(op: LiteRtOp, stride_w: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConv2dStrideHOption(op: LiteRtOp, stride_h: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConv2dFusedActivationOption( + op: LiteRtOp, + fused_activation_function: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConv2dDilationWOption( + op: LiteRtOp, + dilation_w_factor: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConv2dDilationHOption( + op: LiteRtOp, + dilation_h_factor: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildConv2dOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + padding: *mut u32, + stride_w: *mut i32, + stride_h: *mut i32, + dilation_w_factor: *mut i32, + dilation_h_factor: *mut i32, + fused_activation_function: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConv3dPaddingOption(op: LiteRtOp, padding: *mut u32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConv3dStrideDOption(op: LiteRtOp, stride_d: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConv3dStrideWOption(op: LiteRtOp, stride_w: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConv3dStrideHOption(op: LiteRtOp, stride_h: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConv3dFusedActivationOption( + op: LiteRtOp, + fused_activation_function: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConv3dDilationDOption( + op: LiteRtOp, + dilation_d_factor: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConv3dDilationWOption( + op: LiteRtOp, + dilation_w_factor: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetConv3dDilationHOption( + op: LiteRtOp, + dilation_h_factor: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildConv3dOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + padding: *mut u32, + stride_w: *mut i32, + stride_h: *mut i32, + stride_d: *mut i32, + dilation_w_factor: *mut i32, + dilation_h_factor: *mut i32, + dilation_d_factor: *mut i32, + fused_activation_function: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetDepthwiseConv2dPaddingOption(op: LiteRtOp, padding: *mut u32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetDepthwiseConv2dStrideWOption(op: LiteRtOp, stride_w: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetDepthwiseConv2dStrideHOption(op: LiteRtOp, stride_h: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetDepthwiseConv2dDepthMultiplierOption( + op: LiteRtOp, + depth_multiplier: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetDepthwiseConv2dFusedActivationOption( + op: LiteRtOp, + fused_activation_function: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetDepthwiseConv2dDilationWOption( + op: LiteRtOp, + dilation_w_factor: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetDepthwiseConv2dDilationHOption( + op: LiteRtOp, + dilation_h_factor: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildDepthwiseConv2dOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + padding: *mut u32, + stride_w: *mut i32, + stride_h: *mut i32, + depth_multiplier: *mut i32, + fused_activation_function: *mut u32, + dilation_w_factor: *mut i32, + dilation_h_factor: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTransposeConvPaddingOption(op: LiteRtOp, padding: *mut u32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTransposeConvStrideWOption(op: LiteRtOp, stride_w: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTransposeConvStrideHOption(op: LiteRtOp, stride_h: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTransposeConvFusedActivationOption( + op: LiteRtOp, + fused_activation_function: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildTransposeConvOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + padding: *mut u32, + stride_w: *mut i32, + stride_h: *mut i32, + fused_activation_function: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetAveragePool2dPaddingOption(op: LiteRtOp, padding: *mut u32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetAveragePool2dStrideWOption(op: LiteRtOp, stride_w: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetAveragePool2dStrideHOption(op: LiteRtOp, stride_h: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetAveragePool2dFilterWidthOption( + op: LiteRtOp, + filter_width: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetAveragePool2dFilterHeightOption( + op: LiteRtOp, + filter_height: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetAveragePool2dFusedActivationOption( + op: LiteRtOp, + fused_activation_function: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildAveragePool2dOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + padding: *mut u32, + stride_w: *mut i32, + stride_h: *mut i32, + filter_width: *mut i32, + filter_height: *mut i32, + fused_activation_function: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetMaxPool2dPaddingOption(op: LiteRtOp, padding: *mut u32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetMaxPool2dStrideWOption(op: LiteRtOp, stride_w: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetMaxPool2dStrideHOption(op: LiteRtOp, stride_h: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetMaxPool2dFilterWidthOption( + op: LiteRtOp, + filter_width: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetMaxPool2dFilterHeightOption( + op: LiteRtOp, + filter_height: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetMaxPool2dFusedActivationOption( + op: LiteRtOp, + fused_activation_function: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildMaxPool2dOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + padding: *mut u32, + stride_w: *mut i32, + stride_h: *mut i32, + filter_width: *mut i32, + filter_height: *mut i32, + fused_activation_function: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetL2Pool2dPaddingOption(op: LiteRtOp, padding: *mut u32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetL2Pool2dStrideWOption(op: LiteRtOp, stride_w: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetL2Pool2dStrideHOption(op: LiteRtOp, stride_h: *mut i32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetL2Pool2dFilterWidthOption(op: LiteRtOp, filter_width: *mut i32) + -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetL2Pool2dFilterHeightOption( + op: LiteRtOp, + filter_height: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetL2Pool2dFusedActivationOption( + op: LiteRtOp, + fused_activation_function: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildL2Pool2dOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + padding: *mut u32, + stride_w: *mut i32, + stride_h: *mut i32, + filter_width: *mut i32, + filter_height: *mut i32, + fused_activation_function: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetResizeBilinearAlignCornersOption( + op: LiteRtOp, + align_corners: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetResizeBilinearHalfPixelCenterOption( + op: LiteRtOp, + half_pixel_centers: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildResizeBilinearOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + align_corners: *mut bool, + half_pixel_centers: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetLeakyReluAlphaOption(op: LiteRtOp, alpha: *mut f32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildLeakyReluOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + alpha: *mut f32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetDepthToSpaceBlockSizeOption(op: LiteRtOp, block_size: *mut i32) + -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildDepthToSpaceOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + block_size: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSpaceToDepthBlockSizeOption(op: LiteRtOp, block_size: *mut i32) + -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildSpaceToDepthOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + block_size: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetResizeNearestNeighborAlignCornersOption( + op: LiteRtOp, + align_corners: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetResizeNearestNeighborHalfPixelCenterOption( + op: LiteRtOp, + half_pixel_centers: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildResizeNearestNeighborOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + align_corners: *mut bool, + half_pixel_centers: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetCumsumExclusiveOption(op: LiteRtOp, exclusive: *mut bool) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetCumsumReverseOption(op: LiteRtOp, reverse: *mut bool) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildCumsumOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + exclusive: *mut bool, + reverse: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetGeluApproximateOption(op: LiteRtOp, approximate: *mut bool) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildGeluOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + approximate: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetMirrorPadModeOption(op: LiteRtOp, mode: *mut u32) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildMirrorPadOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + mode: *mut u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSqueezeDimsOption( + op: LiteRtOp, + squeeze_dims: *mut *const i32, + num_squeeze_dims: *mut i32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtBuilderBuildSqueezeOpOption( + builder: LiteRtBuilder, + op: LiteRtOp, + squeeze_dims: *const i32, + num_squeeze_dims: i32, + ) -> LiteRtStatus; +} +pub type LiteRtGLenum = u32; +pub type LiteRtGLuint = u32; +pub type LiteRtGLint = i32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtEglContextStruct { + _unused: [u8; 0], +} +pub type LiteRtEglContext = *mut LiteRtEglContextStruct; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtEglDisplayStruct { + _unused: [u8; 0], +} +pub type LiteRtEglDisplay = *mut LiteRtEglDisplayStruct; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtEglSyncKhrStruct { + _unused: [u8; 0], +} +pub type LiteRtEglSyncKhr = *mut LiteRtEglSyncKhrStruct; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _cl_mem { + _unused: [u8; 0], +} +#[doc = " Define LiteRT aliases for OpenCL types without requiring downstream users to\n include the OpenCL SDK headers just to compile LiteRT public headers.\n\n The OpenCL C API models both `cl_mem` and `cl_event` as opaque pointers to\n implementation-defined structs. Forward-declaring the same struct tags keeps\n LiteRT's public ABI compatible with code that later includes `CL/cl.h`,\n while avoiding a transitive dependency on the OpenCL headers for consumers\n that never bind directly to raw OpenCL objects."] +pub type LiteRtClMem = *mut _cl_mem; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct _cl_event { + _unused: [u8; 0], +} +pub type LiteRtClEvent = *mut _cl_event; +pub type LiteRtClInt = i32; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct WGPUBufferImpl { + _unused: [u8; 0], +} +pub type LiteRtWGPUBufferImpl = WGPUBufferImpl; +pub type LiteRtWGPUBuffer = *mut LiteRtWGPUBufferImpl; +extern "C" { + pub fn LiteRtCreateTensorBufferRequirements( + num_supported_tensor_buffer_types: ::std::os::raw::c_int, + supported_tensor_buffer_types: *const LiteRtTensorBufferType, + buffer_size: usize, + num_strides: ::std::os::raw::c_int, + strides: *const u32, + requirements: *mut LiteRtTensorBufferRequirements, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateTensorBufferRequirementsWithAlignment( + num_supported_tensor_buffer_types: ::std::os::raw::c_int, + supported_tensor_buffer_types: *const LiteRtTensorBufferType, + buffer_size: usize, + num_strides: ::std::os::raw::c_int, + strides: *const u32, + alignment: usize, + requirements: *mut LiteRtTensorBufferRequirements, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetNumTensorBufferRequirementsSupportedBufferTypes( + requirements: LiteRtTensorBufferRequirements, + num_types: *mut ::std::os::raw::c_int, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferRequirementsSupportedTensorBufferType( + requirements: LiteRtTensorBufferRequirements, + type_index: ::std::os::raw::c_int, + type_: *mut LiteRtTensorBufferType, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferRequirementsBufferSize( + requirements: LiteRtTensorBufferRequirements, + buffer_size: *mut usize, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferRequirementsStrides( + requirements: LiteRtTensorBufferRequirements, + num_strides: *mut ::std::os::raw::c_int, + strides: *mut *const u32, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferRequirementsAlignment( + requirements: LiteRtTensorBufferRequirements, + alignment: *mut usize, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtJoinTensorBufferRequirements( + src_requirements_1: LiteRtTensorBufferRequirements, + src_requirements_2: LiteRtTensorBufferRequirements, + joined_requirements: *mut LiteRtTensorBufferRequirements, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtDestroyTensorBufferRequirements(requirements: LiteRtTensorBufferRequirements); +} +extern "C" { + pub fn LiteRtCreateTensorBufferFromHostMemory( + tensor_type: *const LiteRtRankedTensorType, + host_buffer_addr: *mut ::std::os::raw::c_void, + host_buffer_size: usize, + deallocator: LiteRtHostMemoryDeallocator, + buffer: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferHostMemory( + tensor_buffer: LiteRtTensorBuffer, + host_memory_addr: *mut *mut ::std::os::raw::c_void, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateTensorBufferFromAhwb( + env: LiteRtEnvironment, + tensor_type: *const LiteRtRankedTensorType, + ahwb: *mut AHardwareBuffer, + ahwb_offset: usize, + deallocator: LiteRtAhwbDeallocator, + buffer: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferAhwb( + tensor_buffer: LiteRtTensorBuffer, + ahwb: *mut *mut AHardwareBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateTensorBufferFromIonBuffer( + tensor_type: *const LiteRtRankedTensorType, + ion_buffer_addr: *mut ::std::os::raw::c_void, + ion_buffer_fd: ::std::os::raw::c_int, + ion_buffer_size: usize, + ion_buffer_offset: usize, + deallocator: LiteRtIonDeallocator, + buffer: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferIonBuffer( + buffer: LiteRtTensorBuffer, + ion_buffer_addr: *mut *mut ::std::os::raw::c_void, + ion_buffer_fd: *mut ::std::os::raw::c_int, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateTensorBufferFromDmaBufBuffer( + tensor_type: *const LiteRtRankedTensorType, + dmabuf_buffer_addr: *mut ::std::os::raw::c_void, + dmabuf_buffer_fd: ::std::os::raw::c_int, + dmabuf_buffer_size: usize, + dmabuf_buffer_offset: usize, + deallocator: LiteRtDmaBufDeallocator, + buffer: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferDmaBufBuffer( + tensor_buffer: LiteRtTensorBuffer, + dmabuf_buffer_addr: *mut *mut ::std::os::raw::c_void, + dmabuf_buffer_fd: *mut ::std::os::raw::c_int, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateTensorBufferFromFastRpcBuffer( + tensor_type: *const LiteRtRankedTensorType, + fastrpc_buffer_addr: *mut ::std::os::raw::c_void, + fastrpc_buffer_fd: ::std::os::raw::c_int, + fastrpc_buffer_size: usize, + fastrpc_buffer_offset: usize, + deallocator: LiteRtFastRpcDeallocator, + tensor_buffer: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferFastRpcBuffer( + tensor_buffer: LiteRtTensorBuffer, + fastrpc_buffer_addr: *mut *mut ::std::os::raw::c_void, + fastrpc_buffer_fd: *mut ::std::os::raw::c_int, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateTensorBufferFromOpenClMemory( + env: LiteRtEnvironment, + tensor_type: *const LiteRtRankedTensorType, + buffer_type: LiteRtTensorBufferType, + cl_mem_addr: LiteRtClMem, + opencl_buffer_size: usize, + deallocator: LiteRtOpenClDeallocator, + buffer: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferOpenClMemory( + tensor_buffer: LiteRtTensorBuffer, + cl_mem_addr: *mut LiteRtClMem, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferCustomTensorBufferHandle( + tensor_buffer: LiteRtTensorBuffer, + hw_memory_handle: *mut HwMemoryHandle, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateTensorBufferFromGlBuffer( + env: LiteRtEnvironment, + tensor_type: *const LiteRtRankedTensorType, + target: LiteRtGLenum, + id: LiteRtGLuint, + size_bytes: usize, + offset: usize, + deallocator: LiteRtGlBufferDeallocator, + buffer: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferGlBuffer( + tensor_buffer: LiteRtTensorBuffer, + target: *mut LiteRtGLenum, + id: *mut LiteRtGLuint, + size_bytes: *mut usize, + offset: *mut usize, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateTensorBufferFromGlTexture( + env: LiteRtEnvironment, + tensor_type: *const LiteRtRankedTensorType, + target: LiteRtGLenum, + id: LiteRtGLuint, + format: LiteRtGLenum, + size_bytes: usize, + layer: LiteRtGLint, + deallocator: LiteRtGlTextureDeallocator, + buffer: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferGlTexture( + tensor_buffer: LiteRtTensorBuffer, + target: *mut LiteRtGLenum, + id: *mut LiteRtGLuint, + format: *mut LiteRtGLenum, + size_bytes: *mut usize, + layer: *mut LiteRtGLint, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateTensorBufferFromWebGpuBuffer( + env: LiteRtEnvironment, + tensor_type: *const LiteRtRankedTensorType, + buffer_type: LiteRtTensorBufferType, + wgpu_buffer: LiteRtWGPUBuffer, + wgpu_buffer_size: usize, + deallocator: LiteRtWebGpuBufferDeallocator, + tensor_buffer: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateTensorBufferFromWebGpuTexture( + env: LiteRtEnvironment, + tensor_type: *const LiteRtRankedTensorType, + webgpu_texture: *mut ::std::os::raw::c_void, + webgpu_texture_size: usize, + deallocator: LiteRtWebGpuTextureDeallocator, + tensor_buffer: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferWebGpuBuffer( + tensor_buffer: LiteRtTensorBuffer, + hw_memory_handle: *mut HwMemoryHandle, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateTensorBufferFromMetalMemory( + env: LiteRtEnvironment, + tensor_type: *const LiteRtRankedTensorType, + buffer_type: LiteRtTensorBufferType, + metal_buffer: *mut ::std::os::raw::c_void, + metal_buffer_size: usize, + deallocator: LiteRtMetalDeallocator, + tensor_buffer: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferMetalMemory( + tensor_buffer: LiteRtTensorBuffer, + hw_memory_handle: *mut HwMemoryHandle, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferVulkanMemory( + tensor_buffer: LiteRtTensorBuffer, + hw_memory_handle: *mut HwMemoryHandle, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateManagedTensorBuffer( + env: LiteRtEnvironment, + buffer_type: LiteRtTensorBufferType, + tensor_type: *const LiteRtRankedTensorType, + buffer_size: usize, + buffer: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateManagedTensorBufferFromRequirements( + env: LiteRtEnvironment, + tensor_type: *const LiteRtRankedTensorType, + requirements: LiteRtTensorBufferRequirements, + buffer: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtDuplicateTensorBuffer(tensor_buffer: LiteRtTensorBuffer) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferType( + tensor_buffer: LiteRtTensorBuffer, + buffer_type: *mut LiteRtTensorBufferType, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferTensorType( + tensor_buffer: LiteRtTensorBuffer, + tensor_type: *mut LiteRtRankedTensorType, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferSize( + tensor_buffer: LiteRtTensorBuffer, + size: *mut usize, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferPackedSize( + tensor_buffer: LiteRtTensorBuffer, + size: *mut usize, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferOffset( + tensor_buffer: LiteRtTensorBuffer, + offset: *mut usize, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtHasTensorBufferEvent( + tensor_buffer: LiteRtTensorBuffer, + has_event: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetTensorBufferEvent( + tensor_buffer: LiteRtTensorBuffer, + event: *mut LiteRtEvent, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtSetTensorBufferEvent( + tensor_buffer: LiteRtTensorBuffer, + event: LiteRtEvent, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtClearTensorBufferEvent(tensor_buffer: LiteRtTensorBuffer) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtLockTensorBuffer( + tensor_buffer: LiteRtTensorBuffer, + host_mem_addr: *mut *mut ::std::os::raw::c_void, + lock_mode: LiteRtTensorBufferLockMode, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtUnlockTensorBuffer(buffer: LiteRtTensorBuffer) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtClearTensorBuffer(buffer: LiteRtTensorBuffer) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtDestroyTensorBuffer(buffer: LiteRtTensorBuffer); +} +pub const LiteRtEventTypeUnknown: LiteRtEventType = 0; +pub const LiteRtEventTypeSyncFenceFd: LiteRtEventType = 1; +pub const LiteRtEventTypeOpenCl: LiteRtEventType = 2; +pub const LiteRtEventTypeEglSyncFence: LiteRtEventType = 3; +pub const LiteRtEventTypeEglNativeSyncFence: LiteRtEventType = 4; +pub const LiteRtEventTypeCustom: LiteRtEventType = 5; +pub type LiteRtEventType = ::std::os::raw::c_uint; +pub type LiteRtCustomEvent = *mut LiteRtCustomEventT; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct LiteRtCustomEventT { + pub Retain: ::std::option::Option, + pub Release: ::std::option::Option, + pub Wait: + ::std::option::Option, + pub IsSignaled: ::std::option::Option< + unsafe extern "C" fn(event: LiteRtCustomEvent) -> ::std::os::raw::c_int, + >, + pub GetNative: ::std::option::Option< + unsafe extern "C" fn(event: LiteRtCustomEvent) -> *mut ::std::os::raw::c_void, + >, +} +extern "C" { + pub fn LiteRtCreateEventFromSyncFenceFd( + env: LiteRtEnvironment, + sync_fence_fd: ::std::os::raw::c_int, + owns_fd: bool, + event: *mut LiteRtEvent, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateEventFromOpenClEvent( + env: LiteRtEnvironment, + cl_event: LiteRtClEvent, + event: *mut LiteRtEvent, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateEventFromEglSyncFence( + env: LiteRtEnvironment, + egl_sync: LiteRtEglSyncKhr, + event: *mut LiteRtEvent, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCreateManagedEvent( + env: LiteRtEnvironment, + type_: LiteRtEventType, + event: *mut LiteRtEvent, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtSetCustomEvent( + event: LiteRtEvent, + custom_event: LiteRtCustomEvent, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetCustomEvent( + event: LiteRtEvent, + custom_event: *mut LiteRtCustomEvent, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetEventCustomNativeEvent( + event: LiteRtEvent, + native: *mut *mut ::std::os::raw::c_void, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetEventEventType(event: LiteRtEvent, type_: *mut LiteRtEventType) + -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetEventSyncFenceFd( + event: LiteRtEvent, + sync_fence_fd: *mut ::std::os::raw::c_int, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetEventOpenClEvent( + event: LiteRtEvent, + cl_event: *mut LiteRtClEvent, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetEventEglSync( + event: LiteRtEvent, + egl_sync: *mut LiteRtEglSyncKhr, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtWaitEvent(event: LiteRtEvent, timeout_in_ms: i64) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtSignalEvent(event: LiteRtEvent) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtIsEventSignaled(event: LiteRtEvent, is_signaled: *mut bool) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtDupFdEvent(event: LiteRtEvent, dup_fd: *mut ::std::os::raw::c_int) + -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtDestroyEvent(event: LiteRtEvent); +} +pub const kLiteRtSchedulingInfoFieldOriginalUid: LiteRtSchedulingInfoField = 1; +pub const kLiteRtSchedulingInfoFieldDebugFeatureId: LiteRtSchedulingInfoField = 2; +pub const kLiteRtSchedulingInfoFieldJobPriority: LiteRtSchedulingInfoField = 4; +pub const kLiteRtSchedulingInfoFieldGroupId: LiteRtSchedulingInfoField = 8; +pub type LiteRtSchedulingInfoField = ::std::os::raw::c_uint; +pub const kLiteRtSchedulingInfoGroupIdSize: _bindgen_ty_1 = 16; +pub type _bindgen_ty_1 = ::std::os::raw::c_uint; +pub const kLiteRtSchedulingInfoJobPriorityHighest: LiteRtSchedulingJobPriority = 0; +pub const kLiteRtSchedulingInfoJobPriorityLowest: LiteRtSchedulingJobPriority = 1000; +pub type LiteRtSchedulingJobPriority = ::std::os::raw::c_uint; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct LiteRtSchedulingInfo { + pub fields_mask: u32, + pub original_uid: i32, + pub debug_feature_id: *const ::std::os::raw::c_char, + pub job_priority: i32, + pub group_id: [u8; 16usize], +} +impl Default for LiteRtSchedulingInfo { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +extern "C" { + pub fn LiteRtCreateCompiledModel( + environment: LiteRtEnvironment, + model: LiteRtModel, + compilation_options: LiteRtOptions, + compiled_model: *mut LiteRtCompiledModel, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetCompiledModelInputBufferRequirements( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + input_index: LiteRtParamIndex, + buffer_requirements: *mut LiteRtTensorBufferRequirements, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetCompiledModelOutputBufferRequirements( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + output_index: LiteRtParamIndex, + buffer_requirements: *mut LiteRtTensorBufferRequirements, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetCompiledModelInputTensorLayout( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + input_index: LiteRtParamIndex, + layout: *mut LiteRtLayout, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetCompiledModelOutputTensorLayouts( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + num_layouts: usize, + layouts: *mut LiteRtLayout, + update_allocation: bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetCompiledModelEnvironment( + compiled_model: LiteRtCompiledModel, + environment: *mut LiteRtEnvironment, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtRunCompiledModel( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + num_input_buffers: usize, + input_buffers: *mut LiteRtTensorBuffer, + num_output_buffers: usize, + output_buffers: *mut LiteRtTensorBuffer, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtRunCompiledModelWithOptions( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + num_input_buffers: usize, + input_buffers: *mut LiteRtTensorBuffer, + num_output_buffers: usize, + output_buffers: *mut LiteRtTensorBuffer, + options: LiteRtOptions, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtRunCompiledModelAsync( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + num_input_buffers: usize, + input_buffers: *mut LiteRtTensorBuffer, + num_output_buffers: usize, + output_buffers: *mut LiteRtTensorBuffer, + async_: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtRunCompiledModelAsyncWithOptions( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + num_input_buffers: usize, + input_buffers: *mut LiteRtTensorBuffer, + num_output_buffers: usize, + output_buffers: *mut LiteRtTensorBuffer, + async_: *mut bool, + options: LiteRtOptions, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCompiledModelSetSchedulingInfo( + compiled_model: LiteRtCompiledModel, + scheduling_info: *const LiteRtSchedulingInfo, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtRunCompiledModelWithSchedulingInfo( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + num_input_buffers: usize, + input_buffers: *mut LiteRtTensorBuffer, + num_output_buffers: usize, + output_buffers: *mut LiteRtTensorBuffer, + scheduling_info: *const LiteRtSchedulingInfo, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtRunCompiledModelAsyncWithSchedulingInfo( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + num_input_buffers: usize, + input_buffers: *mut LiteRtTensorBuffer, + num_output_buffers: usize, + output_buffers: *mut LiteRtTensorBuffer, + async_: *mut bool, + scheduling_info: *const LiteRtSchedulingInfo, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtSetCompiledModelCancellationFunction( + compiled_model: LiteRtCompiledModel, + data: *mut ::std::os::raw::c_void, + check_cancelled_func: ::std::option::Option< + unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> bool, + >, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtDestroyCompiledModel(compiled_model: LiteRtCompiledModel); +} +extern "C" { + pub fn LiteRtCompiledModelStartMetricsCollection( + compiled_model: LiteRtCompiledModel, + detail_level: ::std::os::raw::c_int, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCompiledModelStopMetricsCollection( + compiled_model: LiteRtCompiledModel, + metrics: LiteRtMetrics, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCompiledModelIsFullyAccelerated( + compiled_model: LiteRtCompiledModel, + fully_accelerated: *mut bool, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCompiledModelGetProfiler( + compiled_model: LiteRtCompiledModel, + profiler: *mut LiteRtProfiler, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCompiledModelResizeInputTensor( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + input_index: LiteRtParamIndex, + dims: *const ::std::os::raw::c_int, + dims_size: usize, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCompiledModelResizeInputTensorNonStrict( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + input_index: LiteRtParamIndex, + dims: *const ::std::os::raw::c_int, + dims_size: usize, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCompiledModelSetDispatchAnnotation( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + key: *const ::std::os::raw::c_char, + value: *const ::std::os::raw::c_char, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCompiledModelGetDispatchAnnotation( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + key: *const ::std::os::raw::c_char, + value: *mut *const ::std::os::raw::c_char, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCompiledModelRemoveDispatchAnnotation( + compiled_model: LiteRtCompiledModel, + signature_index: LiteRtParamIndex, + key: *const ::std::os::raw::c_char, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCompiledModelReportError( + compiled_model: LiteRtCompiledModel, + format: *const ::std::os::raw::c_char, + ... + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCompiledModelClearErrors(compiled_model: LiteRtCompiledModel) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtCompiledModelGetErrorMessages( + compiled_model: LiteRtCompiledModel, + error_messages: *mut *mut ::std::os::raw::c_char, + ) -> LiteRtStatus; +} +pub const kLiteRtCompilerOptionsPartitionStrategyDefault: LiteRtCompilerOptionsPartitionStrategy = + 0; +pub const kLiteRtCompilerOptionsPartitionStrategyWeaklyConnected: + LiteRtCompilerOptionsPartitionStrategy = 1; +pub type LiteRtCompilerOptionsPartitionStrategy = ::std::os::raw::c_uint; +pub const kLiteRtCpuKernelModeXnnpack: LiteRtCpuKernelMode = 0; +pub const kLiteRtCpuKernelModeReference: LiteRtCpuKernelMode = 1; +pub const kLiteRtCpuKernelModeBuiltin: LiteRtCpuKernelMode = 2; +pub type LiteRtCpuKernelMode = ::std::os::raw::c_uint; +pub const DEFAULT: LiteRtProfilerEventType = 1; +pub const OPERATOR_INVOKE_EVENT: LiteRtProfilerEventType = 2; +pub const DELEGATE_OPERATOR_INVOKE_EVENT: LiteRtProfilerEventType = 4; +pub const DELEGATE_PROFILED_OPERATOR_INVOKE_EVENT: LiteRtProfilerEventType = 8; +pub const GENERAL_RUNTIME_INSTRUMENTATION_EVENT: LiteRtProfilerEventType = 16; +pub const TELEMETRY_EVENT: LiteRtProfilerEventType = 32; +pub const TELEMETRY_REPORT_SETTINGS: LiteRtProfilerEventType = 64; +pub const TELEMETRY_DELEGATE_EVENT: LiteRtProfilerEventType = 128; +pub const TELEMETRY_DELEGATE_REPORT_SETTINGS: LiteRtProfilerEventType = 256; +pub type LiteRtProfilerEventType = ::std::os::raw::c_uint; +#[repr(C)] +#[derive(Debug, Default, Copy, Clone)] +pub struct LiteRtMemoryUsage { + pub total_allocated_bytes: usize, + pub in_use_allocated_bytes: usize, + pub private_footprint_bytes: usize, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct LiteRtMetric { + pub name: *const ::std::os::raw::c_char, + pub value: LiteRtAny, +} +impl Default for LiteRtMetric { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +extern "C" { + pub fn LiteRtCreateMetrics(metrics: *mut LiteRtMetrics) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetNumMetrics( + metrics: LiteRtMetrics, + num_metrics: *mut ::std::os::raw::c_int, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetMetric( + metrics: LiteRtMetrics, + metric_index: ::std::os::raw::c_int, + metric: *mut LiteRtMetric, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtDestroyMetrics(metrics: LiteRtMetrics); +} +pub const kLiteRtLogSeverityDebug: LiteRtLogSeverity = -1; +pub const kLiteRtLogSeverityVerbose: LiteRtLogSeverity = 0; +pub const kLiteRtLogSeverityInfo: LiteRtLogSeverity = 1; +pub const kLiteRtLogSeverityWarning: LiteRtLogSeverity = 2; +pub const kLiteRtLogSeverityError: LiteRtLogSeverity = 3; +pub const kLiteRtLogSeveritySilent: LiteRtLogSeverity = 4; +pub type LiteRtLogSeverity = i8; +extern "C" { + pub fn LiteRtGetLogSeverityName(severity: LiteRtLogSeverity) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn LiteRtCreateLogger(logger: *mut LiteRtLogger) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetMinLoggerSeverity( + logger: LiteRtLogger, + min_severity: *mut LiteRtLogSeverity, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtSetMinLoggerSeverity( + logger: LiteRtLogger, + min_severity: LiteRtLogSeverity, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtLoggerLog( + logger: LiteRtLogger, + severity: LiteRtLogSeverity, + format: *const ::std::os::raw::c_char, + ... + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetLoggerIdentifier( + logger: LiteRtLoggerConst, + identifier: *mut *const ::std::os::raw::c_char, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtDestroyLogger(logger: LiteRtLogger); +} +extern "C" { + pub fn LiteRtCreateSinkLogger(logger: *mut LiteRtLogger) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSinkLoggerSize(logger: LiteRtLogger, size: *mut usize) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetSinkLoggerMessage( + logger: LiteRtLogger, + idx: usize, + message: *mut *const ::std::os::raw::c_char, + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtClearSinkLogger(logger: LiteRtLogger) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtGetDefaultLogger() -> LiteRtLogger; +} +extern "C" { + pub fn LiteRtSetDefaultLogger(logger: LiteRtLogger) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtDefaultLoggerLog( + severity: LiteRtLogSeverity, + format: *const ::std::os::raw::c_char, + ... + ) -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtUseStandardLogger() -> LiteRtStatus; +} +extern "C" { + pub fn LiteRtUseSinkLogger() -> LiteRtStatus; +}