libobs-wrapper 9.0.4+32.0.2

A safe wrapper around libobs
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

use std::{ffi::CStr, sync::Arc};

use libobs::obs_data_t;

use crate::{
    data::{ObsDataGetters, ObsDataPointers},
    run_with_obs,
    runtime::ObsRuntime,
    unsafe_send::{Sendable, SmartPointerSendable},
    utils::ObsError,
};

use super::{ObsData, _ObsDataDropGuard};

#[derive(Clone, Debug)]
/// Immutable wrapper around obs_data_t to be prevent modification and to be used in creation of other objects.
///
/// **DO NOT** update this data using the pointer directly. If you want to change the data,
/// use the corresponding update methods of the struct you want to update or turn this struct into
/// a `ObsData` object by using the `to_mutable` method.
pub struct ImmutableObsData {
    runtime: ObsRuntime,
    ptr: SmartPointerSendable<*mut obs_data_t>,
}

impl ImmutableObsData {
    pub fn new(runtime: &ObsRuntime) -> Result<Self, ObsError> {
        let ptr = run_with_obs!(runtime, move || unsafe {
            // Safety: We are in the runtime, so creating new obs_data_t is safe.
            Sendable(libobs::obs_data_create())
        })?;

        let drop_guard = Arc::new(_ObsDataDropGuard {
            data_ptr: ptr.clone(),
            runtime: runtime.clone(),
        });

        let ptr = SmartPointerSendable::new(ptr.0, drop_guard);
        Ok(ImmutableObsData {
            ptr,
            runtime: runtime.clone(),
        })
    }

    pub fn from_raw_pointer(data: Sendable<*mut obs_data_t>, runtime: ObsRuntime) -> Self {
        ImmutableObsData {
            ptr: SmartPointerSendable::new(
                data.0,
                Arc::new(_ObsDataDropGuard {
                    data_ptr: data.clone(),
                    runtime: runtime.clone(),
                }),
            ),
            runtime,
        }
    }

    pub fn to_mutable(&self) -> Result<ObsData, ObsError> {
        let ptr = self.ptr.clone();
        let json = run_with_obs!(self.runtime, (ptr), move || {
            let json_ptr = unsafe {
                // Safety: We are making sure by using a SmartPointer, that this pointer is valid during the call.
                libobs::obs_data_get_json(ptr.get_ptr())
            };

            if json_ptr.is_null() {
                return Err(ObsError::NullPointer(Some(
                    "Couldn't get json representation of OBS data".into(),
                )));
            }

            let json = unsafe {
                // Safety: We made sure the json ptr is valid because it is not null.
                CStr::from_ptr(json_ptr)
            }
            .to_str()
            .map_err(|_| ObsError::JsonParseError)?
            .to_string();

            Ok(json)
        })??;

        ObsData::from_json(json.as_ref(), self.runtime.clone())
    }
}

impl ObsDataPointers for ImmutableObsData {
    fn runtime(&self) -> &ObsRuntime {
        &self.runtime
    }

    fn as_ptr(&self) -> SmartPointerSendable<*mut obs_data_t> {
        self.ptr.clone()
    }
}

impl ObsDataGetters for ImmutableObsData {}

impl From<ObsData> for ImmutableObsData {
    fn from(data: ObsData) -> Self {
        ImmutableObsData {
            ptr: data.as_ptr(),
            runtime: data.runtime.clone(),
        }
    }
}