atm0s_media_server_endpoint/
rpc.rs

1use cluster::{ClusterEndpointMeta, ClusterTrackMeta};
2use media_utils::hash_str;
3use serde::{Deserialize, Serialize};
4use transport::MediaKind;
5
6#[derive(Deserialize, Serialize, Debug, PartialEq, Eq)]
7pub struct RpcRequest<D> {
8    pub req_id: u64,
9    pub data: D,
10}
11
12impl<D> RpcRequest<D> {
13    pub fn from(req_id: u64, data: D) -> Self {
14        Self { req_id, data }
15    }
16}
17
18#[derive(Deserialize, Serialize, Debug, PartialEq, Eq)]
19pub struct RpcResponse<D> {
20    pub req_id: u64,
21    #[serde(rename = "type")]
22    _type: String,
23    pub success: bool,
24    pub data: Option<D>,
25}
26
27impl<D> RpcResponse<D> {
28    pub fn success(req_id: u64, data: D) -> Self {
29        Self {
30            req_id,
31            _type: "answer".to_string(),
32            success: true,
33            data: Some(data),
34        }
35    }
36
37    pub fn error(req_id: u64) -> Self {
38        Self {
39            req_id,
40            _type: "answer".to_string(),
41            success: false,
42            data: None,
43        }
44    }
45}
46
47#[derive(Deserialize, Debug, PartialEq, Eq)]
48pub struct RemotePeer {
49    pub peer: String,
50}
51
52#[derive(Deserialize, Debug, PartialEq, Eq)]
53pub struct RemoteStream {
54    pub peer: String,
55    pub stream: String,
56}
57
58#[derive(Deserialize, Debug, PartialEq, Eq)]
59pub struct ReceiverLayerLimit {
60    pub priority: u16,
61    pub min_spatial: Option<u8>,
62    pub max_spatial: u8,
63    pub min_temporal: Option<u8>,
64    pub max_temporal: u8,
65}
66
67#[derive(Deserialize, Debug, PartialEq, Eq)]
68pub struct SenderToggle {
69    pub name: String,
70    pub kind: MediaKind,
71    pub track: Option<String>,
72    pub label: Option<String>,
73}
74
75#[derive(Deserialize, Debug, PartialEq, Eq)]
76pub struct ReceiverSwitch {
77    pub id: String,
78    pub priority: u16,
79    pub remote: RemoteStream,
80}
81
82#[derive(Deserialize, Debug, PartialEq, Eq)]
83pub struct MixMinusSource {
84    pub id: String,
85    pub remote: RemoteStream,
86}
87
88#[derive(Deserialize, Debug, PartialEq, Eq)]
89pub struct MixMinusToggle {
90    pub id: String,
91    pub enable: bool,
92}
93
94#[derive(Deserialize, Debug, PartialEq, Eq)]
95pub struct ReceiverLimit {
96    pub id: String,
97    pub limit: ReceiverLayerLimit,
98}
99
100#[derive(Deserialize, Debug, PartialEq, Eq)]
101pub struct ReceiverDisconnect {
102    pub id: String,
103}
104
105#[derive(Serialize, Debug, PartialEq, Eq)]
106pub struct PeerInfo {
107    peer_hash: u32,
108    pub peer: String,
109    pub state: Option<ClusterEndpointMeta>,
110}
111
112impl PeerInfo {
113    pub fn new(peer: &str, state: Option<ClusterEndpointMeta>) -> Self {
114        Self {
115            peer_hash: hash_str(peer) as u32,
116            peer: peer.to_string(),
117            state,
118        }
119    }
120}
121
122#[derive(Serialize, Debug, PartialEq, Eq)]
123pub struct TrackInfo {
124    peer_hash: u32,
125    pub peer: String,
126    pub kind: MediaKind,
127    #[serde(rename = "stream")]
128    pub track: String,
129    pub state: Option<ClusterTrackMeta>,
130}
131
132impl TrackInfo {
133    pub fn new(peer: &str, track: &str, kind: MediaKind, state: Option<ClusterTrackMeta>) -> Self {
134        Self {
135            peer_hash: hash_str(peer) as u32,
136            peer: peer.to_string(),
137            kind,
138            track: track.to_string(),
139            state,
140        }
141    }
142
143    pub fn new_audio(peer: &str, track: &str, state: Option<ClusterTrackMeta>) -> Self {
144        Self::new(peer, track, MediaKind::Audio, state)
145    }
146
147    pub fn new_video(peer: &str, track: &str, state: Option<ClusterTrackMeta>) -> Self {
148        Self::new(peer, track, MediaKind::Video, state)
149    }
150}
151
152#[derive(Debug, PartialEq, Eq)]
153pub enum EndpointRpcIn {
154    PeerClose,
155    SubscribePeer(RpcRequest<RemotePeer>),
156    UnsubscribePeer(RpcRequest<RemotePeer>),
157    MixMinusSourceAdd(RpcRequest<MixMinusSource>),
158    MixMinusSourceRemove(RpcRequest<MixMinusSource>),
159    MixMinusToggle(RpcRequest<MixMinusToggle>),
160}
161
162#[derive(Debug, PartialEq, Eq)]
163pub enum RemoteTrackRpcIn {
164    Toggle(RpcRequest<SenderToggle>),
165}
166
167#[derive(Debug, PartialEq, Eq)]
168pub enum LocalTrackRpcIn {
169    Switch(RpcRequest<ReceiverSwitch>),
170    Limit(RpcRequest<ReceiverLimit>),
171    Disconnect(RpcRequest<ReceiverDisconnect>),
172}
173
174#[derive(Debug, PartialEq, Eq)]
175pub enum EndpointRpcOut {
176    MixMinusSourceAddRes(RpcResponse<bool>),
177    MixMinusSourceRemoveRes(RpcResponse<bool>),
178    MixMinusToggleRes(RpcResponse<bool>),
179    PeerAdded(PeerInfo),
180    PeerUpdated(PeerInfo),
181    PeerRemoved(PeerInfo),
182    TrackAdded(TrackInfo),
183    TrackUpdated(TrackInfo),
184    TrackRemoved(TrackInfo),
185    SubscribePeerRes(RpcResponse<bool>),
186    UnsubscribePeerRes(RpcResponse<bool>),
187    ConnectionAcceptRequest, //Use for calling style rooms
188}
189
190#[derive(Debug, PartialEq, Eq)]
191pub enum RemoteTrackRpcOut {
192    ToggleRes(RpcResponse<bool>),
193}
194
195#[derive(Debug, PartialEq, Eq)]
196pub enum LocalTrackRpcOut {
197    SwitchRes(RpcResponse<bool>),
198    LimitRes(RpcResponse<bool>),
199    DisconnectRes(RpcResponse<bool>),
200}
atm0s_media_server_endpoint/rpc.rs

atm0s_media_server_endpoint/
rpc.rs
