Rust bindgen use of pointer addresse `*mut i8` for allocating memory for camera, getting "cannot be sent between threads safely"

Question

tl&dr: How to work with *mut i8 so it is thread safe for use in lazy_static! Mutex ?

I have a function that generates a pointer address in the form of *mut i8, which I want to store in a struct that is initiated by

lazy_static! {static ref HARDWARE: Mutex<HardwareT> = Mutex::new(HardwareT::new());}

I get

error[E0277]: `*mut i8` cannot be sent between threads safely
  --> src\lib.rs:21:1
   |
21 | / lazy_static! {
22 | |     static ref HARDWARE: Mutex<HardwareT> = Mutex::new(HardwareT::new());
23 | | }
   | |_^ `*mut i8` cannot be sent between threads safely
   |
   = help: the trait `Send` is not implemented for `*mut i8`
   = note: required for `Unique<*mut i8>` to implement `Send`
   = note: required because it appears within the type `Box<*mut i8>`

Complete story

I'm using rust bindgen to control a ueye camera.

The way it takes a picture, is it allocates a given amount of memory and the user has to pass the pointer address between functions (I guess something Rust is not very happy with). To describe my question, I'll use the python code and then show where I'm having issues. (without the actual hardware, it is difficult to make a MVE).

python example code: https://fr.ids-imaging.com/programming-examples-details/simple-live-image-acquisition-with-the-python-interface-pyueye.html

# SimpleLive_Pyueye_OpenCV.py
# In the python example, we first generate a pointer address that we keep in a variable
pcImageMemory = ueye.c_mem_p()
...

# Then we allocate the memory through the C api 
err = ueye.is_AllocImageMem(..some args..,  pcImageMemory, ..more args..)
check(err)
...

#Later on, we call this memory address to get the array
array = ueye.get_data(pcImageMemory, ..more args..)

Here is the original C definition from the documentation.

INT is_AllocImageMem (..some args.., char** ppcMem, ..more args..)

Now, in rust, the generated function to allocate the memory is

// bindings.rs generated code 
extern "C" {
    pub fn is_AllocImageMem(
        ..some args..,
        ppcMem: *mut *mut ::std::os::raw::c_char,
        ..more args..
    ) -> INT;
}

I thus need a *mut *mut i8, which I managed to get working with this code,

pub fn allocate_img_memory(..some args..) -> Result<*mut i8, MessageError> {
    let mut pc_image_memory =  Box::into_raw(Box::new(0i8)) as *mut i8;
    let err = unsafe { 
        ueye::is_AllocImageMem(
             ..some args.., 
             &mut  pc_image_memory as *mut  *mut i8, 
             ..more args..
        ) };
   
    check(err)?;
    Ok(pc_image_memory))
}

This system works in terms of generating the pointer address which i can use, however, this function is impl in a struct HardwareT that is initiated in lazy_static! Mutex

lazy_static! {static ref HARDWARE: Mutex<HardwareT> = Mutex::new(HardwareT::new());}

therefore I get the error message about thread safety.

Question: How to convert pc_image_memory so as to keep the thread safety and store it in my struct?

---

Edit 1 : here how the hardware struct is defined in this example

pub struct HardwareT{
    image_memory: *mut i8,
}