cadeau 0.5.2

Idiomatic rust bindings to Cadeau library, performance primitives and media foundation functions
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use core::fmt;
use std::ffi::CString;
use std::mem::MaybeUninit;
use std::path::Path;

use xmf_sys::{XmfImage_FreeData, XmfImage_LoadFile, XmfImage_SaveFile};

#[derive(Debug, Clone)]
pub enum ImageError {
    BadArgument { name: &'static str },
    OperationFailed,
}

impl std::error::Error for ImageError {}

impl fmt::Display for ImageError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ImageError::BadArgument { name } => write!(f, "bad argument: {name}"),
            ImageError::OperationFailed => write!(f, "the operation failed"),
        }
    }
}

pub struct Image {
    // INVARIANT: len(data) == height * step
    data: *mut u8,
    width: usize,
    height: usize,
    step: usize,
}

impl Image {
    pub fn load_file(path: impl AsRef<Path>) -> Result<Self, ImageError> {
        Self::load_file_impl(path.as_ref())
    }

    fn load_file_impl(path: &Path) -> Result<Self, ImageError> {
        let path = path
            .to_str()
            .and_then(|s| CString::new(s).ok())
            .ok_or(ImageError::BadArgument { name: "path" })?;

        let mut data = MaybeUninit::zeroed();
        let mut width = MaybeUninit::zeroed();
        let mut height = MaybeUninit::zeroed();
        let mut step = MaybeUninit::zeroed();

        // SAFETY: FFI call with no outstanding precondition.
        let ret = unsafe {
            XmfImage_LoadFile(
                path.as_ptr(),
                data.as_mut_ptr(),
                width.as_mut_ptr(),
                height.as_mut_ptr(),
                step.as_mut_ptr(),
            )
        };

        if !ret {
            return Err(ImageError::OperationFailed);
        }

        // SAFETY: XmfImage_LoadFile returned success status, and is supposed to initialize the values.
        let data = unsafe { data.assume_init() };

        // SAFETY: XmfImage_LoadFile returned success status, and is supposed to initialize the values.
        let width = unsafe { width.assume_init() };

        // SAFETY: XmfImage_LoadFile returned success status, and is supposed to initialize the values.
        let height = unsafe { height.assume_init() };

        // SAFETY: XmfImage_LoadFile returned success status, and is supposed to initialize the values.
        let step = unsafe { step.assume_init() };

        let width = usize::try_from(width).map_err(|_| ImageError::BadArgument { name: "width" })?;
        let height = usize::try_from(height).map_err(|_| ImageError::BadArgument { name: "height" })?;
        let step = usize::try_from(step).map_err(|_| ImageError::BadArgument { name: "step" })?;

        Ok(Self {
            data,
            width,
            height,
            step,
        })
    }

    pub fn save_file(&self, path: impl AsRef<Path>) -> Result<(), ImageError> {
        self.save_file_impl(path.as_ref())
    }

    fn save_file_impl(&self, path: &Path) -> Result<(), ImageError> {
        let path = path
            .to_str()
            .and_then(|s| CString::new(s).ok())
            .ok_or(ImageError::BadArgument { name: "path" })?;

        let width = u32::try_from(self.width).map_err(|_| ImageError::BadArgument { name: "width" })?;
        let height = u32::try_from(self.height).map_err(|_| ImageError::BadArgument { name: "height" })?;
        let step = u32::try_from(self.step).map_err(|_| ImageError::BadArgument { name: "step" })?;

        // SAFETY: Per invariants, len(data) == height * step
        let ret = unsafe { XmfImage_SaveFile(path.as_ptr(), self.data, width, height, step) };

        if ret {
            Ok(())
        } else {
            Err(ImageError::OperationFailed)
        }
    }

    #[inline]
    pub fn width(&self) -> usize {
        self.width
    }

    #[inline]
    pub fn height(&self) -> usize {
        self.height
    }

    #[inline]
    pub fn step(&self) -> usize {
        self.step
    }

    #[inline]
    pub fn data(&self) -> &[u8] {
        let len = self.height * self.step;

        // SAFETY: The buffer is expected to contain at least height * step elements.
        unsafe { core::slice::from_raw_parts(self.data, len) }
    }

    #[inline]
    pub fn data_mut(&mut self) -> &mut [u8] {
        let len = self.height * self.step;

        // SAFETY: The buffer is expected to contain at least height * step elements.
        unsafe { core::slice::from_raw_parts_mut(self.data, len) }
    }

    #[inline]
    /// Returns a raw pointer to the underlying FFI handle.
    pub const fn data_ptr(&self) -> *mut u8 {
        self.data
    }
}

impl Drop for Image {
    #[inline]
    fn drop(&mut self) {
        // SAFETY: Data owned by this type, and we are not going to use it again after executing drop.
        unsafe { XmfImage_FreeData(self.data) };
    }
}