use std::ffi::{c_char, c_void, CStr, CString};
use std::path::{Path, PathBuf};
use std::sync::{Mutex, OnceLock};
use libloading::Library;
use crate::assets::{ensure_assets, native_library_from_assets};
use crate::error::Error;
use crate::ffi::{
ConfigInitFn, ConsolidateJsonFn, CreateWithConfigAndObjectFn, CreateWithConfigFn,
CreateWithStoreAndObjectFn, CreateWithStoreFn, EmbedAudioJsonFn, EmbedImageJsonFn,
EmbedTextJsonFn, FreeFn, LastErrorFn, NativeConfig, NativeDbCallbacks, NativeMedia,
NativeObjectCallbacks, NativeProcessOptions, ProcessAudioJsonOptsFn, ProcessAudioMediaOptsFn,
ProcessImageJsonOptsFn, ProcessImageMediaOptsFn, ProcessJsonOptionsInitFn,
ProcessTextJsonOptsFn, ProcessTextMediaOptsFn, StatusFn, StringFreeFn, VersionFn,
};
struct Native {
_lib: Library,
config_init: ConfigInitFn,
create_with_config: CreateWithConfigFn,
create_with_store: Option<CreateWithStoreFn>,
create_with_store_and_object: Option<CreateWithStoreAndObjectFn>,
create_with_config_and_object: Option<CreateWithConfigAndObjectFn>,
free: FreeFn,
process_text_json_opts: ProcessTextJsonOptsFn,
process_text_media_opts: Option<ProcessTextMediaOptsFn>,
embed_text_json: EmbedTextJsonFn,
process_audio_json_opts: ProcessAudioJsonOptsFn,
process_audio_media_opts: ProcessAudioMediaOptsFn,
embed_audio_json: EmbedAudioJsonFn,
process_image_json_opts: ProcessImageJsonOptsFn,
process_image_media_opts: ProcessImageMediaOptsFn,
embed_image_json: EmbedImageJsonFn,
consolidate_json: ConsolidateJsonFn,
flush: StatusFn,
reset: StatusFn,
version: VersionFn,
last_error: LastErrorFn,
string_free: StringFreeFn,
process_json_options_init: ProcessJsonOptionsInitFn,
}
struct Loaded {
native: Native,
path: PathBuf,
}
static LOADED: OnceLock<Mutex<Option<Result<Loaded, Error>>>> = OnceLock::new();
fn loaded_slot() -> &'static Mutex<Option<Result<Loaded, Error>>> {
LOADED.get_or_init(|| Mutex::new(None))
}
pub(crate) fn platform_tag() -> String {
let os = if cfg!(target_os = "macos") {
"macos"
} else if cfg!(target_os = "windows") {
"windows"
} else if cfg!(target_os = "linux") {
"linux"
} else {
std::env::consts::OS
};
let arch = if cfg!(target_arch = "x86_64") {
"x86_64"
} else if cfg!(target_arch = "aarch64") {
"aarch64"
} else {
std::env::consts::ARCH
};
format!("{os}-{arch}")
}
pub(crate) fn library_name_for_tag(tag: &str) -> &'static str {
if tag.starts_with("macos") {
"libcortext.dylib"
} else if tag.starts_with("windows") {
"cortext.dll"
} else {
"libcortext.so"
}
}
fn resolve_library_path() -> Result<PathBuf, Error> {
if let Ok(env) = std::env::var("CORTEXT_LIBRARY_PATH") {
let path = PathBuf::from(env);
if !path.is_file() {
return Err(Error::new(format!(
"CORTEXT_LIBRARY_PATH is missing or not a file: {}",
path.display()
)));
}
return Ok(std::fs::canonicalize(&path).unwrap_or(path));
}
let root = ensure_assets()?;
let path = native_library_from_assets(&root);
if !path.is_file() {
return Err(Error::new(format!(
"release assets missing native library for {} at {}",
platform_tag(),
path.display()
)));
}
Ok(std::fs::canonicalize(&path).unwrap_or(path))
}
fn symbol<T>(lib: &Library, name: &[u8]) -> Result<T, Error>
where
T: Copy,
{
let sym = unsafe { lib.get::<T>(name) }?;
Ok(*sym)
}
fn load_native(path: &Path) -> Result<Native, Error> {
let lib = unsafe { Library::new(path) }?;
let process_text_media_opts = unsafe {
lib.get::<ProcessTextMediaOptsFn>(b"cortext_process_text_with_media_json_with_options\0")
.ok()
.map(|s| *s)
};
let create_with_store = unsafe {
lib.get::<CreateWithStoreFn>(b"cortext_create_with_store_callbacks\0")
.ok()
.map(|s| *s)
};
let create_with_store_and_object = unsafe {
lib.get::<CreateWithStoreAndObjectFn>(b"cortext_create_with_store_and_object_callbacks\0")
.ok()
.map(|s| *s)
};
let create_with_config_and_object = unsafe {
lib.get::<CreateWithConfigAndObjectFn>(b"cortext_create_with_config_and_object_callbacks\0")
.ok()
.map(|s| *s)
};
Ok(Native {
config_init: symbol(&lib, b"cortext_config_init\0")?,
create_with_config: symbol(&lib, b"cortext_create_with_config\0")?,
create_with_store,
create_with_store_and_object,
create_with_config_and_object,
free: symbol(&lib, b"cortext_free\0")?,
process_text_json_opts: symbol(&lib, b"cortext_process_text_json_with_options\0")?,
process_text_media_opts,
embed_text_json: symbol(&lib, b"cortext_embed_text_json\0")?,
process_audio_json_opts: symbol(&lib, b"cortext_process_audio_json_with_options\0")?,
process_audio_media_opts: symbol(
&lib,
b"cortext_process_audio_with_media_json_with_options\0",
)?,
embed_audio_json: symbol(&lib, b"cortext_embed_audio_json\0")?,
process_image_json_opts: symbol(&lib, b"cortext_process_image_json_with_options\0")?,
process_image_media_opts: symbol(
&lib,
b"cortext_process_image_with_media_json_with_options\0",
)?,
embed_image_json: symbol(&lib, b"cortext_embed_image_json\0")?,
consolidate_json: symbol(&lib, b"cortext_consolidate_json\0")?,
flush: symbol(&lib, b"cortext_flush\0")?,
reset: symbol(&lib, b"cortext_reset\0")?,
version: symbol(&lib, b"cortext_version\0")?,
last_error: symbol(&lib, b"cortext_last_error\0")?,
string_free: symbol(&lib, b"cortext_string_free\0")?,
process_json_options_init: symbol(&lib, b"cortext_process_json_options_init\0")?,
_lib: lib,
})
}
fn ensure_loaded() -> Result<(), Error> {
let mut slot = loaded_slot()
.lock()
.map_err(|_| Error::new("library lock poisoned"))?;
if slot.is_none() {
*slot = Some(match resolve_library_path() {
Ok(path) => match load_native(&path) {
Ok(native) => Ok(Loaded { native, path }),
Err(err) => Err(Error::new(format!(
"load library {}: {err}",
path.display()
))),
},
Err(err) => Err(Error::new(format!(
"could not load Cortext shared library for {}: {err}\nset CORTEXT_LIBRARY_PATH, CORTEXT_ASSETS_DIR, or allow download of github.com/augmem/cortext.cpp release assets v{}",
platform_tag(),
crate::assets::assets_version()
))),
});
}
match slot.as_ref() {
Some(Ok(_)) => Ok(()),
Some(Err(err)) => Err(err.clone()),
None => Err(Error::new("library load slot empty")),
}
}
fn with_native<T>(f: impl FnOnce(&Native) -> T) -> Result<T, Error> {
ensure_loaded()?;
let slot = loaded_slot()
.lock()
.map_err(|_| Error::new("library lock poisoned"))?;
match slot.as_ref() {
Some(Ok(loaded)) => Ok(f(&loaded.native)),
Some(Err(err)) => Err(err.clone()),
None => Err(Error::new("native library is not loaded")),
}
}
pub fn load_library() -> Result<(), Error> {
ensure_loaded()
}
pub fn load_library_from(path: impl AsRef<Path>) -> Result<(), Error> {
let path = path.as_ref();
if !path.is_file() {
return Err(Error::new(format!(
"CORTEXT library path does not exist: {}",
path.display()
)));
}
let path = std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf());
let mut slot = loaded_slot()
.lock()
.map_err(|_| Error::new("library lock poisoned"))?;
match load_native(&path) {
Ok(native) => {
*slot = Some(Ok(Loaded { native, path }));
Ok(())
}
Err(err) => {
let err = Error::new(format!("load library {}: {err}", path.display()));
*slot = Some(Err(err.clone()));
Err(err)
}
}
}
pub fn library_path() -> Option<PathBuf> {
loaded_slot()
.lock()
.ok()
.and_then(|slot| match slot.as_ref() {
Some(Ok(loaded)) => Some(loaded.path.clone()),
_ => None,
})
}
pub(crate) fn native_version() -> String {
match with_native(|n| unsafe { cstr_owned((n.version)()) }) {
Ok(v) => v,
Err(_) => String::new(),
}
}
pub(crate) fn native_last_error() -> String {
match with_native(|n| unsafe { cstr_owned((n.last_error)()) }) {
Ok(v) => v,
Err(err) => err.to_string(),
}
}
pub(crate) fn last_error_as_error() -> Error {
let msg = native_last_error();
if msg.is_empty() {
Error::new("cortext call failed")
} else {
Error::new(msg)
}
}
unsafe fn cstr_owned(ptr: *const c_char) -> String {
if ptr.is_null() {
return String::new();
}
CStr::from_ptr(ptr).to_string_lossy().into_owned()
}
pub(crate) fn take_json_string(ptr: *mut c_char) -> Result<Vec<u8>, Error> {
if ptr.is_null() {
return Err(last_error_as_error());
}
let result = unsafe { cstr_owned(ptr) };
with_native(|n| unsafe { (n.string_free)(ptr) })?;
Ok(result.into_bytes())
}
pub(crate) fn config_init(cfg: &mut NativeConfig) -> Result<(), Error> {
with_native(|n| unsafe { (n.config_init)(cfg) })
}
pub(crate) fn process_json_options_init(opts: &mut NativeProcessOptions) -> Result<(), Error> {
with_native(|n| unsafe { (n.process_json_options_init)(opts) })
}
pub(crate) fn create_with_config(
cfg: &NativeConfig,
db_path: &CString,
) -> Result<*mut c_void, Error> {
with_native(|n| unsafe { (n.create_with_config)(cfg, db_path.as_ptr()) })
}
fn missing_symbol(name: &str) -> Error {
Error::new(format!(
"native library is missing {name}; update cortext.cpp assets to a release that exports store callbacks"
))
}
pub(crate) fn create_with_store(
cfg: &NativeConfig,
callbacks: &NativeDbCallbacks,
user_data: *mut c_void,
) -> Result<*mut c_void, Error> {
with_native(|n| {
let f = n
.create_with_store
.ok_or_else(|| missing_symbol("cortext_create_with_store_callbacks"))?;
Ok(unsafe { f(cfg, callbacks, user_data) })
})?
}
pub(crate) fn create_with_store_and_object(
cfg: &NativeConfig,
db_callbacks: &NativeDbCallbacks,
db_user_data: *mut c_void,
object_callbacks: &NativeObjectCallbacks,
object_user_data: *mut c_void,
) -> Result<*mut c_void, Error> {
with_native(|n| {
let f = n.create_with_store_and_object.ok_or_else(|| {
missing_symbol("cortext_create_with_store_and_object_callbacks")
})?;
Ok(unsafe { f(cfg, db_callbacks, db_user_data, object_callbacks, object_user_data) })
})?
}
pub(crate) fn create_with_config_and_object(
cfg: &NativeConfig,
db_path: &CString,
object_callbacks: &NativeObjectCallbacks,
object_user_data: *mut c_void,
) -> Result<*mut c_void, Error> {
with_native(|n| {
let f = n.create_with_config_and_object.ok_or_else(|| {
missing_symbol("cortext_create_with_config_and_object_callbacks")
})?;
Ok(unsafe { f(cfg, db_path.as_ptr(), object_callbacks, object_user_data) })
})?
}
pub(crate) fn free_handle(ptr: *mut c_void) {
let _ = with_native(|n| unsafe { (n.free)(ptr) });
}
pub(crate) fn has_process_text_media() -> bool {
with_native(|n| n.process_text_media_opts.is_some()).unwrap_or(false)
}
pub(crate) fn process_text_json_opts(
handle: *mut c_void,
text: &CString,
source_id: &CString,
options: &NativeProcessOptions,
) -> Result<*mut c_char, Error> {
with_native(|n| unsafe {
(n.process_text_json_opts)(handle, text.as_ptr(), source_id.as_ptr(), options)
})
}
pub(crate) fn process_text_media_opts(
handle: *mut c_void,
text: &CString,
source_id: &CString,
media: &NativeMedia,
options: &NativeProcessOptions,
) -> Result<*mut c_char, Error> {
with_native(|n| {
let f = n
.process_text_media_opts
.ok_or_else(|| Error::new("native library does not support text media processing"))?;
Ok(unsafe { f(handle, text.as_ptr(), source_id.as_ptr(), media, options) })
})?
}
pub(crate) fn embed_text_json(handle: *mut c_void, text: &CString) -> Result<*mut c_char, Error> {
with_native(|n| unsafe { (n.embed_text_json)(handle, text.as_ptr()) })
}
pub(crate) fn process_audio_json_opts(
handle: *mut c_void,
pcm: *const f32,
len: usize,
source_id: &CString,
options: &NativeProcessOptions,
) -> Result<*mut c_char, Error> {
with_native(|n| unsafe {
(n.process_audio_json_opts)(handle, pcm, len, source_id.as_ptr(), options)
})
}
pub(crate) fn process_audio_media_opts(
handle: *mut c_void,
pcm: *const f32,
len: usize,
source_id: &CString,
media: &NativeMedia,
options: &NativeProcessOptions,
) -> Result<*mut c_char, Error> {
with_native(|n| unsafe {
(n.process_audio_media_opts)(handle, pcm, len, source_id.as_ptr(), media, options)
})
}
pub(crate) fn embed_audio_json(
handle: *mut c_void,
pcm: *const f32,
len: usize,
) -> Result<*mut c_char, Error> {
with_native(|n| unsafe { (n.embed_audio_json)(handle, pcm, len) })
}
pub(crate) fn process_image_json_opts(
handle: *mut c_void,
data: *const u8,
width: i32,
height: i32,
channels: i32,
source_id: &CString,
options: &NativeProcessOptions,
) -> Result<*mut c_char, Error> {
with_native(|n| unsafe {
(n.process_image_json_opts)(
handle,
data,
width,
height,
channels,
source_id.as_ptr(),
options,
)
})
}
pub(crate) fn process_image_media_opts(
handle: *mut c_void,
data: *const u8,
width: i32,
height: i32,
channels: i32,
source_id: &CString,
media: &NativeMedia,
options: &NativeProcessOptions,
) -> Result<*mut c_char, Error> {
with_native(|n| unsafe {
(n.process_image_media_opts)(
handle,
data,
width,
height,
channels,
source_id.as_ptr(),
media,
options,
)
})
}
pub(crate) fn embed_image_json(
handle: *mut c_void,
data: *const u8,
width: i32,
height: i32,
channels: i32,
) -> Result<*mut c_char, Error> {
with_native(|n| unsafe { (n.embed_image_json)(handle, data, width, height, channels) })
}
pub(crate) fn consolidate_json(handle: *mut c_void) -> Result<*mut c_char, Error> {
with_native(|n| unsafe { (n.consolidate_json)(handle) })
}
pub(crate) fn flush(handle: *mut c_void) -> Result<i32, Error> {
with_native(|n| unsafe { (n.flush)(handle) })
}
pub(crate) fn reset(handle: *mut c_void) -> Result<i32, Error> {
with_native(|n| unsafe { (n.reset)(handle) })
}
#[cfg(test)]
pub(crate) fn reset_library_for_test() {
if let Ok(mut slot) = loaded_slot().lock() {
*slot = None;
}
crate::assets::reset_assets_for_test();
}