libobs_wrapper\sources/
media.rs1use 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 #[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 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 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 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 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 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 libobs::obs_source_media_previous(source.get_ptr());
110 })
111 }
112
113 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 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 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 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 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 #[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}