servo_media_dummy/
lib.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5extern crate ipc_channel;
6extern crate servo_media;
7extern crate servo_media_audio;
8extern crate servo_media_player;
9extern crate servo_media_streams;
10extern crate servo_media_traits;
11extern crate servo_media_webrtc;
12
13use std::any::Any;
14use std::ops::Range;
15use std::sync::mpsc::{self, Sender};
16use std::sync::{Arc, Mutex};
17
18use ipc_channel::ipc::IpcSender;
19use servo_media::{Backend, BackendInit, MediaInstanceError, SupportsMediaType};
20use servo_media_audio::block::{Block, Chunk};
21use servo_media_audio::context::{AudioContext, AudioContextOptions};
22use servo_media_audio::decoder::{AudioDecoder, AudioDecoderCallbacks, AudioDecoderOptions};
23use servo_media_audio::render_thread::AudioRenderThreadMsg;
24use servo_media_audio::sink::{AudioSink, AudioSinkError};
25use servo_media_audio::{AudioBackend, AudioStreamReader};
26use servo_media_player::context::PlayerGLContext;
27use servo_media_player::{Player, PlayerError, PlayerEvent, StreamType, audio, video};
28use servo_media_streams::capture::MediaTrackConstraintSet;
29use servo_media_streams::device_monitor::{MediaDeviceInfo, MediaDeviceMonitor};
30use servo_media_streams::registry::{MediaStreamId, register_stream, unregister_stream};
31use servo_media_streams::{MediaOutput, MediaSocket, MediaStream, MediaStreamType};
32use servo_media_traits::{ClientContextId, MediaInstance};
33use servo_media_webrtc::{
34    BundlePolicy, DataChannelId, DataChannelInit, DataChannelMessage, IceCandidate,
35    SessionDescription, WebRtcBackend, WebRtcController, WebRtcControllerBackend,
36    WebRtcDataChannelResult, WebRtcResult, WebRtcSignaller, thread,
37};
38
39pub struct DummyBackend;
40
41impl BackendInit for DummyBackend {
42    fn init() -> Box<dyn Backend> {
43        Box::new(DummyBackend)
44    }
45}
46
47impl Backend for DummyBackend {
48    fn create_audiostream(&self) -> MediaStreamId {
49        register_stream(Arc::new(Mutex::new(DummyMediaStream {
50            id: MediaStreamId::new(),
51        })))
52    }
53
54    fn create_videostream(&self) -> MediaStreamId {
55        register_stream(Arc::new(Mutex::new(DummyMediaStream {
56            id: MediaStreamId::new(),
57        })))
58    }
59
60    fn create_stream_output(&self) -> Box<dyn MediaOutput> {
61        Box::new(DummyMediaOutput)
62    }
63
64    fn create_audioinput_stream(&self, _: MediaTrackConstraintSet) -> Option<MediaStreamId> {
65        Some(register_stream(Arc::new(Mutex::new(DummyMediaStream {
66            id: MediaStreamId::new(),
67        }))))
68    }
69
70    fn create_stream_and_socket(
71        &self,
72        _: MediaStreamType,
73    ) -> (Box<dyn MediaSocket>, MediaStreamId) {
74        let id = register_stream(Arc::new(Mutex::new(DummyMediaStream {
75            id: MediaStreamId::new(),
76        })));
77        (Box::new(DummySocket), id)
78    }
79
80    fn create_videoinput_stream(&self, _: MediaTrackConstraintSet) -> Option<MediaStreamId> {
81        Some(register_stream(Arc::new(Mutex::new(DummyMediaStream {
82            id: MediaStreamId::new(),
83        }))))
84    }
85
86    fn create_player(
87        &self,
88        _id: &ClientContextId,
89        _: StreamType,
90        _: IpcSender<PlayerEvent>,
91        _: Option<Arc<Mutex<dyn video::VideoFrameRenderer>>>,
92        _: Option<Arc<Mutex<dyn audio::AudioRenderer>>>,
93        _: Box<dyn PlayerGLContext>,
94    ) -> Arc<Mutex<dyn Player>> {
95        Arc::new(Mutex::new(DummyPlayer))
96    }
97
98    fn create_audio_context(
99        &self,
100        _id: &ClientContextId,
101        options: AudioContextOptions,
102    ) -> Result<Arc<Mutex<AudioContext>>, AudioSinkError> {
103        let (sender, _) = mpsc::channel();
104        let sender = Arc::new(Mutex::new(sender));
105        Ok(Arc::new(Mutex::new(AudioContext::new::<Self>(
106            0,
107            &ClientContextId::build(1, 1),
108            sender,
109            options,
110        )?)))
111    }
112
113    fn create_webrtc(&self, signaller: Box<dyn WebRtcSignaller>) -> WebRtcController {
114        WebRtcController::new::<Self>(signaller)
115    }
116
117    fn can_play_type(&self, _media_type: &str) -> SupportsMediaType {
118        SupportsMediaType::No
119    }
120
121    fn get_device_monitor(&self) -> Box<dyn MediaDeviceMonitor> {
122        Box::new(DummyMediaDeviceMonitor {})
123    }
124}
125
126impl AudioBackend for DummyBackend {
127    type Sink = DummyAudioSink;
128    fn make_decoder() -> Box<dyn AudioDecoder> {
129        Box::new(DummyAudioDecoder)
130    }
131
132    fn make_sink() -> Result<Self::Sink, AudioSinkError> {
133        Ok(DummyAudioSink)
134    }
135    fn make_streamreader(
136        _id: MediaStreamId,
137        _sample_rate: f32,
138    ) -> Result<Box<dyn AudioStreamReader + Send>, AudioSinkError> {
139        Ok(Box::new(DummyStreamReader))
140    }
141}
142
143pub struct DummyPlayer;
144
145pub struct DummyStreamReader;
146
147impl AudioStreamReader for DummyStreamReader {
148    fn pull(&self) -> Block {
149        Default::default()
150    }
151    fn start(&self) {}
152    fn stop(&self) {}
153}
154
155impl Player for DummyPlayer {
156    fn play(&self) -> Result<(), PlayerError> {
157        Ok(())
158    }
159    fn pause(&self) -> Result<(), PlayerError> {
160        Ok(())
161    }
162
163    fn paused(&self) -> bool {
164        true
165    }
166    fn can_resume(&self) -> bool {
167        true
168    }
169
170    fn stop(&self) -> Result<(), PlayerError> {
171        Ok(())
172    }
173    fn seek(&self, _: f64) -> Result<(), PlayerError> {
174        Ok(())
175    }
176
177    fn set_mute(&self, _: bool) -> Result<(), PlayerError> {
178        Ok(())
179    }
180
181    fn muted(&self) -> bool {
182        false
183    }
184
185    fn set_volume(&self, _: f64) -> Result<(), PlayerError> {
186        Ok(())
187    }
188
189    fn volume(&self) -> f64 {
190        1.0
191    }
192
193    fn set_input_size(&self, _: u64) -> Result<(), PlayerError> {
194        Ok(())
195    }
196
197    fn set_playback_rate(&self, _: f64) -> Result<(), PlayerError> {
198        Ok(())
199    }
200
201    fn playback_rate(&self) -> f64 {
202        1.0
203    }
204
205    fn push_data(&self, _: Vec<u8>) -> Result<(), PlayerError> {
206        Ok(())
207    }
208    fn end_of_stream(&self) -> Result<(), PlayerError> {
209        Ok(())
210    }
211
212    fn buffered(&self) -> Vec<Range<f64>> {
213        vec![]
214    }
215
216    fn seekable(&self) -> Vec<Range<f64>> {
217        vec![]
218    }
219
220    fn set_stream(&self, _: &MediaStreamId, _: bool) -> Result<(), PlayerError> {
221        Ok(())
222    }
223
224    fn render_use_gl(&self) -> bool {
225        false
226    }
227    fn set_audio_track(&self, _: i32, _: bool) -> Result<(), PlayerError> {
228        Ok(())
229    }
230    fn set_video_track(&self, _: i32, _: bool) -> Result<(), PlayerError> {
231        Ok(())
232    }
233}
234
235impl WebRtcBackend for DummyBackend {
236    type Controller = DummyWebRtcController;
237    fn construct_webrtc_controller(
238        _: Box<dyn WebRtcSignaller>,
239        _: WebRtcController,
240    ) -> Self::Controller {
241        DummyWebRtcController
242    }
243}
244
245pub struct DummyAudioDecoder;
246
247impl AudioDecoder for DummyAudioDecoder {
248    fn decode(&self, _: Vec<u8>, _: AudioDecoderCallbacks, _: Option<AudioDecoderOptions>) {}
249}
250
251pub struct DummySocket;
252
253impl MediaSocket for DummySocket {
254    fn as_any(&self) -> &dyn Any {
255        self
256    }
257}
258
259pub struct DummyMediaStream {
260    id: MediaStreamId,
261}
262
263impl MediaStream for DummyMediaStream {
264    fn as_any(&self) -> &dyn Any {
265        self
266    }
267    fn as_mut_any(&mut self) -> &mut dyn Any {
268        self
269    }
270    fn set_id(&mut self, _: MediaStreamId) {}
271
272    fn ty(&self) -> MediaStreamType {
273        MediaStreamType::Audio
274    }
275}
276
277impl Drop for DummyMediaStream {
278    fn drop(&mut self) {
279        unregister_stream(&self.id);
280    }
281}
282
283pub struct DummyAudioSink;
284
285impl AudioSink for DummyAudioSink {
286    fn init(&self, _: f32, _: Sender<AudioRenderThreadMsg>) -> Result<(), AudioSinkError> {
287        Ok(())
288    }
289    fn init_stream(&self, _: u8, _: f32, _: Box<dyn MediaSocket>) -> Result<(), AudioSinkError> {
290        Ok(())
291    }
292    fn play(&self) -> Result<(), AudioSinkError> {
293        Ok(())
294    }
295    fn stop(&self) -> Result<(), AudioSinkError> {
296        Ok(())
297    }
298    fn has_enough_data(&self) -> bool {
299        true
300    }
301    fn push_data(&self, _: Chunk) -> Result<(), AudioSinkError> {
302        Ok(())
303    }
304    fn set_eos_callback(&self, _: Box<dyn Fn(Box<dyn AsRef<[f32]>>) + Send + Sync + 'static>) {}
305}
306
307pub struct DummyMediaOutput;
308impl MediaOutput for DummyMediaOutput {
309    fn add_stream(&mut self, _stream: &MediaStreamId) {}
310}
311
312pub struct DummyWebRtcController;
313
314impl WebRtcControllerBackend for DummyWebRtcController {
315    fn configure(&mut self, _: &str, _: BundlePolicy) -> WebRtcResult {
316        Ok(())
317    }
318    fn set_remote_description(
319        &mut self,
320        _: SessionDescription,
321        _: Box<dyn FnOnce() + Send + 'static>,
322    ) -> WebRtcResult {
323        Ok(())
324    }
325    fn set_local_description(
326        &mut self,
327        _: SessionDescription,
328        _: Box<dyn FnOnce() + Send + 'static>,
329    ) -> WebRtcResult {
330        Ok(())
331    }
332    fn add_ice_candidate(&mut self, _: IceCandidate) -> WebRtcResult {
333        Ok(())
334    }
335    fn create_offer(
336        &mut self,
337        _: Box<dyn FnOnce(SessionDescription) + Send + 'static>,
338    ) -> WebRtcResult {
339        Ok(())
340    }
341    fn create_answer(
342        &mut self,
343        _: Box<dyn FnOnce(SessionDescription) + Send + 'static>,
344    ) -> WebRtcResult {
345        Ok(())
346    }
347    fn add_stream(&mut self, _: &MediaStreamId) -> WebRtcResult {
348        Ok(())
349    }
350    fn create_data_channel(&mut self, _: &DataChannelInit) -> WebRtcDataChannelResult {
351        Ok(0)
352    }
353    fn close_data_channel(&mut self, _: &DataChannelId) -> WebRtcResult {
354        Ok(())
355    }
356    fn send_data_channel_message(
357        &mut self,
358        _: &DataChannelId,
359        _: &DataChannelMessage,
360    ) -> WebRtcResult {
361        Ok(())
362    }
363    fn internal_event(&mut self, _: thread::InternalEvent) -> WebRtcResult {
364        Ok(())
365    }
366    fn quit(&mut self) {}
367}
368
369impl MediaInstance for DummyPlayer {
370    fn get_id(&self) -> usize {
371        0
372    }
373
374    fn mute(&self, _val: bool) -> Result<(), MediaInstanceError> {
375        Ok(())
376    }
377
378    fn suspend(&self) -> Result<(), MediaInstanceError> {
379        Ok(())
380    }
381
382    fn resume(&self) -> Result<(), MediaInstanceError> {
383        Ok(())
384    }
385}
386
387struct DummyMediaDeviceMonitor;
388
389impl MediaDeviceMonitor for DummyMediaDeviceMonitor {
390    fn enumerate_devices(&self) -> Option<Vec<MediaDeviceInfo>> {
391        Some(vec![])
392    }
393}
servo_media_dummy/lib.rs

servo_media_dummy/
lib.rs
