webrtc 0.21.0-beta.1

Async-friendly WebRTC implementation in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use crate::error::{Error, Result};
use crate::media_stream::track_local::TrackLocal;
use crate::peer_connection::PeerConnectionRef;
use crate::peer_connection::transport::{DtlsRoute, DtlsTransport, DtlsTransportImpl};
use crate::rtp_transceiver::RtpSender;
use rtc::media_stream::MediaStreamId;
use rtc::rtp_transceiver::RTCRtpSenderId;
use rtc::rtp_transceiver::rtp_sender::{
    RTCRtpCapabilities, RTCRtpSendParameters, RTCSetParameterOptions, RtpCodecKind,
};
use rtc::statistics::StatsSelector;
use rtc::statistics::report::RTCStatsReport;
use std::sync::Arc;
use std::time::Instant;

/// Concrete async rtp sender implementation (generic over interceptor type).
///
/// This wraps a rtp sender and provides async send/receive APIs.
pub(crate) struct RtpSenderImpl {
    /// Unique identifier for this rtp sender
    id: RTCRtpSenderId,

    /// Inner PeerConnection Reference
    inner: Arc<PeerConnectionRef>,

    track: Arc<dyn TrackLocal>,
}

impl RtpSenderImpl {
    /// Create a new rtp sender wrapper
    pub(crate) fn new(
        id: RTCRtpSenderId,
        inner: Arc<PeerConnectionRef>,
        track: Arc<dyn TrackLocal>,
    ) -> Self {
        Self { id, inner, track }
    }
}

impl crate::sealed::Sealed for RtpSenderImpl {}

#[async_trait::async_trait]
impl RtpSender for RtpSenderImpl {
    fn id(&self) -> RTCRtpSenderId {
        self.id
    }

    fn track(&self) -> &Arc<dyn TrackLocal> {
        &self.track
    }

    async fn get_capabilities(&self, kind: RtpCodecKind) -> Result<Option<RTCRtpCapabilities>> {
        let mut peer_connection = self.inner.core.lock().await;

        Ok(peer_connection
            .rtp_sender(self.id)
            .ok_or(Error::ErrRTPSenderNotExisted)?
            .get_capabilities(kind))
    }

    async fn set_parameters(
        &self,
        parameters: RTCRtpSendParameters,
        set_parameter_options: Option<RTCSetParameterOptions>,
    ) -> Result<()> {
        let mut peer_connection = self.inner.core.lock().await;

        peer_connection
            .rtp_sender(self.id)
            .ok_or(Error::ErrRTPSenderNotExisted)?
            .set_parameters(parameters, set_parameter_options)
    }

    async fn get_parameters(&self) -> Result<RTCRtpSendParameters> {
        let mut peer_connection = self.inner.core.lock().await;

        Ok(peer_connection
            .rtp_sender(self.id)
            .ok_or(Error::ErrRTPSenderNotExisted)?
            .get_parameters()
            .to_owned())
    }

    async fn replace_track(&self, track: Arc<dyn TrackLocal>) -> Result<()> {
        let mut peer_connection = self.inner.core.lock().await;

        peer_connection
            .rtp_sender(self.id)
            .ok_or(Error::ErrRTPSenderNotExisted)?
            .replace_track(track.track().await)
    }

    async fn set_streams(&self, streams: Vec<MediaStreamId>) -> Result<()> {
        let mut peer_connection = self.inner.core.lock().await;

        peer_connection
            .rtp_sender(self.id)
            .ok_or(Error::ErrRTPSenderNotExisted)?
            .set_streams(streams);
        Ok(())
    }

    async fn get_stats(&self, now: Instant) -> Result<RTCStatsReport> {
        let mut peer_connection = self.inner.core.lock().await;
        peer_connection
            .rtp_sender(self.id)
            .ok_or(Error::ErrRTPSenderNotExisted)?;
        Ok(peer_connection.get_stats(now, StatsSelector::Sender(self.id)))
    }
    async fn transport(&self) -> Result<Option<Arc<dyn DtlsTransport>>> {
        let mut peer_connection = self.inner.core.lock().await;

        // Walk under the lock and keep only the ids: a borrowed view cannot cross an await, so
        // the handle re-walks per call and carries the ids so `id()` can stay synchronous.
        let ids = match peer_connection.rtp_sender(self.id) {
            Some(sender) => sender
                .transport()
                .map(|dtls| (dtls.id(), dtls.ice_transport().id())),
            None => return Err(Error::ErrRTPSenderNotExisted),
        };
        drop(peer_connection);

        Ok(ids.map(|(id, ice_id)| {
            Arc::new(DtlsTransportImpl::new(
                id,
                ice_id,
                DtlsRoute::Sender(self.id),
                Arc::clone(&self.inner),
            )) as Arc<dyn DtlsTransport>
        }))
    }
}