medea 0.2.0

Medea media server
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

//! Endpoint elements of [Medea] spec.
//!
//! [Medea]: https://github.com/instrumentisto/medea

pub mod webrtc_play_endpoint;
pub mod webrtc_publish_endpoint;

use std::convert::TryFrom;

use derive_more::{Display, From, Into};
use medea_control_api_proto::grpc::api as proto;
use serde::Deserialize;

use super::{member::MemberElement, TryFromProtobufError};

#[doc(inline)]
pub use webrtc_play_endpoint::{WebRtcPlayEndpoint, WebRtcPlayId};
#[doc(inline)]
pub use webrtc_publish_endpoint::{WebRtcPublishEndpoint, WebRtcPublishId};

/// ID of `Endpoint`.
#[derive(
    Clone, Debug, Deserialize, Display, Eq, From, Hash, Into, PartialEq,
)]
pub struct Id(pub String);

macro_rules! impl_from_into {
    ($id:ty) => {
        impl std::convert::From<Id> for $id {
            fn from(id: Id) -> Self {
                String::from(id).into()
            }
        }

        impl std::convert::From<$id> for Id {
            fn from(id: $id) -> Self {
                String::from(id).into()
            }
        }
    };
}

impl_from_into!(WebRtcPublishId);
impl_from_into!(WebRtcPlayId);

/// Media element that one or more media data streams flow through.
#[derive(Debug, From)]
pub enum EndpointSpec {
    /// [`WebRtcPublishEndpoint`] element.
    WebRtcPublish(WebRtcPublishEndpoint),

    /// [`WebRtcPlayEndpoint`] element.
    WebRtcPlay(WebRtcPlayEndpoint),
}

impl From<EndpointSpec> for MemberElement {
    #[inline]
    fn from(spec: EndpointSpec) -> Self {
        match spec {
            EndpointSpec::WebRtcPublish(e) => {
                Self::WebRtcPublishEndpoint { spec: e }
            }
            EndpointSpec::WebRtcPlay(e) => Self::WebRtcPlayEndpoint { spec: e },
        }
    }
}

impl TryFrom<(Id, proto::member::element::El)> for EndpointSpec {
    type Error = TryFromProtobufError;

    fn try_from(
        (_, proto): (Id, proto::member::element::El),
    ) -> Result<Self, Self::Error> {
        use proto::member::element::El;

        match proto {
            El::WebrtcPlay(elem) => {
                let play = WebRtcPlayEndpoint::try_from(&elem)?;
                Ok(Self::WebRtcPlay(play))
            }
            El::WebrtcPub(elem) => {
                let publish = WebRtcPublishEndpoint::from(&elem);
                Ok(Self::WebRtcPublish(publish))
            }
        }
    }
}

impl TryFrom<(Id, proto::create_request::El)> for EndpointSpec {
    type Error = TryFromProtobufError;

    fn try_from(
        (id, proto): (Id, proto::create_request::El),
    ) -> Result<Self, Self::Error> {
        use proto::create_request::El;

        match proto {
            El::WebrtcPlay(elem) => {
                let play = WebRtcPlayEndpoint::try_from(&elem)?;
                Ok(Self::WebRtcPlay(play))
            }
            El::WebrtcPub(elem) => {
                let publish = WebRtcPublishEndpoint::from(&elem);
                Ok(Self::WebRtcPublish(publish))
            }
            El::Member(_) | El::Room(_) => {
                Err(TryFromProtobufError::ExpectedOtherElement(
                    String::from("Endpoint"),
                    id.0,
                ))
            }
        }
    }
}