Skip to main content

ocio_rs/transform/
display_view.rs

1use std::ffi::c_void;
2use std::ptr::NonNull;
3
4use crate::{cstr_from_mut, cstr_to_opt_string, cstring, OcioError, Result, TransformDirection};
5use ocio_sys;
6
7/// Converts through an OCIO display/view pipeline.
8pub struct DisplayViewTransform {
9    pub(crate) handle: NonNull<c_void>,
10}
11
12impl DisplayViewTransform {
13    /// Create a display/view transform with default settings.
14    pub fn create() -> Result<Self> {
15        crate::clear_last_error();
16        let handle = unsafe { ocio_sys::ocio_display_view_transform_create() };
17        crate::handle_result(handle).map(|handle| Self { handle })
18    }
19
20    /// Return the source color space name.
21    pub fn src(&self) -> Option<String> {
22        unsafe {
23            cstr_from_mut(ocio_sys::ocio_display_view_transform_get_src(
24                self.handle.as_ptr(),
25            ))
26        }
27    }
28
29    /// Set the source color space name.
30    pub fn set_src(&self, src: impl AsRef<str>) -> Result<()> {
31        let s = cstring(src)?;
32        crate::clear_last_error();
33        unsafe {
34            ocio_sys::ocio_display_view_transform_set_src(self.handle.as_ptr(), s.as_ptr().cast())
35        };
36        crate::ocio_call_status()
37    }
38
39    /// Return the display name.
40    pub fn display(&self) -> Option<String> {
41        unsafe {
42            cstr_from_mut(ocio_sys::ocio_display_view_transform_get_display(
43                self.handle.as_ptr(),
44            ))
45        }
46    }
47
48    /// Set the display name.
49    pub fn set_display(&self, display: impl AsRef<str>) -> Result<()> {
50        let d = cstring(display)?;
51        crate::clear_last_error();
52        unsafe {
53            ocio_sys::ocio_display_view_transform_set_display(
54                self.handle.as_ptr(),
55                d.as_ptr().cast(),
56            )
57        };
58        crate::ocio_call_status()
59    }
60
61    /// Return the view name.
62    pub fn view(&self) -> Option<String> {
63        unsafe {
64            cstr_from_mut(ocio_sys::ocio_display_view_transform_get_view(
65                self.handle.as_ptr(),
66            ))
67        }
68    }
69
70    /// Set the view name.
71    pub fn set_view(&self, view: impl AsRef<str>) -> Result<()> {
72        let v = cstring(view)?;
73        crate::clear_last_error();
74        unsafe {
75            ocio_sys::ocio_display_view_transform_set_view(self.handle.as_ptr(), v.as_ptr().cast())
76        };
77        crate::ocio_call_status()
78    }
79
80    /// Return whether looks bypass is enabled.
81    pub fn looks_bypass(&self) -> bool {
82        unsafe { ocio_sys::ocio_display_view_transform_get_looks_bypass(self.handle.as_ptr()) }
83    }
84
85    /// Set looks bypass behavior, panicking on validation error.
86    pub fn set_looks_bypass(&self, bypass: bool) {
87        self.try_set_looks_bypass(bypass)
88            .expect("failed to set display view looks bypass");
89    }
90
91    /// Set looks bypass behavior and surface any OCIO validation error.
92    pub fn try_set_looks_bypass(&self, bypass: bool) -> Result<()> {
93        crate::clear_last_error();
94        unsafe {
95            ocio_sys::ocio_display_view_transform_set_looks_bypass(self.handle.as_ptr(), bypass)
96        };
97        crate::ocio_call_status()
98    }
99
100    /// Return the evaluation direction.
101    pub fn direction(&self) -> TransformDirection {
102        let dir =
103            unsafe { ocio_sys::ocio_display_view_transform_get_direction(self.handle.as_ptr()) };
104        match dir {
105            1 => TransformDirection::Inverse,
106            _ => TransformDirection::Forward,
107        }
108    }
109
110    /// Set the evaluation direction, panicking on validation error.
111    pub fn set_direction(&self, direction: TransformDirection) {
112        self.try_set_direction(direction)
113            .expect("failed to set display view transform direction");
114    }
115
116    /// Set evaluation direction and surface any OCIO validation error.
117    pub fn try_set_direction(&self, direction: TransformDirection) -> Result<()> {
118        crate::clear_last_error();
119        unsafe {
120            ocio_sys::ocio_display_view_transform_set_direction(
121                self.handle.as_ptr(),
122                direction as i32,
123            );
124        }
125        crate::ocio_call_status()
126    }
127
128    /// Return whether data channel bypass is enabled.
129    pub fn data_bypass(&self) -> bool {
130        unsafe { ocio_sys::ocio_display_view_transform_get_data_bypass(self.handle.as_ptr()) }
131    }
132
133    /// Set data bypass behavior, panicking on validation error.
134    pub fn set_data_bypass(&self, bypass: bool) {
135        self.try_set_data_bypass(bypass)
136            .expect("failed to set display view data bypass");
137    }
138
139    /// Set data bypass behavior and surface any OCIO validation error.
140    pub fn try_set_data_bypass(&self, bypass: bool) -> Result<()> {
141        crate::clear_last_error();
142        unsafe {
143            ocio_sys::ocio_display_view_transform_set_data_bypass(self.handle.as_ptr(), bypass)
144        };
145        crate::ocio_call_status()
146    }
147
148    /// Create an editable copy that is independent from the original transform.
149    pub fn create_editable_copy(&self) -> Result<Self> {
150        crate::clear_last_error();
151        let handle = unsafe {
152            ocio_sys::ocio_display_view_transform_create_editable_copy(self.handle.as_ptr())
153        };
154        crate::handle_result(handle).map(|handle| Self { handle })
155    }
156
157    /// Return format metadata attached to the transform, when available.
158    pub fn format_metadata(&self) -> Option<crate::FormatMetadata> {
159        let handle = unsafe { ocio_sys::ocio_transform_get_format_metadata(self.handle.as_ptr()) };
160        NonNull::new(handle).map(|h| crate::FormatMetadata { handle: h })
161    }
162
163    /// Validate the transform configuration and return any errors.
164    pub fn validate(&self) -> Result<()> {
165        crate::clear_last_error();
166        unsafe { ocio_sys::ocio_display_view_transform_validate(self.handle.as_ptr()) };
167        crate::validation_status()
168    }
169}
170
171impl Drop for DisplayViewTransform {
172    fn drop(&mut self) {
173        unsafe { ocio_sys::ocio_display_view_transform_destroy(self.handle.as_ptr()) };
174    }
175}
176
177#[cfg(test)]
178mod tests {
179    use super::*;
180
181    #[test]
182    fn create_display_view_transform() {
183        let t = DisplayViewTransform::create();
184        assert!(t.is_ok());
185    }
186
187    #[test]
188    fn set_src_display_view_no_crash() {
189        let t = DisplayViewTransform::create().unwrap();
190        assert!(t.set_src("src").is_ok());
191        let _ = t.src();
192        assert!(t.set_display("display").is_ok());
193        let _ = t.display();
194        assert!(t.set_view("view").is_ok());
195        let _ = t.view();
196    }
197
198    #[test]
199    fn direction_no_crash() {
200        let t = DisplayViewTransform::create().unwrap();
201        let _ = t.direction();
202        t.try_set_direction(TransformDirection::Inverse).unwrap();
203    }
204
205    #[test]
206    fn looks_bypass_no_crash() {
207        let t = DisplayViewTransform::create().unwrap();
208        let _ = t.looks_bypass();
209        t.try_set_looks_bypass(true).unwrap();
210    }
211
212    #[test]
213    fn data_bypass_no_crash() {
214        let t = DisplayViewTransform::create().unwrap();
215        let _ = t.data_bypass();
216        t.try_set_data_bypass(true).unwrap();
217    }
218
219    #[test]
220    fn create_editable_copy_no_crash() {
221        let t = DisplayViewTransform::create().unwrap();
222        let _ = t.create_editable_copy();
223    }
224
225    #[test]
226    fn format_metadata_no_crash() {
227        let t = DisplayViewTransform::create().unwrap();
228        let _ = t.format_metadata();
229    }
230
231    #[test]
232    fn validate_no_crash() {
233        let t = DisplayViewTransform::create().unwrap();
234        let _ = t.validate();
235    }
236}