1use crate::event::{EventSender, SessionEvent};
2use crate::media::ambiance::{AmbianceOption, AmbianceProcessor};
3use crate::media::dtmf::DtmfDetector;
4use crate::media::volume_control::HoldProcessor;
5use crate::media::{AudioFrame, INTERNAL_SAMPLERATE, Samples, TrackId};
6use crate::media::{
7 processor::Processor,
8 recorder::{Recorder, RecorderOption},
9 track::{Track, TrackPacketReceiver, TrackPacketSender},
10};
11use anyhow::Result;
12use std::collections::{HashMap, HashSet};
13use std::path::Path;
14use std::sync::{
15 Arc, Mutex as StdMutex,
16 atomic::{AtomicBool, AtomicU64, Ordering},
17};
18use std::time::Duration;
19use tokio::task::JoinHandle;
20use tokio::{
21 select,
22 sync::{Mutex, mpsc},
23};
24use tokio_util::sync::CancellationToken;
25use tracing::{debug, info, warn};
26use uuid;
27
28pub struct MediaStream {
29 id: String,
30 pub cancel_token: CancellationToken,
31 recorder_option: Mutex<Option<RecorderOption>>,
32 tracks: Mutex<HashMap<TrackId, (Box<dyn Track>, DtmfDetector)>>,
33 pending_ice_candidates: Mutex<Vec<(String, Option<String>, Option<u32>)>>,
36 suppressed_sources: Mutex<HashSet<TrackId>>,
37 event_sender: EventSender,
38 pub packet_sender: TrackPacketSender,
39 packet_receiver: Mutex<Option<TrackPacketReceiver>>,
40 recorder_sender: mpsc::UnboundedSender<AudioFrame>,
41 recorder_receiver: Mutex<Option<mpsc::UnboundedReceiver<AudioFrame>>>,
42 recorder_handle: Mutex<Option<JoinHandle<()>>>,
43 recording_active: Arc<AtomicBool>,
47 ambiance: Mutex<Option<Arc<StdMutex<AmbianceProcessor>>>>,
48 ambiance_source_id: StdMutex<Option<TrackId>>,
49 last_server_packet_ts: Arc<AtomicU64>,
50 ambiance_idle_started: AtomicBool,
51}
52
53const CALLEE_TRACK_ID: &str = "callee-track";
54const QUEUE_HOLD_TRACK_ID: &str = "queue-hold-track";
55pub const SERVER_SIDE_TRACK_ID: &str = "server-side-track";
56const AMBIANCE_IDLE_TRACK_ID: &str = "ambiance-track";
57const AMBIANCE_IDLE_PTIME: Duration = Duration::from_millis(20);
58const AMBIANCE_IDLE_GAP_MS: u64 = 25;
60
61pub struct MediaStreamBuilder {
62 cancel_token: Option<CancellationToken>,
63 id: Option<String>,
64 event_sender: EventSender,
65 recorder_config: Option<RecorderOption>,
66}
67
68impl MediaStreamBuilder {
69 pub fn new(event_sender: EventSender) -> Self {
70 Self {
71 id: Some(format!("ms:{}", uuid::Uuid::new_v4())),
72 cancel_token: None,
73 event_sender,
74 recorder_config: None,
75 }
76 }
77 pub fn with_id(mut self, id: String) -> Self {
78 self.id = Some(id);
79 self
80 }
81
82 pub fn with_cancel_token(mut self, cancel_token: CancellationToken) -> Self {
83 self.cancel_token = Some(cancel_token);
84 self
85 }
86
87 pub fn with_recorder_config(mut self, recorder_config: RecorderOption) -> Self {
88 self.recorder_config = Some(recorder_config);
89 self
90 }
91
92 pub fn build(self) -> MediaStream {
93 let cancel_token = self
94 .cancel_token
95 .unwrap_or_else(|| CancellationToken::new());
96 let tracks = Mutex::new(HashMap::new());
97 let (track_packet_sender, track_packet_receiver) = mpsc::unbounded_channel();
98 let (recorder_sender, recorder_receiver) = mpsc::unbounded_channel();
99 MediaStream {
100 id: self.id.unwrap_or_default(),
101 cancel_token,
102 recorder_option: Mutex::new(self.recorder_config),
103 tracks,
104 pending_ice_candidates: Mutex::new(Vec::new()),
105 suppressed_sources: Mutex::new(HashSet::new()),
106 event_sender: self.event_sender,
107 packet_sender: track_packet_sender,
108 packet_receiver: Mutex::new(Some(track_packet_receiver)),
109 recorder_sender,
110 recorder_receiver: Mutex::new(Some(recorder_receiver)),
111 recorder_handle: Mutex::new(None),
112 recording_active: Arc::new(AtomicBool::new(false)),
113 ambiance: Mutex::new(None),
114 ambiance_source_id: StdMutex::new(None),
115 last_server_packet_ts: Arc::new(AtomicU64::new(0)),
116 ambiance_idle_started: AtomicBool::new(false),
117 }
118 }
119}
120
121impl MediaStream {
122 pub async fn serve(&self) -> Result<()> {
123 let packet_receiver = match self.packet_receiver.lock().await.take() {
124 Some(receiver) => receiver,
125 None => {
126 warn!(
127 session_id = self.id,
128 "MediaStream::serve() called multiple times, stream already serving"
129 );
130 return Ok(());
131 }
132 };
133 self.start_recorder().await.ok();
134 info!(session_id = self.id, "mediastream serving");
135 select! {
136 _ = self.cancel_token.cancelled() => {}
137 r = self.handle_forward_track(packet_receiver) => {
138 info!(session_id = self.id, "track packet receiver stopped {:?}", r);
139 }
140 }
141 Ok(())
142 }
143
144 pub async fn ensure_ambiance(
146 &self,
147 option: AmbianceOption,
148 source_track_id: TrackId,
149 ) -> Result<Option<Arc<StdMutex<AmbianceProcessor>>>> {
150 let mut slot = self.ambiance.lock().await;
151 if let Some(existing) = slot.as_ref() {
152 return Ok(Some(existing.clone()));
153 }
154
155 if option.path.is_none() || option.enabled == Some(false) {
156 return Ok(None);
157 }
158
159 let processor = AmbianceProcessor::new(option).await?;
160 let shared = Arc::new(StdMutex::new(processor));
161 *slot = Some(shared.clone());
162 drop(slot);
163
164 *self.ambiance_source_id.lock().unwrap() = Some(source_track_id);
165 self.start_ambiance_idle_loop(shared.clone());
166 info!(session_id = self.id, "ambiance idle mixer started");
167 Ok(Some(shared))
168 }
169
170 fn start_ambiance_idle_loop(&self, processor: Arc<StdMutex<AmbianceProcessor>>) {
171 if self.ambiance_idle_started.swap(true, Ordering::SeqCst) {
172 return;
173 }
174
175 let cancel_token = self.cancel_token.clone();
176 let packet_sender = self.packet_sender.clone();
177 let last_server_packet_ts = self.last_server_packet_ts.clone();
178 let session_id = self.id.clone();
179 let recorder_sender = self.recorder_sender.clone();
180 let recording_active = self.recording_active.clone();
181
182 crate::spawn(async move {
183 let mut ticker = tokio::time::interval(AMBIANCE_IDLE_PTIME);
184 ticker.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
185 loop {
186 tokio::select! {
187 _ = cancel_token.cancelled() => break,
188 _ = ticker.tick() => {
189 let now = crate::media::get_timestamp();
190 let last = last_server_packet_ts.load(Ordering::Relaxed);
191 if last != 0 && now.saturating_sub(last) < AMBIANCE_IDLE_GAP_MS {
192 continue;
193 }
194
195 let mut frame = AudioFrame {
196 track_id: AMBIANCE_IDLE_TRACK_ID.to_string(),
197 samples: Samples::Empty,
198 timestamp: now,
199 sample_rate: INTERNAL_SAMPLERATE,
200 channels: 1,
201 ..Default::default()
202 };
203 {
204 let mut ambiance = match processor.lock() {
205 Ok(guard) => guard,
206 Err(_) => break,
207 };
208 if let Err(e) = ambiance.process_frame(&mut frame) {
209 warn!(session_id, "ambiance idle mix failed: {}", e);
210 continue;
211 }
212 }
213 if matches!(frame.samples, Samples::Empty) {
214 continue;
215 }
216 if recording_active.load(Ordering::SeqCst) {
220 let mut recorded = frame.clone();
221 recorded.track_id = SERVER_SIDE_TRACK_ID.to_string();
222 let _ = recorder_sender.send(recorded);
223 }
224 if packet_sender.send(frame).is_err() {
225 debug!(session_id, "ambiance idle sender closed");
226 break;
227 }
228 }
229 }
230 }
231 });
232 }
233
234 pub fn stop(&self, _reason: Option<String>, _initiator: Option<String>) {
235 self.cancel_token.cancel()
236 }
237
238 pub async fn cleanup(&self) -> Result<()> {
239 self.cancel_token.cancel();
240 {
241 let mut tracks = self.tracks.lock().await;
242 for (id, (track, _)) in tracks.drain() {
243 if let Err(e) = track.stop().await {
244 warn!(session_id = self.id, track_id = %id, "failed to stop track during cleanup: {}", e);
245 }
246 }
247 }
248 self.suppressed_sources.lock().await.clear();
249
250 if let Some(recorder_handle) = self.recorder_handle.lock().await.take() {
251 if let Ok(Ok(_)) = tokio::time::timeout(Duration::from_secs(30), recorder_handle).await
252 {
253 info!(session_id = self.id, "recorder stopped");
254 } else {
255 warn!(session_id = self.id, "recorder timeout");
256 }
257 }
258 Ok(())
259 }
260 pub async fn track_count(&self) -> usize {
261 self.tracks.lock().await.len()
262 }
263
264 pub async fn update_recorder_option(&self, recorder_config: RecorderOption) {
265 *self.recorder_option.lock().await = Some(recorder_config);
266 self.start_recorder().await.ok();
267 }
268
269 pub async fn remove_track(&self, id: &TrackId, graceful: bool) {
270 let track_entry = { self.tracks.lock().await.remove(id) };
271 if let Some((track, _)) = track_entry {
272 self.suppressed_sources.lock().await.remove(id);
273 let res = if !graceful {
274 track.stop().await
275 } else {
276 track.stop_graceful().await
277 };
278 match res {
279 Ok(_) => {}
280 Err(e) => {
281 warn!(session_id = self.id, "failed to stop track: {}", e);
282 }
283 }
284 }
285 }
286 pub async fn update_remote_description(
287 &self,
288 track_id: &TrackId,
289 answer: &String,
290 ) -> Result<()> {
291 let track_entry = { self.tracks.lock().await.remove(track_id) };
292 if let Some((mut track, dtmf)) = track_entry {
293 let res = track.update_remote_description(answer).await;
294 self.tracks
295 .lock()
296 .await
297 .insert(track_id.clone(), (track, dtmf));
298 res?;
299 }
300 Ok(())
301 }
302
303 pub async fn update_remote_description_force(
304 &self,
305 track_id: &TrackId,
306 answer: &String,
307 ) -> Result<()> {
308 let track_entry = { self.tracks.lock().await.remove(track_id) };
309 if let Some((mut track, dtmf)) = track_entry {
310 let res = track.update_remote_description_force(answer).await;
311 self.tracks
312 .lock()
313 .await
314 .insert(track_id.clone(), (track, dtmf));
315 res?;
316 }
317 Ok(())
318 }
319
320 pub async fn update_remote_description_provisional(
323 &self,
324 track_id: &TrackId,
325 answer: &String,
326 ) -> Result<()> {
327 let track_entry = { self.tracks.lock().await.remove(track_id) };
328 if let Some((mut track, dtmf)) = track_entry {
329 let res = track.update_remote_description_provisional(answer).await;
330 self.tracks
331 .lock()
332 .await
333 .insert(track_id.clone(), (track, dtmf));
334 res?;
335 }
336 Ok(())
337 }
338
339 pub async fn handshake(
340 &self,
341 track_id: &TrackId,
342 offer: String,
343 timeout: Option<Duration>,
344 ) -> Result<String> {
345 let track_entry = { self.tracks.lock().await.remove(track_id) };
346 if let Some((mut track, dtmf)) = track_entry {
347 let res = track.handshake(offer, timeout).await;
348 self.tracks
349 .lock()
350 .await
351 .insert(track_id.clone(), (track, dtmf));
352 res
353 } else {
354 anyhow::bail!("track not found: {}", track_id)
355 }
356 }
357
358 pub async fn update_track(&self, mut track: Box<dyn Track>, play_id: Option<String>) {
359 self.remove_track(track.id(), false).await;
360 self.attach_recorder_tap(&mut track).await;
361 match track
362 .start(self.event_sender.clone(), self.packet_sender.clone())
363 .await
364 {
365 Ok(_) => {
366 info!(session_id = self.id, track_id = track.id(), "track started");
367 let track_id = track.id().clone();
368 if track_id.as_str() == self.id.as_str() {
369 let pending = std::mem::take(&mut *self.pending_ice_candidates.lock().await);
370 for (candidate, sdp_mid, sdp_mline_index) in pending {
371 if let Err(e) =
372 track.add_ice_candidate(&candidate, sdp_mid.as_deref(), sdp_mline_index)
373 {
374 warn!(
375 session_id = self.id,
376 track_id = track.id(),
377 "failed to apply buffered ICE candidate: {}",
378 e
379 );
380 }
381 }
382 }
383 self.tracks
384 .lock()
385 .await
386 .insert(track_id.clone(), (track, DtmfDetector::new()));
387 self.event_sender
388 .send(SessionEvent::TrackStart {
389 track_id,
390 timestamp: crate::media::get_timestamp(),
391 play_id,
392 })
393 .ok();
394 }
395 Err(e) => {
396 warn!(
397 session_id = self.id,
398 track_id = track.id(),
399 play_id = play_id.as_deref(),
400 "Failed to start track: {}",
401 e
402 );
403 }
404 }
405 }
406
407 pub async fn mute_track(&self, id: Option<TrackId>) {
408 if let Some(id) = id {
409 if let Some((track, _)) = self.tracks.lock().await.get_mut(&id) {
410 MuteProcessor::mute_track(track.as_mut());
411 }
412 } else {
413 for (track, _) in self.tracks.lock().await.values_mut() {
414 MuteProcessor::mute_track(track.as_mut());
415 }
416 }
417 }
418
419 pub async fn unmute_track(&self, id: Option<TrackId>) {
420 if let Some(id) = id {
421 if let Some((track, _)) = self.tracks.lock().await.get_mut(&id) {
422 MuteProcessor::unmute_track(track.as_mut());
423 }
424 } else {
425 for (track, _) in self.tracks.lock().await.values_mut() {
426 MuteProcessor::unmute_track(track.as_mut());
427 }
428 }
429 }
430
431 pub async fn renegotiate(&self, offer: String) -> Result<String> {
434 let mut tracks = self.tracks.lock().await;
439 let Some((track, _)) = tracks.get_mut(self.id.as_str()) else {
440 anyhow::bail!("track not found: {}", self.id)
441 };
442 let answer = track.handshake(offer, None).await?;
443 if answer.is_empty() {
444 anyhow::bail!("track {} does not support renegotiation", self.id)
445 }
446 Ok(answer)
447 }
448
449 pub async fn on_answered(&self, track_id: &TrackId, rtp_timeout: Option<Duration>) {
451 if let Some((track, _)) = self.tracks.lock().await.get(track_id) {
452 track.on_answered(rtp_timeout);
453 }
454 }
455
456 pub async fn add_ice_candidate(
460 &self,
461 candidate: &str,
462 sdp_mid: Option<&str>,
463 sdp_mline_index: Option<u32>,
464 ) -> Result<()> {
465 let tracks = self.tracks.lock().await;
466 if let Some((track, _)) = tracks.get(self.id.as_str()) {
467 track.add_ice_candidate(candidate, sdp_mid, sdp_mline_index)?;
468 return Ok(());
469 }
470 drop(tracks);
471 self.pending_ice_candidates.lock().await.push((
472 candidate.to_string(),
473 sdp_mid.map(|s| s.to_string()),
474 sdp_mline_index,
475 ));
476 Ok(())
477 }
478
479 pub async fn pause_playback(&self, id: TrackId) -> Result<()> {
480 self.set_playback_paused(id, true).await
481 }
482
483 pub async fn resume_playback(&self, id: TrackId) -> Result<()> {
484 self.set_playback_paused(id, false).await
485 }
486
487 async fn set_playback_paused(&self, id: TrackId, paused: bool) -> Result<()> {
488 if let Some((track, _)) = self.tracks.lock().await.get_mut(&id) {
489 if track.set_paused(paused) {
490 Ok(())
491 } else {
492 warn!(
493 session_id = self.id,
494 track_id = %id,
495 paused,
496 "pause state requested for track that does not support pausing"
497 );
498 Err(anyhow::anyhow!("track does not support pausing: {}", id))
499 }
500 } else {
501 warn!(
502 session_id = self.id,
503 track_id = %id,
504 paused,
505 "pause state requested for unknown track"
506 );
507 Err(anyhow::anyhow!("track not found: {}", id))
508 }
509 }
510
511 pub async fn hold_track(&self, id: Option<TrackId>) {
512 if let Some(id) = id {
513 if let Some((track, _)) = self.tracks.lock().await.get_mut(&id) {
514 HoldTrack::hold_track(track.as_mut());
515 }
516 } else {
517 for (track, _) in self.tracks.lock().await.values_mut() {
518 HoldTrack::hold_track(track.as_mut());
519 }
520 }
521 }
522
523 pub async fn resume_track(&self, id: Option<TrackId>) {
524 if let Some(id) = id {
525 if let Some((track, _)) = self.tracks.lock().await.get_mut(&id) {
526 HoldTrack::resume_track(track.as_mut());
527 }
528 } else {
529 for (track, _) in self.tracks.lock().await.values_mut() {
530 HoldTrack::resume_track(track.as_mut());
531 }
532 }
533 }
534
535 pub async fn suppress_forwarding(&self, track_id: &TrackId) {
536 self.suppressed_sources
537 .lock()
538 .await
539 .insert(track_id.clone());
540 }
541
542 pub async fn resume_forwarding(&self, track_id: &TrackId) {
543 self.suppressed_sources.lock().await.remove(track_id);
544 }
545
546 pub async fn remove_processor<T: 'static>(&self, track_id: &TrackId) -> Result<()> {
547 if let Some((track, _)) = self.tracks.lock().await.get_mut(track_id) {
548 track.as_mut().processor_chain().remove_processor::<T>();
549 Ok(())
550 } else {
551 Err(anyhow::anyhow!("Track {} not found", track_id))
552 }
553 }
554
555 pub async fn append_processor(
556 &self,
557 track_id: &TrackId,
558 processor: Box<dyn crate::media::processor::Processor>,
559 ) -> Result<()> {
560 if let Some((track, _)) = self.tracks.lock().await.get_mut(track_id) {
561 track.as_mut().processor_chain().append_processor(processor);
562 Ok(())
563 } else {
564 Err(anyhow::anyhow!("Track {} not found", track_id))
565 }
566 }
567}
568
569#[derive(Clone)]
570pub struct RecorderProcessor {
571 sender: mpsc::UnboundedSender<AudioFrame>,
572}
573
574impl RecorderProcessor {
575 pub fn new(sender: mpsc::UnboundedSender<AudioFrame>) -> Self {
576 Self { sender }
577 }
578}
579
580impl Processor for RecorderProcessor {
581 fn process_frame(&mut self, frame: &mut AudioFrame) -> Result<()> {
582 let frame_clone = frame.clone();
583 let _ = self.sender.send(frame_clone);
584 Ok(())
585 }
586}
587
588impl MediaStream {
589 pub async fn start_recorder(&self) -> Result<()> {
590 let recorder_option = self.recorder_option.lock().await.clone();
591 if let Some(recorder_option) = recorder_option {
592 if recorder_option.recorder_file.is_empty() {
593 warn!(
594 session_id = self.id,
595 "recorder file is empty, skipping recorder start"
596 );
597 return Ok(());
598 }
599 let recorder_receiver = match self.recorder_receiver.lock().await.take() {
600 Some(receiver) => receiver,
601 None => {
602 return Ok(());
603 }
604 };
605 let cancel_token = self.cancel_token.child_token();
606 let session_id_clone = self.id.clone();
607
608 info!(
609 session_id = session_id_clone,
610 sample_rate = recorder_option.samplerate,
611 native_samplerate = recorder_option.native_samplerate.unwrap_or(false),
612 ptime = recorder_option.ptime,
613 "start recorder",
614 );
615
616 let native = recorder_option.native_samplerate.unwrap_or(false);
617 let recorder_handle = crate::spawn(async move {
618 let recorder_file = recorder_option.recorder_file.clone();
619 let recorder =
620 Recorder::new(cancel_token, session_id_clone.clone(), recorder_option);
621 match recorder
622 .process_recording(Path::new(&recorder_file), recorder_receiver)
623 .await
624 {
625 Ok(_) => {}
626 Err(e) => {
627 warn!(
628 session_id = session_id_clone,
629 "Failed to process recorder: {}", e
630 );
631 }
632 }
633 });
634 *self.recorder_handle.lock().await = Some(recorder_handle);
635 self.recording_active.store(true, Ordering::SeqCst);
636
637 for (track, _) in self.tracks.lock().await.values_mut() {
641 if native {
642 track.set_raw_tap(Some(self.recorder_sender.clone()));
643 } else if !track.processor_chain().has_processor::<RecorderProcessor>() {
644 track.insert_processor(Box::new(RecorderProcessor::new(
645 self.recorder_sender.clone(),
646 )));
647 }
648 }
649 }
650 Ok(())
651 }
652
653 async fn attach_recorder_tap(&self, track: &mut Box<dyn Track>) {
658 let Some(option) = self.recorder_option.lock().await.clone() else {
659 return;
660 };
661 if option.native_samplerate.unwrap_or(false) {
662 track.set_raw_tap(Some(self.recorder_sender.clone()));
663 } else {
664 track.append_processor(Box::new(RecorderProcessor::new(
665 self.recorder_sender.clone(),
666 )));
667 }
668 }
669
670 pub async fn set_track_refer(&self, track_id: &TrackId, refer: Option<bool>) {
671 if let Some((_, dtmf)) = self.tracks.lock().await.get_mut(track_id) {
672 dtmf.refer = refer;
673 }
674 }
675
676 pub async fn set_track_dtmf_forward(&self, track_id: &TrackId, forward: bool) {
677 if let Some((_, dtmf)) = self.tracks.lock().await.get_mut(track_id) {
678 dtmf.suppress_dtmf_forward = !forward;
679 }
680 }
681
682 async fn handle_forward_track(&self, mut packet_receiver: TrackPacketReceiver) {
683 let event_sender = self.event_sender.clone();
684 while let Some(packet) = packet_receiver.recv().await {
685 if self
686 .ambiance_source_id
687 .lock()
688 .ok()
689 .and_then(|id| id.clone())
690 .as_ref()
691 == Some(&packet.track_id)
692 {
693 self.last_server_packet_ts
694 .store(crate::media::get_timestamp(), Ordering::Relaxed);
695 }
696
697 let suppressed = {
698 self.suppressed_sources
699 .lock()
700 .await
701 .contains(&packet.track_id)
702 };
703
704 let is_dtmf = matches!(&packet.samples,
705 Samples::RTP { payload_type, .. } if *payload_type >= 96 && *payload_type <= 127);
706
707 let mut tracks = self.tracks.lock().await;
708
709 let source_suppresses_dtmf = is_dtmf
711 && tracks
712 .get(&packet.track_id)
713 .map(|(_, d)| d.suppress_dtmf_forward)
714 .unwrap_or(false);
715
716 for (track, dtmf_detector) in tracks.values_mut() {
717 if track.id() == &packet.track_id {
718 if let Samples::RTP {
719 payload_type,
720 payload,
721 ..
722 } = &packet.samples
723 {
724 if let Some(digit) = dtmf_detector.detect_rtp(*payload_type, payload) {
725 debug!(track_id = track.id(), digit, "DTMF detected");
726 event_sender
727 .send(SessionEvent::Dtmf {
728 track_id: packet.track_id.to_string(),
729 timestamp: packet.timestamp,
730 digit,
731 refer: dtmf_detector.refer,
732 })
733 .ok();
734 }
735 }
736 continue;
737 }
738 if suppressed {
739 continue;
740 }
741 if source_suppresses_dtmf || (is_dtmf && dtmf_detector.suppress_dtmf_forward) {
743 continue;
744 }
745 if packet.track_id == QUEUE_HOLD_TRACK_ID && track.id() == CALLEE_TRACK_ID {
746 continue;
747 }
748 if let Err(e) = track.send_packet(&packet).await {
749 warn!(
750 id = track.id(),
751 "media_stream: Failed to send packet to track: {}", e
752 );
753 }
754 }
755 }
756 }
757}
758
759pub struct MuteProcessor;
760
761impl MuteProcessor {
762 pub fn mute_track(track: &mut dyn Track) {
763 let chain = track.processor_chain();
764 if !chain.has_processor::<MuteProcessor>() {
765 chain.insert_processor(Box::new(MuteProcessor));
766 }
767 }
768
769 pub fn unmute_track(track: &mut dyn Track) {
770 let chain = track.processor_chain();
771 chain.remove_processor::<MuteProcessor>();
772 }
773}
774
775impl Processor for MuteProcessor {
776 fn process_frame(&mut self, frame: &mut AudioFrame) -> Result<()> {
777 match &mut frame.samples {
778 Samples::PCM { samples } => {
779 samples.fill(0);
780 }
781 Samples::RTP { payload_type, .. } if *payload_type >= 96 && *payload_type <= 127 => {
783 frame.samples = Samples::Empty;
784 }
785 _ => {}
786 }
787 Ok(())
788 }
789}
790
791pub struct HoldTrack;
792
793impl HoldTrack {
794 pub fn hold_track(track: &mut dyn Track) {
795 let chain = track.processor_chain();
796 chain.remove_processor::<HoldProcessor>();
798 let processor = HoldProcessor::new();
800 processor.set_hold(true);
801 chain.insert_processor(Box::new(processor));
802 }
803
804 pub fn resume_track(track: &mut dyn Track) {
805 let chain = track.processor_chain();
806 chain.remove_processor::<HoldProcessor>();
808 }
809}