diff --git a/Cargo.lock b/Cargo.lock index 31348cce..7b9d9604 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1546,6 +1546,14 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "larod-sys" +version = "0.0.0" +dependencies = [ + "bindgen 0.69.5", + "pkg-config", +] + [[package]] name = "lazy_static" version = "1.4.0" @@ -1571,7 +1579,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0c2a198fb6b0eada2a8df47933734e6d35d350665a33a3593d7164fa52c75c19" dependencies = [ "cfg-if", - "windows-targets 0.48.5", + "windows-targets 0.52.6", ] [[package]] @@ -1803,6 +1811,16 @@ dependencies = [ "memchr", ] +[[package]] +name = "object_detection" +version = "0.0.0" +dependencies = [ + "acap-logging", + "anyhow", + "larod-sys", + "log", +] + [[package]] name = "once_cell" version = "1.19.0" diff --git a/Cargo.toml b/Cargo.toml index 467ac122..7ab2ae02 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -58,6 +58,7 @@ bbox-sys = { path = "crates/bbox-sys" } cargo-acap-build = { path = "crates/cargo-acap-build" } cli-version = { path = "crates/cli-version" } device-manager = { path = "crates/device-manager" } +larod-sys = { path = "crates/larod-sys" } licensekey = { path = "crates/licensekey" } licensekey-sys = { path = "crates/licensekey-sys" } mdb = { path = "crates/mdb" } diff --git a/apps-aarch64.checksum b/apps-aarch64.checksum index 36b73eb5..ea9671cf 100644 --- a/apps-aarch64.checksum +++ b/apps-aarch64.checksum @@ -8,6 +8,7 @@ dfd925c003c30164c00dfc51676b6e1317a0fa6d target-aarch64/acap/consume_analytics_ 5712d955c8ea45a774597a6032a16af72a24e118 target-aarch64/acap/hello_world_0_0_0_aarch64.eap 222f821339cf36e88596d85427740de3536573bf target-aarch64/acap/inspect_env_0_0_0_aarch64.eap 74d6106b8f0afe7e3342ae3b470d8b81e7aa5150 target-aarch64/acap/licensekey_handler_0_0_0_aarch64.eap +9deb95dbb3d67596d9f7cbc2aa05b3fb4d812025 target-aarch64/acap/object_detection_1_0_0_aarch64.eap 5dc0969dcbe6ca09aabcef9530a0f77786932b22 target-aarch64/acap/reverse_proxy_0_0_0_aarch64.eap c94b3ba49a3897617dc13599ffbc0642681133e5 target-aarch64/acap/send_event_1_0_0_aarch64.eap 9df8dead66b245aa19d3aafa758871118b8cc25f target-aarch64/acap/using_a_build_script_0_0_0_aarch64.eap diff --git a/apps-aarch64.filesize b/apps-aarch64.filesize index d71f8225..5523d3aa 100644 --- a/apps-aarch64.filesize +++ b/apps-aarch64.filesize @@ -8,6 +8,7 @@ 1406 target-aarch64/acap/hello_world_0_0_0_aarch64.eap 1441 target-aarch64/acap/inspect_env_0_0_0_aarch64.eap 1430 target-aarch64/acap/licensekey_handler_0_0_0_aarch64.eap +1408 target-aarch64/acap/object_detection_1_0_0_aarch64.eap 10362 target-aarch64/acap/reverse_proxy_0_0_0_aarch64.eap 3430 target-aarch64/acap/send_event_1_0_0_aarch64.eap 899 target-aarch64/acap/using_a_build_script_0_0_0_aarch64.eap diff --git a/apps/object_detection/Cargo.toml b/apps/object_detection/Cargo.toml new file mode 100644 index 00000000..d865c7fa --- /dev/null +++ b/apps/object_detection/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "object_detection" +version = "0.0.0" +edition.workspace = true +publish = false + +[dependencies] +anyhow = { workspace = true } +log = { workspace = true } + +acap-logging = { workspace = true } +larod-sys = { workspace = true } diff --git a/apps/object_detection/manifest.json b/apps/object_detection/manifest.json new file mode 100644 index 00000000..df03f595 --- /dev/null +++ b/apps/object_detection/manifest.json @@ -0,0 +1,11 @@ +{ + "schemaVersion": "1.4.0", + "acapPackageConf": { + "setup": { + "appName": "object_detection", + "vendor": "Axis Communications", + "runMode": "never", + "version": "1.0.0" + } + } +} diff --git a/apps/object_detection/src/main.rs b/apps/object_detection/src/main.rs new file mode 100644 index 00000000..09d06797 --- /dev/null +++ b/apps/object_detection/src/main.rs @@ -0,0 +1,35 @@ +//! This application loads a larod model which takes an image as input and outputs values +//! corresponding to the class, score and location of detected objects in the image. +//! +//! # Arguments +//! +//! 1. `MODEL`: a string describing the path to the model. +//! 2. `WIDTH`: an integer for the input width. ß +//! 3. `HEIGHT`: an integer for the input height. +//! 4. `QUALITY`: an integer for the desired jpeg quality. +//! 5. `RAW_WIDTH`: an integer for camera width resolution. +//! 6. `RAW_HEIGHT`: an integer for camera height resolution. +//! 7. `THRESHOLD`: an integer ranging from 0 to 100 to select good detections. +//! 8. `LABELSFILE`: a string describing the path to the label txt. + +use log::{error, info}; + +fn main() { + acap_logging::init_logger(); + let mut conn: *mut larod_sys::larodConnection = std::ptr::null_mut(); + let mut error: *mut larod_sys::larodError = std::ptr::null_mut(); + if unsafe { !larod_sys::larodConnect(&mut conn, &mut error) } { + error!("Could not connect to larod"); + return; + } + assert!(error.is_null()); + + let mut num_sessions = u64::MAX; + if unsafe { !larod_sys::larodGetNumSessions(conn, &mut num_sessions, &mut error) } { + error!("Could not get the number of sessions"); + return; + } + + info!("Number of sessions: {num_sessions}"); + todo!("Implement the real example") +} diff --git a/crates/larod-sys/Cargo.toml b/crates/larod-sys/Cargo.toml new file mode 100644 index 00000000..02a7f561 --- /dev/null +++ b/crates/larod-sys/Cargo.toml @@ -0,0 +1,10 @@ +[package] +build = "build.rs" +name = "larod-sys" +version = "0.0.0" +edition.workspace = true +license = "MIT" + +[build-dependencies] +bindgen = { workspace = true } +pkg-config = { workspace = true } diff --git a/crates/larod-sys/build.rs b/crates/larod-sys/build.rs new file mode 100644 index 00000000..a155cea7 --- /dev/null +++ b/crates/larod-sys/build.rs @@ -0,0 +1,27 @@ +use std::{env, path}; + +fn populated_bindings(dst: &path::PathBuf) { + let library = pkg_config::Config::new().probe("liblarod").unwrap(); + let mut bindings = bindgen::Builder::default() + .header("wrapper.h") + .allowlist_recursively(false) + .allowlist_function("^(larod.*)$") + .allowlist_type("^(_?larod.*)$") + .default_enum_style(bindgen::EnumVariation::NewType { + is_global: false, + is_bitfield: true, + }) + .parse_callbacks(Box::new(bindgen::CargoCallbacks::new())) + .layout_tests(false); + for path in library.include_paths { + bindings = bindings.clang_args(&["-F", path.to_str().unwrap()]); + } + bindings.generate().unwrap().write_to_file(dst).unwrap(); +} + +fn main() { + let dst = path::PathBuf::from(env::var("OUT_DIR").unwrap()).join("bindings.rs"); + if env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default() != "x86_64" { + populated_bindings(&dst); + } +} diff --git a/crates/larod-sys/src/bindings.rs b/crates/larod-sys/src/bindings.rs new file mode 100644 index 00000000..716de3c3 --- /dev/null +++ b/crates/larod-sys/src/bindings.rs @@ -0,0 +1,747 @@ +/* automatically generated by rust-bindgen 0.69.5 */ + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct larodDevice { + _unused: [u8; 0], +} +impl larodAccess { + pub const LAROD_ACCESS_INVALID: larodAccess = larodAccess(0); +} +impl larodAccess { + pub const LAROD_ACCESS_PRIVATE: larodAccess = larodAccess(1); +} +impl larodAccess { + pub const LAROD_ACCESS_PUBLIC: larodAccess = larodAccess(2); +} +impl ::std::ops::BitOr for larodAccess { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + larodAccess(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for larodAccess { + #[inline] + fn bitor_assign(&mut self, rhs: larodAccess) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for larodAccess { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + larodAccess(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for larodAccess { + #[inline] + fn bitand_assign(&mut self, rhs: larodAccess) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct larodAccess(pub ::std::os::raw::c_uint); +impl larodErrorCode { + pub const LAROD_ERROR_NONE: larodErrorCode = larodErrorCode(0); +} +impl larodErrorCode { + pub const LAROD_ERROR_JOB: larodErrorCode = larodErrorCode(-1); +} +impl larodErrorCode { + pub const LAROD_ERROR_LOAD_MODEL: larodErrorCode = larodErrorCode(-2); +} +impl larodErrorCode { + pub const LAROD_ERROR_FD: larodErrorCode = larodErrorCode(-3); +} +impl larodErrorCode { + pub const LAROD_ERROR_MODEL_NOT_FOUND: larodErrorCode = larodErrorCode(-4); +} +impl larodErrorCode { + pub const LAROD_ERROR_PERMISSION: larodErrorCode = larodErrorCode(-5); +} +impl larodErrorCode { + pub const LAROD_ERROR_CONNECTION: larodErrorCode = larodErrorCode(-6); +} +impl larodErrorCode { + pub const LAROD_ERROR_CREATE_SESSION: larodErrorCode = larodErrorCode(-7); +} +impl larodErrorCode { + pub const LAROD_ERROR_KILL_SESSION: larodErrorCode = larodErrorCode(-8); +} +impl larodErrorCode { + pub const LAROD_ERROR_INVALID_CHIP_ID: larodErrorCode = larodErrorCode(-9); +} +impl larodErrorCode { + pub const LAROD_ERROR_INVALID_ACCESS: larodErrorCode = larodErrorCode(-10); +} +impl larodErrorCode { + pub const LAROD_ERROR_DELETE_MODEL: larodErrorCode = larodErrorCode(-11); +} +impl larodErrorCode { + pub const LAROD_ERROR_TENSOR_MISMATCH: larodErrorCode = larodErrorCode(-12); +} +impl larodErrorCode { + pub const LAROD_ERROR_VERSION_MISMATCH: larodErrorCode = larodErrorCode(-13); +} +impl larodErrorCode { + pub const LAROD_ERROR_ALLOC: larodErrorCode = larodErrorCode(-14); +} +impl larodErrorCode { + pub const LAROD_ERROR_POWER_NOT_AVAILABLE: larodErrorCode = larodErrorCode(-15); +} +impl larodErrorCode { + pub const LAROD_ERROR_MAX_ERRNO: larodErrorCode = larodErrorCode(1024); +} +impl ::std::ops::BitOr for larodErrorCode { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + larodErrorCode(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for larodErrorCode { + #[inline] + fn bitor_assign(&mut self, rhs: larodErrorCode) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for larodErrorCode { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + larodErrorCode(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for larodErrorCode { + #[inline] + fn bitand_assign(&mut self, rhs: larodErrorCode) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct larodErrorCode(pub ::std::os::raw::c_int); +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_INVALID: larodTensorDataType = larodTensorDataType(0); +} +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_UNSPECIFIED: larodTensorDataType = larodTensorDataType(1); +} +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_BOOL: larodTensorDataType = larodTensorDataType(2); +} +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_UINT8: larodTensorDataType = larodTensorDataType(3); +} +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_INT8: larodTensorDataType = larodTensorDataType(4); +} +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_UINT16: larodTensorDataType = larodTensorDataType(5); +} +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_INT16: larodTensorDataType = larodTensorDataType(6); +} +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_UINT32: larodTensorDataType = larodTensorDataType(7); +} +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_INT32: larodTensorDataType = larodTensorDataType(8); +} +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_UINT64: larodTensorDataType = larodTensorDataType(9); +} +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_INT64: larodTensorDataType = larodTensorDataType(10); +} +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_FLOAT16: larodTensorDataType = larodTensorDataType(11); +} +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_FLOAT32: larodTensorDataType = larodTensorDataType(12); +} +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_FLOAT64: larodTensorDataType = larodTensorDataType(13); +} +impl larodTensorDataType { + pub const LAROD_TENSOR_DATA_TYPE_MAX: larodTensorDataType = larodTensorDataType(14); +} +impl ::std::ops::BitOr for larodTensorDataType { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + larodTensorDataType(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for larodTensorDataType { + #[inline] + fn bitor_assign(&mut self, rhs: larodTensorDataType) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for larodTensorDataType { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + larodTensorDataType(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for larodTensorDataType { + #[inline] + fn bitand_assign(&mut self, rhs: larodTensorDataType) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct larodTensorDataType(pub ::std::os::raw::c_uint); +impl larodTensorLayout { + pub const LAROD_TENSOR_LAYOUT_INVALID: larodTensorLayout = larodTensorLayout(0); +} +impl larodTensorLayout { + pub const LAROD_TENSOR_LAYOUT_UNSPECIFIED: larodTensorLayout = larodTensorLayout(1); +} +impl larodTensorLayout { + pub const LAROD_TENSOR_LAYOUT_NHWC: larodTensorLayout = larodTensorLayout(2); +} +impl larodTensorLayout { + pub const LAROD_TENSOR_LAYOUT_NCHW: larodTensorLayout = larodTensorLayout(3); +} +impl larodTensorLayout { + pub const LAROD_TENSOR_LAYOUT_420SP: larodTensorLayout = larodTensorLayout(4); +} +impl larodTensorLayout { + pub const LAROD_TENSOR_LAYOUT_MAX: larodTensorLayout = larodTensorLayout(5); +} +impl ::std::ops::BitOr for larodTensorLayout { + type Output = Self; + #[inline] + fn bitor(self, other: Self) -> Self { + larodTensorLayout(self.0 | other.0) + } +} +impl ::std::ops::BitOrAssign for larodTensorLayout { + #[inline] + fn bitor_assign(&mut self, rhs: larodTensorLayout) { + self.0 |= rhs.0; + } +} +impl ::std::ops::BitAnd for larodTensorLayout { + type Output = Self; + #[inline] + fn bitand(self, other: Self) -> Self { + larodTensorLayout(self.0 & other.0) + } +} +impl ::std::ops::BitAndAssign for larodTensorLayout { + #[inline] + fn bitand_assign(&mut self, rhs: larodTensorLayout) { + self.0 &= rhs.0; + } +} +#[repr(transparent)] +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct larodTensorLayout(pub ::std::os::raw::c_uint); +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct larodError { + pub code: larodErrorCode, + pub msg: *const ::std::os::raw::c_char, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct larodTensorDims { + pub dims: [usize; 12usize], + pub len: usize, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct larodTensorPitches { + pub pitches: [usize; 12usize], + pub len: usize, +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct larodModel { + _unused: [u8; 0], +} +pub type larodLoadModelCallback = ::std::option::Option< + unsafe extern "C" fn( + model: *mut larodModel, + userData: *mut ::std::os::raw::c_void, + error: *mut larodError, + ), +>; +pub type larodRunJobCallback = ::std::option::Option< + unsafe extern "C" fn(userData: *mut ::std::os::raw::c_void, error: *mut larodError), +>; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct larodConnection { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct larodJobRequest { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct larodTensor { + _unused: [u8; 0], +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct larodMap { + _unused: [u8; 0], +} +extern "C" { + pub fn larodClearError(error: *mut *mut larodError); +} +extern "C" { + pub fn larodConnect(conn: *mut *mut larodConnection, error: *mut *mut larodError) -> bool; +} +extern "C" { + pub fn larodDisconnect(conn: *mut *mut larodConnection, error: *mut *mut larodError) -> bool; +} +extern "C" { + pub fn larodGetNumSessions( + conn: *mut larodConnection, + numSessions: *mut u64, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodGetDevice( + conn: *const larodConnection, + name: *const ::std::os::raw::c_char, + instance: u32, + error: *mut *mut larodError, + ) -> *const larodDevice; +} +extern "C" { + pub fn larodGetDeviceName( + dev: *const larodDevice, + error: *mut *mut larodError, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn larodGetDeviceInstance( + dev: *const larodDevice, + instance: *mut u32, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodListDevices( + conn: *mut larodConnection, + numDevices: *mut usize, + error: *mut *mut larodError, + ) -> *mut *const larodDevice; +} +extern "C" { + pub fn larodLoadModel( + conn: *mut larodConnection, + fd: ::std::os::raw::c_int, + dev: *const larodDevice, + access: larodAccess, + name: *const ::std::os::raw::c_char, + params: *const larodMap, + error: *mut *mut larodError, + ) -> *mut larodModel; +} +extern "C" { + pub fn larodLoadModelAsync( + conn: *mut larodConnection, + inFd: ::std::os::raw::c_int, + dev: *const larodDevice, + access: larodAccess, + name: *const ::std::os::raw::c_char, + params: *const larodMap, + callback: larodLoadModelCallback, + userData: *mut ::std::os::raw::c_void, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodGetModel( + conn: *mut larodConnection, + modelId: u64, + error: *mut *mut larodError, + ) -> *mut larodModel; +} +extern "C" { + pub fn larodGetModels( + conn: *mut larodConnection, + numModels: *mut usize, + error: *mut *mut larodError, + ) -> *mut *mut larodModel; +} +extern "C" { + pub fn larodDestroyModel(model: *mut *mut larodModel); +} +extern "C" { + pub fn larodDestroyModels(models: *mut *mut *mut larodModel, numModels: usize); +} +extern "C" { + pub fn larodDeleteModel( + conn: *mut larodConnection, + model: *mut larodModel, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodGetModelId(model: *const larodModel, error: *mut *mut larodError) -> u64; +} +extern "C" { + pub fn larodGetModelDevice( + model: *const larodModel, + error: *mut *mut larodError, + ) -> *const larodDevice; +} +extern "C" { + pub fn larodGetModelSize(model: *const larodModel, error: *mut *mut larodError) -> usize; +} +extern "C" { + pub fn larodGetModelName( + model: *const larodModel, + error: *mut *mut larodError, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn larodGetModelAccess( + model: *const larodModel, + error: *mut *mut larodError, + ) -> larodAccess; +} +extern "C" { + pub fn larodGetModelNumInputs(model: *const larodModel, error: *mut *mut larodError) -> usize; +} +extern "C" { + pub fn larodGetModelNumOutputs(model: *const larodModel, error: *mut *mut larodError) -> usize; +} +extern "C" { + pub fn larodGetModelInputByteSizes( + model: *const larodModel, + numInputs: *mut usize, + error: *mut *mut larodError, + ) -> *mut usize; +} +extern "C" { + pub fn larodGetModelOutputByteSizes( + model: *const larodModel, + numOutputs: *mut usize, + error: *mut *mut larodError, + ) -> *mut usize; +} +extern "C" { + pub fn larodCreateModelInputs( + model: *const larodModel, + numTensors: *mut usize, + error: *mut *mut larodError, + ) -> *mut *mut larodTensor; +} +extern "C" { + pub fn larodCreateModelOutputs( + model: *const larodModel, + numTensors: *mut usize, + error: *mut *mut larodError, + ) -> *mut *mut larodTensor; +} +extern "C" { + pub fn larodAllocModelInputs( + conn: *mut larodConnection, + model: *const larodModel, + fdPropFlags: u32, + numTensors: *mut usize, + params: *mut larodMap, + error: *mut *mut larodError, + ) -> *mut *mut larodTensor; +} +extern "C" { + pub fn larodAllocModelOutputs( + conn: *mut larodConnection, + model: *const larodModel, + fdPropFlags: u32, + numTensors: *mut usize, + params: *mut larodMap, + error: *mut *mut larodError, + ) -> *mut *mut larodTensor; +} +extern "C" { + pub fn larodCreateTensors( + numTensors: usize, + error: *mut *mut larodError, + ) -> *mut *mut larodTensor; +} +extern "C" { + pub fn larodDestroyTensors( + conn: *mut larodConnection, + tensors: *mut *mut *mut larodTensor, + numTensors: usize, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodSetTensorDims( + tensor: *mut larodTensor, + dims: *const larodTensorDims, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodGetTensorDims( + tensor: *const larodTensor, + error: *mut *mut larodError, + ) -> *const larodTensorDims; +} +extern "C" { + pub fn larodSetTensorPitches( + tensor: *mut larodTensor, + pitches: *const larodTensorPitches, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodGetTensorPitches( + tensor: *const larodTensor, + error: *mut *mut larodError, + ) -> *const larodTensorPitches; +} +extern "C" { + pub fn larodSetTensorDataType( + tensor: *mut larodTensor, + dataType: larodTensorDataType, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodGetTensorDataType( + tensor: *const larodTensor, + error: *mut *mut larodError, + ) -> larodTensorDataType; +} +extern "C" { + pub fn larodSetTensorLayout( + tensor: *mut larodTensor, + layout: larodTensorLayout, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodGetTensorLayout( + tensor: *const larodTensor, + error: *mut *mut larodError, + ) -> larodTensorLayout; +} +extern "C" { + pub fn larodSetTensorFd( + tensor: *mut larodTensor, + fd: ::std::os::raw::c_int, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodGetTensorFd( + tensor: *const larodTensor, + error: *mut *mut larodError, + ) -> ::std::os::raw::c_int; +} +extern "C" { + pub fn larodSetTensorFdSize( + tensor: *mut larodTensor, + size: usize, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodGetTensorFdSize( + tensor: *const larodTensor, + size: *mut usize, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodSetTensorFdOffset( + tensor: *mut larodTensor, + offset: i64, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodGetTensorFdOffset(tensor: *const larodTensor, error: *mut *mut larodError) -> i64; +} +extern "C" { + pub fn larodTrackTensor( + conn: *mut larodConnection, + tensor: *mut larodTensor, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodSetTensorFdProps( + tensor: *mut larodTensor, + fdPropFlags: u32, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodGetTensorFdProps( + tensor: *const larodTensor, + fdPropFlags: *mut u32, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodGetTensorName( + tensor: *const larodTensor, + error: *mut *mut larodError, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn larodGetTensorByteSize( + tensor: *const larodTensor, + byteSize: *mut usize, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodCreateMap(error: *mut *mut larodError) -> *mut larodMap; +} +extern "C" { + pub fn larodDestroyMap(map: *mut *mut larodMap); +} +extern "C" { + pub fn larodMapSetStr( + map: *mut larodMap, + key: *const ::std::os::raw::c_char, + value: *const ::std::os::raw::c_char, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodMapSetInt( + map: *mut larodMap, + key: *const ::std::os::raw::c_char, + value: i64, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodMapSetIntArr2( + map: *mut larodMap, + key: *const ::std::os::raw::c_char, + value0: i64, + value1: i64, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodMapSetIntArr4( + map: *mut larodMap, + key: *const ::std::os::raw::c_char, + value0: i64, + value1: i64, + value2: i64, + value3: i64, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodMapGetStr( + map: *mut larodMap, + key: *const ::std::os::raw::c_char, + error: *mut *mut larodError, + ) -> *const ::std::os::raw::c_char; +} +extern "C" { + pub fn larodMapGetInt( + map: *mut larodMap, + key: *const ::std::os::raw::c_char, + value: *mut i64, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodMapGetIntArr2( + map: *mut larodMap, + key: *const ::std::os::raw::c_char, + error: *mut *mut larodError, + ) -> *const i64; +} +extern "C" { + pub fn larodMapGetIntArr4( + map: *mut larodMap, + key: *const ::std::os::raw::c_char, + error: *mut *mut larodError, + ) -> *const i64; +} +extern "C" { + pub fn larodCreateJobRequest( + model: *const larodModel, + inputTensors: *mut *mut larodTensor, + numInputs: usize, + outputTensors: *mut *mut larodTensor, + numOutputs: usize, + params: *mut larodMap, + error: *mut *mut larodError, + ) -> *mut larodJobRequest; +} +extern "C" { + pub fn larodDestroyJobRequest(jobReq: *mut *mut larodJobRequest); +} +extern "C" { + pub fn larodSetJobRequestModel( + jobReq: *mut larodJobRequest, + model: *const larodModel, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodSetJobRequestInputs( + jobReq: *mut larodJobRequest, + tensors: *mut *mut larodTensor, + numTensors: usize, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodSetJobRequestOutputs( + jobReq: *mut larodJobRequest, + tensors: *mut *mut larodTensor, + numTensors: usize, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodSetJobRequestPriority( + jobReq: *mut larodJobRequest, + priority: u8, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodSetJobRequestParams( + jobReq: *mut larodJobRequest, + params: *const larodMap, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodRunJob( + conn: *mut larodConnection, + jobReq: *const larodJobRequest, + error: *mut *mut larodError, + ) -> bool; +} +extern "C" { + pub fn larodRunJobAsync( + conn: *mut larodConnection, + jobReq: *const larodJobRequest, + callback: larodRunJobCallback, + userData: *mut ::std::os::raw::c_void, + error: *mut *mut larodError, + ) -> bool; +} diff --git a/crates/larod-sys/src/lib.rs b/crates/larod-sys/src/lib.rs new file mode 100644 index 00000000..6cfa7580 --- /dev/null +++ b/crates/larod-sys/src/lib.rs @@ -0,0 +1,9 @@ +#![allow(non_upper_case_globals)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] + +#[cfg(not(target_arch = "x86_64"))] +include!(concat!(env!("OUT_DIR"), "/bindings.rs")); + +#[cfg(target_arch = "x86_64")] +include!("bindings.rs"); diff --git a/crates/larod-sys/wrapper.h b/crates/larod-sys/wrapper.h new file mode 100644 index 00000000..bda0612d --- /dev/null +++ b/crates/larod-sys/wrapper.h @@ -0,0 +1 @@ +#include