1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use std::ffi::c_void;

use crate::internal;

pub struct MaaImageBuffer {
    pub(crate) handle: internal::MaaImageBufferHandle,
    destroy_at_drop: bool,
}

impl From<internal::MaaImageBufferHandle> for MaaImageBuffer {
    fn from(handle: internal::MaaImageBufferHandle) -> Self {
        MaaImageBuffer {
            handle,
            destroy_at_drop: false,
        }
    }
}

unsafe impl Send for MaaImageBuffer {}
unsafe impl Sync for MaaImageBuffer {}

impl MaaImageBuffer {
    pub fn new() -> Self {
        let handle = unsafe { internal::MaaCreateImageBuffer() };

        MaaImageBuffer {
            handle,
            destroy_at_drop: true,
        }
    }

    pub fn get_raw(&self) -> *mut c_void {
        unsafe { internal::MaaGetImageRawData(self.handle) }
    }

    pub fn width(&self) -> i32 {
        unsafe { internal::MaaGetImageWidth(self.handle) }
    }

    pub fn height(&self) -> i32 {
        unsafe { internal::MaaGetImageHeight(self.handle) }
    }

    pub fn typ(&self) -> i32 {
        unsafe { internal::MaaGetImageType(self.handle) }
    }

    pub fn encoded(&self) -> *mut u8 {
        unsafe { internal::MaaGetImageEncoded(self.handle) }
    }

    pub fn encoded_size(&self) -> u64 {
        unsafe { internal::MaaGetImageEncodedSize(self.handle) }
    }

    /// # Safety
    ///
    /// data must be a valid pointer to a valid encoded image
    pub unsafe fn set_raw(&self, data: *mut c_void, width: i32, height: i32, typ: i32) {
        unsafe {
            internal::MaaSetImageRawData(self.handle, data, width, height, typ);
        }
    }

    /// # Safety
    ///
    /// data must be a valid pointer to a valid encoded image
    pub unsafe fn set_encoded(&self, data: *mut u8, size: u64) {
        unsafe {
            internal::MaaSetImageEncoded(self.handle, data, size);
        }
    }
}

impl Default for MaaImageBuffer {
    fn default() -> Self {
        MaaImageBuffer::new()
    }
}

impl Drop for MaaImageBuffer {
    fn drop(&mut self) {
        if self.destroy_at_drop {
            unsafe {
                internal::MaaDestroyImageBuffer(self.handle);
            }
        }
    }
}