use libloading::{Library, Symbol};
use std::cell::RefCell;
use std::os::raw::{c_char, c_double, c_float};
use std::sync::Mutex;
pub struct BrukerTimsDataLibrary {
pub lib: Library,
pub handle: u64,
}
impl BrukerTimsDataLibrary {
pub fn new(
bruker_lib_path: &str,
data_path: &str,
) -> Result<BrukerTimsDataLibrary, Box<dyn std::error::Error>> {
let lib = unsafe { Library::new(bruker_lib_path)? };
let handle = unsafe {
let func: Symbol<unsafe extern "C" fn(*const c_char, u32) -> u64> =
lib.get(b"tims_open")?;
let path = std::ffi::CString::new(data_path)?;
let handle = func(path.as_ptr(), 0);
handle
};
Ok(BrukerTimsDataLibrary { lib, handle })
}
pub fn tims_close(&self) -> Result<(), Box<dyn std::error::Error>> {
unsafe {
let func: Symbol<unsafe extern "C" fn(u64) -> ()> = self.lib.get(b"tims_close")?;
func(self.handle);
}
Ok(())
}
pub fn tims_index_to_mz(
&self,
frame_id: u32,
dbl_tofs: &[c_double],
mzs: &mut [c_double],
) -> Result<(), Box<dyn std::error::Error>> {
unsafe {
let func: Symbol<unsafe extern "C" fn(u64, u32, *const c_double, *mut c_double, u32)> =
self.lib.get(b"tims_index_to_mz")?;
func(
self.handle,
frame_id,
dbl_tofs.as_ptr(),
mzs.as_mut_ptr(),
dbl_tofs.len() as u32,
);
}
Ok(())
}
pub fn tims_mz_to_index(
&self,
frame_id: u32,
mzs: &[c_double],
indices: &mut [c_double],
) -> Result<(), Box<dyn std::error::Error>> {
unsafe {
let func: Symbol<unsafe extern "C" fn(u64, u32, *const c_double, *mut c_double, u32)> =
self.lib.get(b"tims_mz_to_index")?;
func(
self.handle,
frame_id,
mzs.as_ptr(),
indices.as_mut_ptr(),
mzs.len() as u32,
);
}
Ok(())
}
pub fn tims_scan_to_inv_mob(
&self,
frame_id: u32,
dbl_scans: &[c_double],
inv_mob: &mut [c_double],
) -> Result<(), Box<dyn std::error::Error>> {
unsafe {
let func: Symbol<unsafe extern "C" fn(u64, u32, *const c_double, *mut c_double, u32)> =
self.lib.get(b"tims_scannum_to_oneoverk0")?;
func(
self.handle,
frame_id,
dbl_scans.as_ptr(),
inv_mob.as_mut_ptr(),
dbl_scans.len() as u32,
);
}
Ok(())
}
pub fn inv_mob_to_tims_scan(
&self,
frame_id: u32,
inv_mob: &[c_double],
scans: &mut [c_double],
) -> Result<(), Box<dyn std::error::Error>> {
unsafe {
let func: Symbol<unsafe extern "C" fn(u64, u32, *const c_double, *mut c_double, u32)> =
self.lib.get(b"tims_oneoverk0_to_scannum")?;
func(
self.handle,
frame_id,
inv_mob.as_ptr(),
scans.as_mut_ptr(),
inv_mob.len() as u32,
);
}
Ok(())
}
pub fn tims_extract_centroided_spectrum_for_frame(
&self,
frame_id: i64,
scan_begin: u32,
scan_end: u32,
) -> Result<(Vec<f64>, Vec<f32>), Box<dyn std::error::Error>> {
let mut result_mz: Vec<f64> = Vec::new();
let mut result_int: Vec<f32> = Vec::new();
let _guard = EXTRACT_BUF
.lock()
.map_err(|_| "EXTRACT_BUF poisoned")?;
EXTRACT_BUF_DATA.with(|buf| *buf.borrow_mut() = Some((Vec::new(), Vec::new())));
unsafe {
let func: Symbol<
unsafe extern "C" fn(
u64, i64, u32, u32,
extern "C" fn(i64, u32, *const f64, *const f32),
*mut std::ffi::c_void,
) -> u32,
> = self.lib.get(b"tims_extract_centroided_spectrum_for_frame_v2")?;
let rc = func(
self.handle,
frame_id,
scan_begin,
scan_end,
centroid_trampoline,
std::ptr::null_mut(),
);
if rc == 0 {
return Err("tims_extract_centroided_spectrum_for_frame_v2 returned 0".into());
}
}
if let Some((mz, intens)) = EXTRACT_BUF_DATA.with(|buf| buf.borrow_mut().take()) {
result_mz = mz;
result_int = intens;
}
Ok((result_mz, result_int))
}
pub fn tims_read_pasef_msms_for_frame(
&self,
frame_id: i64,
) -> Result<Vec<(i64, Vec<f64>, Vec<f32>)>, Box<dyn std::error::Error>> {
let _guard = PASEF_BUF.lock().map_err(|_| "PASEF_BUF poisoned")?;
PASEF_BUF_DATA.with(|buf| *buf.borrow_mut() = Some(Vec::new()));
unsafe {
let func: Symbol<
unsafe extern "C" fn(
u64, i64,
extern "C" fn(i64, u32, *const f64, *const f32, *mut *mut std::ffi::c_void),
*mut *mut std::ffi::c_void,
) -> u32,
> = self.lib.get(b"tims_read_pasef_msms_for_frame_v2")?;
let rc = func(
self.handle,
frame_id,
pasef_trampoline,
std::ptr::null_mut(),
);
if rc == 0 {
return Err("tims_read_pasef_msms_for_frame_v2 returned 0".into());
}
}
let out = PASEF_BUF_DATA.with(|buf| buf.borrow_mut().take()).unwrap_or_default();
Ok(out)
}
}
static EXTRACT_BUF: Mutex<()> = Mutex::new(());
thread_local! {
static EXTRACT_BUF_DATA: RefCell<Option<(Vec<f64>, Vec<f32>)>> = const { RefCell::new(None) };
}
extern "C" fn centroid_trampoline(
_precursor_id: i64,
n_peaks: u32,
mzs: *const f64,
intensities: *const f32,
) {
if n_peaks == 0 || mzs.is_null() || intensities.is_null() { return; }
let mz_slice = unsafe { std::slice::from_raw_parts(mzs, n_peaks as usize) };
let in_slice = unsafe { std::slice::from_raw_parts(intensities, n_peaks as usize) };
EXTRACT_BUF_DATA.with(|buf| {
if let Some((ref mut mz_acc, ref mut in_acc)) = *buf.borrow_mut() {
mz_acc.extend_from_slice(mz_slice);
in_acc.extend_from_slice(in_slice);
}
});
}
static PASEF_BUF: Mutex<()> = Mutex::new(());
thread_local! {
static PASEF_BUF_DATA: RefCell<Option<Vec<(i64, Vec<f64>, Vec<f32>)>>> = const { RefCell::new(None) };
}
extern "C" fn pasef_trampoline(
precursor_id: i64,
n_peaks: u32,
mzs: *const f64,
intensities: *const f32,
_user_data: *mut *mut std::ffi::c_void,
) {
if n_peaks == 0 || mzs.is_null() || intensities.is_null() { return; }
let mz_slice = unsafe { std::slice::from_raw_parts(mzs, n_peaks as usize) };
let in_slice = unsafe { std::slice::from_raw_parts(intensities, n_peaks as usize) };
PASEF_BUF_DATA.with(|buf| {
if let Some(ref mut acc) = *buf.borrow_mut() {
acc.push((precursor_id, mz_slice.to_vec(), in_slice.to_vec()));
}
});
}
#[allow(dead_code)]
const _: fn() = || { let _: c_float = 0.0; };
impl Drop for BrukerTimsDataLibrary {
fn drop(&mut self) {
let close = self.tims_close();
match close {
Ok(_) => (),
Err(e) => println!("error: {}", e),
};
}
}