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