Skip to main content

libobs_wrapper\sources/
media.rs

1//! Capability-aware media-source controls.
2
3use std::time::Duration;
4
5use crate::{run_with_obs, sources::ObsSourceTrait, utils::ObsError};
6
7#[derive(Clone, Copy, Debug, PartialEq, Eq)]
8pub enum MediaState {
9    None,
10    Playing,
11    Opening,
12    Buffering,
13    Paused,
14    Stopped,
15    Ended,
16    Error,
17    Unknown(u32),
18}
19
20impl MediaState {
21    fn from_native(value: libobs::obs_media_state) -> Self {
22        match value {
23            libobs::obs_media_state_OBS_MEDIA_STATE_NONE => Self::None,
24            libobs::obs_media_state_OBS_MEDIA_STATE_PLAYING => Self::Playing,
25            libobs::obs_media_state_OBS_MEDIA_STATE_OPENING => Self::Opening,
26            libobs::obs_media_state_OBS_MEDIA_STATE_BUFFERING => Self::Buffering,
27            libobs::obs_media_state_OBS_MEDIA_STATE_PAUSED => Self::Paused,
28            libobs::obs_media_state_OBS_MEDIA_STATE_STOPPED => Self::Stopped,
29            libobs::obs_media_state_OBS_MEDIA_STATE_ENDED => Self::Ended,
30            libobs::obs_media_state_OBS_MEDIA_STATE_ERROR => Self::Error,
31            // C enums are `i32` in the MSVC bindings and `u32` elsewhere.
32            #[allow(clippy::unnecessary_cast)]
33            other => Self::Unknown(other as u32),
34        }
35    }
36}
37
38fn ensure_media<T: ObsSourceTrait + ?Sized>(source: &T) -> Result<(), ObsError> {
39    let source_ptr = source.__native_handle();
40    let runtime = source.runtime().clone();
41    let flags = run_with_obs!(runtime, (source_ptr), move || unsafe {
42        // Safety: source is retained for the actor call.
43        libobs::obs_source_get_output_flags(source_ptr.get_ptr())
44    })?;
45    if flags & libobs::OBS_SOURCE_CONTROLLABLE_MEDIA == 0 {
46        return Err(ObsError::InvalidOperation(format!(
47            "source '{}' does not expose OBS_SOURCE_CONTROLLABLE_MEDIA",
48            source.name()
49        )));
50    }
51    Ok(())
52}
53
54pub trait ObsMediaSourceExt: ObsSourceTrait {
55    fn media_play(&self) -> Result<(), ObsError> {
56        self.media_set_paused(false)
57    }
58
59    fn media_pause(&self) -> Result<(), ObsError> {
60        self.media_set_paused(true)
61    }
62
63    fn media_set_paused(&self, paused: bool) -> Result<(), ObsError> {
64        ensure_media(self)?;
65        let source = self.__native_handle();
66        let runtime = self.runtime().clone();
67        run_with_obs!(runtime, (source), move || unsafe {
68            // Safety: source is retained for the actor call.
69            libobs::obs_source_media_play_pause(source.get_ptr(), paused);
70        })
71    }
72
73    fn media_restart(&self) -> Result<(), ObsError> {
74        ensure_media(self)?;
75        let source = self.__native_handle();
76        let runtime = self.runtime().clone();
77        run_with_obs!(runtime, (source), move || unsafe {
78            // Safety: source is retained for the actor call.
79            libobs::obs_source_media_restart(source.get_ptr());
80        })
81    }
82
83    fn media_stop(&self) -> Result<(), ObsError> {
84        ensure_media(self)?;
85        let source = self.__native_handle();
86        let runtime = self.runtime().clone();
87        run_with_obs!(runtime, (source), move || unsafe {
88            // Safety: source is retained for the actor call.
89            libobs::obs_source_media_stop(source.get_ptr());
90        })
91    }
92
93    fn media_next(&self) -> Result<(), ObsError> {
94        ensure_media(self)?;
95        let source = self.__native_handle();
96        let runtime = self.runtime().clone();
97        run_with_obs!(runtime, (source), move || unsafe {
98            // Safety: source is retained for the actor call.
99            libobs::obs_source_media_next(source.get_ptr());
100        })
101    }
102
103    fn media_previous(&self) -> Result<(), ObsError> {
104        ensure_media(self)?;
105        let source = self.__native_handle();
106        let runtime = self.runtime().clone();
107        run_with_obs!(runtime, (source), move || unsafe {
108            // Safety: source is retained for the actor call.
109            libobs::obs_source_media_previous(source.get_ptr());
110        })
111    }
112
113    /// Requests a media seek to `position`.
114    ///
115    /// The native operation is asynchronous and source/plugin-specific. A successful return means
116    /// libobs accepted the request, not that [`Self::media_position`] already reflects it. Some
117    /// plugins may also defer a seek made while paused until playback resumes.
118    fn media_seek(&self, position: Duration) -> Result<(), ObsError> {
119        ensure_media(self)?;
120        let milliseconds = i64::try_from(position.as_millis()).map_err(|_| {
121            ObsError::InvalidOperation("media seek position exceeds libobs i64 milliseconds".into())
122        })?;
123        let source = self.__native_handle();
124        let runtime = self.runtime().clone();
125        run_with_obs!(runtime, (source), move || unsafe {
126            // Safety: source is retained for the actor call.
127            libobs::obs_source_media_set_time(source.get_ptr(), milliseconds);
128        })
129    }
130
131    fn media_position(&self) -> Result<Option<Duration>, ObsError> {
132        ensure_media(self)?;
133        let source = self.__native_handle();
134        let runtime = self.runtime().clone();
135        let ms = run_with_obs!(runtime, (source), move || unsafe {
136            // Safety: source is retained for the actor call.
137            libobs::obs_source_media_get_time(source.get_ptr())
138        })?;
139        Ok((ms >= 0).then(|| Duration::from_millis(ms as u64)))
140    }
141
142    fn media_duration(&self) -> Result<Option<Duration>, ObsError> {
143        ensure_media(self)?;
144        let source = self.__native_handle();
145        let runtime = self.runtime().clone();
146        let ms = run_with_obs!(runtime, (source), move || unsafe {
147            // Safety: source is retained for the actor call.
148            libobs::obs_source_media_get_duration(source.get_ptr())
149        })?;
150        Ok((ms >= 0).then(|| Duration::from_millis(ms as u64)))
151    }
152
153    fn media_state(&self) -> Result<MediaState, ObsError> {
154        ensure_media(self)?;
155        let source = self.__native_handle();
156        let runtime = self.runtime().clone();
157        let state = run_with_obs!(runtime, (source), move || unsafe {
158            // Safety: source is retained for the actor call.
159            libobs::obs_source_media_get_state(source.get_ptr())
160        })?;
161        Ok(MediaState::from_native(state))
162    }
163}
164
165impl<T: ObsSourceTrait + ?Sized> ObsMediaSourceExt for T {}
166
167#[cfg(test)]
168mod tests {
169    use super::*;
170
171    #[test]
172    // C enums are `i32` in the MSVC bindings and `u32` elsewhere.
173    #[allow(clippy::unnecessary_cast)]
174    fn unknown_media_states_are_preserved() {
175        assert_eq!(
176            MediaState::from_native(u32::MAX as libobs::obs_media_state),
177            MediaState::Unknown(u32::MAX)
178        );
179    }
180}