From ea5d0be0e37e807c042728aed23d439dbc4d33ef Mon Sep 17 00:00:00 2001 From: Giang Minh Date: Fri, 24 Nov 2023 08:11:25 +0700 Subject: [PATCH] fix: wrong typos cause publish error --- clusters/local/src/media_hub.rs | 2 +- packages/cluster/Readme.md | 4 +- packages/endpoint/src/endpoint_wrap.rs | 16 ++++---- .../endpoint/src/endpoint_wrap/internal.rs | 40 +++++++++---------- .../local_track/scalable_filter/vp8_sim.rs | 6 +-- servers/media/CHANGELOG.md | 2 +- servers/media/Cargo.toml | 2 +- servers/media/public/whep/whep.js | 2 +- servers/media/public/whip/whip.js | 2 +- servers/media/src/main.rs | 2 +- servers/media/src/server.rs | 6 +-- servers/sip-gateway/Cargo.toml | 2 +- transports/sip/src/SIP.md | 2 +- transports/sip/src/sip/processor/call_in.rs | 4 +- transports/webrtc/CHANGELOG.md | 4 +- transports/webrtc/Cargo.toml | 2 +- transports/webrtc/src/transport.rs | 2 +- transports/webrtc/src/transport/internal.rs | 6 +-- .../webrtc/src/transport/life_cycle/whep.rs | 4 +- .../src/transport/rtp_packet_convert.rs | 2 +- 20 files changed, 56 insertions(+), 56 deletions(-) diff --git a/clusters/local/src/media_hub.rs b/clusters/local/src/media_hub.rs index afdb16d7..c76972f8 100644 --- a/clusters/local/src/media_hub.rs +++ b/clusters/local/src/media_hub.rs @@ -42,7 +42,7 @@ impl LocalMediaHub { } pub fn forward(&self, consumer_id: ConsumerId, event: ClusterRemoteTrackIncomingEvent) { - //TODO optimize this by create map beetween consumer_id and track_uuid + //TODO optimize this by create map between consumer_id and track_uuid for (_, channel) in &self.channels { if channel.consumers.contains_key(&consumer_id) { if let Some((track_id, tx)) = &channel.track { diff --git a/packages/cluster/Readme.md b/packages/cluster/Readme.md index 3daa90cd..a8fbb8ed 100644 --- a/packages/cluster/Readme.md +++ b/packages/cluster/Readme.md @@ -1,4 +1,4 @@ -# Cluster intergration interface +# Cluster integration interface -This package define intergration interface for cluster mode, which support multi-servers, multi-zones +This package define integration interface for cluster mode, which support multi-servers, multi-zones diff --git a/packages/endpoint/src/endpoint_wrap.rs b/packages/endpoint/src/endpoint_wrap.rs index 489aa26c..6777379a 100644 --- a/packages/endpoint/src/endpoint_wrap.rs +++ b/packages/endpoint/src/endpoint_wrap.rs @@ -7,11 +7,11 @@ use media_utils::{EndpointSubscribeScope, Timer}; use transport::{Transport, TransportError}; use crate::{ - endpoint_wrap::internal::{MediaEndpointInteralEvent, MediaInternalAction}, + endpoint_wrap::internal::{MediaEndpointInternalEvent, MediaInternalAction}, rpc::{EndpointRpcIn, EndpointRpcOut, LocalTrackRpcIn, LocalTrackRpcOut, RemoteTrackRpcIn, RemoteTrackRpcOut}, }; -use self::internal::MediaEndpointInteral; +use self::internal::MediaEndpointInternal; mod internal; pub use internal::BitrateLimiterType; @@ -27,7 +27,7 @@ where C: ClusterEndpoint, { _tmp_e: std::marker::PhantomData, - internal: MediaEndpointInteral, + internal: MediaEndpointInternal, transport: T, cluster: C, tick: async_std::stream::Interval, @@ -51,7 +51,7 @@ where } Self { _tmp_e: std::marker::PhantomData, - internal: MediaEndpointInteral::new(room, peer, bitrate_type), + internal: MediaEndpointInternal::new(room, peer, bitrate_type), transport, cluster, tick: async_std::stream::interval(std::time::Duration::from_millis(100)), @@ -69,13 +69,13 @@ where while let Some(out) = self.internal.pop_action() { match out { MediaInternalAction::Internal(e) => match e { - MediaEndpointInteralEvent::ConnectionClosed => { + MediaEndpointInternalEvent::ConnectionClosed => { return Ok(MediaEndpointOutput::ConnectionClosed); } - MediaEndpointInteralEvent::ConnectionCloseRequest => { + MediaEndpointInternalEvent::ConnectionCloseRequest => { return Ok(MediaEndpointOutput::ConnectionCloseRequest); } - MediaEndpointInteralEvent::SubscribePeer(peer) => { + MediaEndpointInternalEvent::SubscribePeer(peer) => { if matches!(self.sub_scope, EndpointSubscribeScope::RoomManual) { self.peer_subscribe.insert(peer.clone(), ()); if let Err(_e) = self.cluster.on_event(cluster::ClusterEndpointOutgoingEvent::SubscribePeer(peer)) { @@ -83,7 +83,7 @@ where } } } - MediaEndpointInteralEvent::UnsubscribePeer(peer) => { + MediaEndpointInternalEvent::UnsubscribePeer(peer) => { if matches!(self.sub_scope, EndpointSubscribeScope::RoomManual) { self.peer_subscribe.remove(&peer); if let Err(_e) = self.cluster.on_event(cluster::ClusterEndpointOutgoingEvent::UnsubscribePeer(peer)) { diff --git a/packages/endpoint/src/endpoint_wrap/internal.rs b/packages/endpoint/src/endpoint_wrap/internal.rs index 3fede199..20bc2cdc 100644 --- a/packages/endpoint/src/endpoint_wrap/internal.rs +++ b/packages/endpoint/src/endpoint_wrap/internal.rs @@ -23,7 +23,7 @@ mod remote_track; pub use bitrate_limiter::BitrateLimiterType; #[derive(Debug, PartialEq, Eq)] -pub enum MediaEndpointInteralEvent { +pub enum MediaEndpointInternalEvent { ConnectionClosed, ConnectionCloseRequest, SubscribePeer(String), @@ -32,12 +32,12 @@ pub enum MediaEndpointInteralEvent { #[derive(Debug, PartialEq, Eq)] pub enum MediaInternalAction { - Internal(MediaEndpointInteralEvent), + Internal(MediaEndpointInternalEvent), Endpoint(TransportOutgoingEvent), Cluster(ClusterEndpointOutgoingEvent), } -pub struct MediaEndpointInteral { +pub struct MediaEndpointInternal { room_id: String, peer_id: String, cluster_track_map: HashMap<(String, String), MediaKind>, @@ -49,9 +49,9 @@ pub struct MediaEndpointInteral { bitrate_limiter: bitrate_limiter::BitrateLimiter, } -impl MediaEndpointInteral { +impl MediaEndpointInternal { pub fn new(room_id: &str, peer_id: &str, bitrate_limiter: BitrateLimiterType) -> Self { - log::info!("[MediaEndpointInteral {}/{}] create", room_id, peer_id); + log::info!("[MediaEndpointInternal {}/{}] create", room_id, peer_id); Self { room_id: room_id.into(), peer_id: peer_id.into(), @@ -73,7 +73,7 @@ impl MediaEndpointInteral { self.output_actions.push_back(MediaInternalAction::Cluster(event)); } - fn push_internal(&mut self, event: MediaEndpointInteralEvent) { + fn push_internal(&mut self, event: MediaEndpointInternalEvent) { self.output_actions.push_back(MediaInternalAction::Internal(event)); } @@ -122,7 +122,7 @@ impl MediaEndpointInteral { TransportStateEvent::Reconnecting => {} TransportStateEvent::Reconnected => {} TransportStateEvent::Disconnected => { - self.push_internal(MediaEndpointInteralEvent::ConnectionClosed); + self.push_internal(MediaEndpointInternalEvent::ConnectionClosed); } } } @@ -244,7 +244,7 @@ impl MediaEndpointInteral { fn process_rpc(&mut self, rpc: EndpointRpcIn) { match rpc { EndpointRpcIn::PeerClose => { - self.push_internal(MediaEndpointInteralEvent::ConnectionCloseRequest); + self.push_internal(MediaEndpointInternalEvent::ConnectionCloseRequest); } EndpointRpcIn::SubscribePeer(peer) => {} EndpointRpcIn::UnsubscribePeer(peer) => {} @@ -400,23 +400,23 @@ impl MediaEndpointInteral { pub fn before_drop(&mut self, now_ms: u64) { let local_tracks = std::mem::take(&mut self.local_tracks); for (track_id, mut track) in local_tracks { - log::info!("[MediaEndpointInteral {}/{}] close local track {}", self.room_id, self.peer_id, track_id); + log::info!("[MediaEndpointInternal {}/{}] close local track {}", self.room_id, self.peer_id, track_id); track.close(); self.pop_local_track_actions(now_ms, track_id, &mut track); } let remote_tracks = std::mem::take(&mut self.remote_tracks); for (track_id, mut track) in remote_tracks { - log::info!("[MediaEndpointInteral {}/{}] close remote track {}", self.room_id, self.peer_id, track_id); + log::info!("[MediaEndpointInternal {}/{}] close remote track {}", self.room_id, self.peer_id, track_id); track.close(); self.pop_remote_track_actions(track_id, &mut track); } } } -impl Drop for MediaEndpointInteral { +impl Drop for MediaEndpointInternal { fn drop(&mut self) { - log::info!("[MediaEndpointInteral {}/{}] drop", self.room_id, self.peer_id); + log::info!("[MediaEndpointInternal {}/{}] drop", self.room_id, self.peer_id); assert!(self.local_tracks.is_empty()); assert!(self.remote_tracks.is_empty()); } @@ -430,16 +430,16 @@ mod tests { }; use crate::{ - endpoint_wrap::internal::{bitrate_limiter::BitrateLimiterType, MediaEndpointInteralEvent, MediaInternalAction, DEFAULT_BITRATE_OUT_BPS}, + endpoint_wrap::internal::{bitrate_limiter::BitrateLimiterType, MediaEndpointInternalEvent, MediaInternalAction, DEFAULT_BITRATE_OUT_BPS}, rpc::{LocalTrackRpcIn, LocalTrackRpcOut, ReceiverSwitch, RemoteStream, TrackInfo}, EndpointRpcOut, RpcRequest, RpcResponse, }; - use super::MediaEndpointInteral; + use super::MediaEndpointInternal; #[test] fn should_fire_cluster_when_remote_track_added_then_close() { - let mut endpoint = MediaEndpointInteral::new("room1", "peer1", BitrateLimiterType::DynamicWithConsumers); + let mut endpoint = MediaEndpointInternal::new("room1", "peer1", BitrateLimiterType::DynamicWithConsumers); let cluster_track_uuid = generate_cluster_track_uuid("room1", "peer1", "audio_main"); endpoint.on_transport(0, TransportIncomingEvent::RemoteTrackAdded("audio_main".to_string(), 100, TrackMeta::new_audio(None))); @@ -483,7 +483,7 @@ mod tests { #[test] fn should_fire_cluster_when_remote_track_added_then_removed() { - let mut endpoint = MediaEndpointInteral::new("room1", "peer1", BitrateLimiterType::DynamicWithConsumers); + let mut endpoint = MediaEndpointInternal::new("room1", "peer1", BitrateLimiterType::DynamicWithConsumers); let cluster_track_uuid = generate_cluster_track_uuid("room1", "peer1", "audio_main"); endpoint.on_transport(0, TransportIncomingEvent::RemoteTrackAdded("audio_main".to_string(), 100, TrackMeta::new_audio(None))); @@ -526,7 +526,7 @@ mod tests { #[test] fn should_fire_rpc_when_cluster_track_added() { - let mut endpoint = MediaEndpointInteral::new("room1", "peer1", BitrateLimiterType::DynamicWithConsumers); + let mut endpoint = MediaEndpointInternal::new("room1", "peer1", BitrateLimiterType::DynamicWithConsumers); endpoint.on_cluster( 0, @@ -558,18 +558,18 @@ mod tests { #[test] fn should_fire_disconnect_when_transport_disconnect() { - let mut endpoint = MediaEndpointInteral::new("room1", "peer1", BitrateLimiterType::DynamicWithConsumers); + let mut endpoint = MediaEndpointInternal::new("room1", "peer1", BitrateLimiterType::DynamicWithConsumers); endpoint.on_transport(0, TransportIncomingEvent::State(TransportStateEvent::Disconnected)); // should output internal event - assert_eq!(endpoint.pop_action(), Some(MediaInternalAction::Internal(MediaEndpointInteralEvent::ConnectionClosed))); + assert_eq!(endpoint.pop_action(), Some(MediaInternalAction::Internal(MediaEndpointInternalEvent::ConnectionClosed))); assert_eq!(endpoint.pop_action(), None); } #[test] fn should_fire_answer_rpc() { - let mut endpoint = MediaEndpointInteral::new("room1", "peer1", BitrateLimiterType::DynamicWithConsumers); + let mut endpoint = MediaEndpointInternal::new("room1", "peer1", BitrateLimiterType::DynamicWithConsumers); endpoint.on_transport(0, TransportIncomingEvent::LocalTrackAdded("video_0".to_string(), 1, TrackMeta::new_video(None))); diff --git a/packages/endpoint/src/endpoint_wrap/internal/local_track/scalable_filter/vp8_sim.rs b/packages/endpoint/src/endpoint_wrap/internal/local_track/scalable_filter/vp8_sim.rs index 75c691a0..d6e6ec36 100644 --- a/packages/endpoint/src/endpoint_wrap/internal/local_track/scalable_filter/vp8_sim.rs +++ b/packages/endpoint/src/endpoint_wrap/internal/local_track/scalable_filter/vp8_sim.rs @@ -172,7 +172,7 @@ mod test { Input::SetTarget(spatial, temporal, key_only, need_key) => { assert_eq!(filter.set_target_layer(spatial, temporal, key_only), need_key, "index: {}", index); } - Input::Packet(is_key, spatial, temporal, pic_id, tl01, layer_sync, seq, time, (result, swiched, exp_pic_id, exp_tl01)) => { + Input::Packet(is_key, spatial, temporal, pic_id, tl01, layer_sync, seq, time, (result, switched, exp_pic_id, exp_tl01)) => { let mut pkt = MediaPacket::simple_video( PayloadCodec::Vp8( is_key, @@ -189,7 +189,7 @@ mod test { vec![1, 2, 3], ); let res = filter.should_send(&mut pkt); - assert_eq!(res, (result, swiched), "index: {}", index); + assert_eq!(res, (result, switched), "index: {}", index); if matches!(res.0, FilterResult::Send) { match &pkt.codec { PayloadCodec::Vp8(_, Some(sim)) => { @@ -238,7 +238,7 @@ mod test { } #[test] - fn rewrite_pic_id_tl01_spatial_switch_stream_remain_continuos() { + fn rewrite_pic_id_tl01_spatial_switch_stream_remain_continuous() { test(vec![ Input::SetTarget(0, 1, false, true), Input::Packet(false, 0, 0, Some(1), Some(1), false, 0, 100, (FilterResult::Reject, false, None, None)), diff --git a/servers/media/CHANGELOG.md b/servers/media/CHANGELOG.md index fec3faaf..228e2fcf 100644 --- a/servers/media/CHANGELOG.md +++ b/servers/media/CHANGELOG.md @@ -20,6 +20,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Update Rust crate clap to 4.4.8 ([#53](https://github.com/8xFF/atm0s-media-server/pull/53)) - Update Rust crate clap to 4.4.7 ([#23](https://github.com/8xFF/atm0s-media-server/pull/23)) - simple rtmp server with SAN I/O style ([#40](https://github.com/8xFF/atm0s-media-server/pull/40)) -- 17 intergrate with bluesea sdn v4 ([#18](https://github.com/8xFF/atm0s-media-server/pull/18)) +- 17 integrate with bluesea sdn v4 ([#18](https://github.com/8xFF/atm0s-media-server/pull/18)) - cargo fmt - break between media-server and transports ([#12](https://github.com/8xFF/atm0s-media-server/pull/12)) diff --git a/servers/media/Cargo.toml b/servers/media/Cargo.toml index 00b6f34a..849b1f93 100644 --- a/servers/media/Cargo.toml +++ b/servers/media/Cargo.toml @@ -20,7 +20,7 @@ media-utils = { workspace = true } async-std = { workspace = true } parking_lot = { workspace = true } futures = { workspace = true } -log = { workpsace = true } +log = { workspace = true } poem = { version = "1.3", features = ["embed"] } poem-openapi = { version = "3.0", features = ["swagger-ui", "static-files"] } serde = { workspace = true } diff --git a/servers/media/public/whep/whep.js b/servers/media/public/whep/whep.js index 692315af..f047b22e 100644 --- a/servers/media/public/whep/whep.js +++ b/servers/media/public/whep/whep.js @@ -198,7 +198,7 @@ export class WHEPClient extends EventTarget //Get current config const config = pc.getConfiguration(); - //If it has ice server info and it is not overriden by the client + //If it has ice server info and it is not overridden by the client if ((!config.iceServer || !config.iceServer.length) && links.hasOwnProperty("ice-server")) { //ICe server config diff --git a/servers/media/public/whip/whip.js b/servers/media/public/whip/whip.js index 0b0bc8ab..ba135684 100644 --- a/servers/media/public/whip/whip.js +++ b/servers/media/public/whip/whip.js @@ -142,7 +142,7 @@ export class WHIPClient //Get current config const config = pc.getConfiguration(); - //If it has ice server info and it is not overriden by the client + //If it has ice server info and it is not overridden by the client if ((!config.iceServer || !config.iceServer.length) && links.hasOwnProperty("ice-server")) { //ICe server config diff --git a/servers/media/src/main.rs b/servers/media/src/main.rs index 9bb8d2be..fb90fdd7 100644 --- a/servers/media/src/main.rs +++ b/servers/media/src/main.rs @@ -107,7 +107,7 @@ async fn main() { let mut server = MediaServer::::new(cluster); while let Ok(event) = rx.recv().await { - server.on_incomming(event).await; + server.on_incoming(event).await; } } diff --git a/servers/media/src/server.rs b/servers/media/src/server.rs index d5c5f508..a9c8d2f0 100644 --- a/servers/media/src/server.rs +++ b/servers/media/src/server.rs @@ -59,7 +59,7 @@ where } } - pub async fn on_incomming(&mut self, event: RpcEvent) { + pub async fn on_incoming(&mut self, event: RpcEvent) { let peers = self.peers.clone(); let conns = self.conns.clone(); @@ -132,7 +132,7 @@ where } }); } else { - res.answer(404, Err(ServerError::build("NOT_FOUND", "Connnection not found"))); + res.answer(404, Err(ServerError::build("NOT_FOUND", "Connection not found"))); } } RpcEvent::WhepConnect(token, sdp, mut res) => { @@ -187,7 +187,7 @@ where } }); } else { - res.answer(404, Err(ServerError::build("NOT_FOUND", "Connnection not found"))); + res.answer(404, Err(ServerError::build("NOT_FOUND", "Connection not found"))); } } RpcEvent::WebrtcConnect(req, mut res) => { diff --git a/servers/sip-gateway/Cargo.toml b/servers/sip-gateway/Cargo.toml index 1292a056..fb6abc47 100644 --- a/servers/sip-gateway/Cargo.toml +++ b/servers/sip-gateway/Cargo.toml @@ -20,7 +20,7 @@ media-utils = { workspace = true } async-std = { workspace = true } parking_lot = { workspace = true } futures = { workspace = true } -log = { workpsace = true } +log = { workspace = true } poem = "1.3" poem-openapi = { version = "3.0", features = ["swagger-ui"] } env_logger = { workspace = true } diff --git a/transports/sip/src/SIP.md b/transports/sip/src/SIP.md index 1f2b91b1..e83409a1 100644 --- a/transports/sip/src/SIP.md +++ b/transports/sip/src/SIP.md @@ -33,7 +33,7 @@ Process request in order: authentication -> method -> header -> others For authentication, read rfc for more info. -If not support -> Must generate 405 response with allow types in Alow header (how to generate response in https://www.rfceditor.org/rfc/rfc3261.html#section-8.2.6) +If not support -> Must generate 405 response with allow types in Allow header (how to generate response in https://www.rfceditor.org/rfc/rfc3261.html#section-8.2.6) If support -> continue diff --git a/transports/sip/src/sip/processor/call_in.rs b/transports/sip/src/sip/processor/call_in.rs index bbc7b1d1..847f50f7 100644 --- a/transports/sip/src/sip/processor/call_in.rs +++ b/transports/sip/src/sip/processor/call_in.rs @@ -317,7 +317,7 @@ mod test { assert_eq!(res.raw.status_code, rsip::StatusCode::Trying); assert_eq!(processor.pop_action(), None); - //after call ringing shoudl send Ringing + //after call ringing should send Ringing processor.ringing(T1 + 1000).expect("Should ok"); let (_, res) = cast2!(processor.pop_action().expect("Should have action"), ProcessorAction::SendResponse); assert_eq!(res.raw.status_code, rsip::StatusCode::Ringing); @@ -360,7 +360,7 @@ mod test { assert_eq!(res.raw.status_code, rsip::StatusCode::Trying); assert_eq!(processor.pop_action(), None); - //after call ringing shoudl send Ringing + //after call ringing should send Ringing processor.ringing(T1 + 1000).expect("Should ok"); let (_, res) = cast2!(processor.pop_action().expect("Should have action"), ProcessorAction::SendResponse); assert_eq!(res.raw.status_code, rsip::StatusCode::Ringing); diff --git a/transports/webrtc/CHANGELOG.md b/transports/webrtc/CHANGELOG.md index 05c529b6..f18283eb 100644 --- a/transports/webrtc/CHANGELOG.md +++ b/transports/webrtc/CHANGELOG.md @@ -21,9 +21,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - update few simple unit tests ([#60](https://github.com/8xFF/atm0s-media-server/pull/60)) - Bump criterion from 0.4.0 to 0.5.1 ([#28](https://github.com/8xFF/atm0s-media-server/pull/28)) - Bump lz4_flex from 0.9.5 to 0.11.1 ([#27](https://github.com/8xFF/atm0s-media-server/pull/27)) -- Update Rust crate flate2 to 1.0.28 ([#22](https://github.com/8xFF/atm0s-media-server/pull/22)) +- Update Rust crate flat2 to 1.0.28 ([#22](https://github.com/8xFF/atm0s-media-server/pull/22)) - update with newest sdn ([#21](https://github.com/8xFF/atm0s-media-server/pull/21)) -- 17 intergrate with bluesea sdn v4 ([#18](https://github.com/8xFF/atm0s-media-server/pull/18)) +- 17 integrate with bluesea sdn v4 ([#18](https://github.com/8xFF/atm0s-media-server/pull/18)) - cargo fmt - dynamic payload type from remote ([#16](https://github.com/8xFF/atm0s-media-server/pull/16)) - update udp_sas for fixing unstable ([#14](https://github.com/8xFF/atm0s-media-server/pull/14)) diff --git a/transports/webrtc/Cargo.toml b/transports/webrtc/Cargo.toml index 743f9537..cef67c61 100644 --- a/transports/webrtc/Cargo.toml +++ b/transports/webrtc/Cargo.toml @@ -16,7 +16,7 @@ media-utils = { workspace = true } poem-openapi = { version = "3.0", features = ["swagger-ui"] } str0m = { version = "0.1.0", package = "atm0s-custom-str0m" } futures = { workspace = true } -log = { workpsace = true } +log = { workspace = true } serde = { workspace = true } serde_json = { workspace = true } lz4_flex = { version = "0.11.1" } diff --git a/transports/webrtc/src/transport.rs b/transports/webrtc/src/transport.rs index c89ff421..66db82c5 100644 --- a/transports/webrtc/src/transport.rs +++ b/transports/webrtc/src/transport.rs @@ -313,7 +313,7 @@ where ) } Ok(Err(e)) => { - log::error!("[TransportWebrtc] network eror {:?}", e); + log::error!("[TransportWebrtc] network error {:?}", e); return Err(TransportError::NetworkError); } Err(_e) => { diff --git a/transports/webrtc/src/transport/internal.rs b/transports/webrtc/src/transport/internal.rs index fae161f2..d2efc87a 100644 --- a/transports/webrtc/src/transport/internal.rs +++ b/transports/webrtc/src/transport/internal.rs @@ -212,8 +212,8 @@ where match event { Str0mInput::Connected => Ok(()), - Str0mInput::ChannelOpen(chanel_id, _name) => { - self.channel_id = Some(chanel_id); + Str0mInput::ChannelOpen(channel_id, _name) => { + self.channel_id = Some(channel_id); self.restore_msgs(); Ok(()) } @@ -265,7 +265,7 @@ where Err(TransportError::RuntimeError(TransportRuntimeError::RpcInvalid)) } } - Str0mInput::ChannelClosed(_chanel_id) => Ok(()), + Str0mInput::ChannelClosed(_channel_id) => Ok(()), Str0mInput::IceConnectionStateChange(_state) => Ok(()), Str0mInput::MediaPacket(track_id, pkt) => { self.endpoint_actions diff --git a/transports/webrtc/src/transport/life_cycle/whep.rs b/transports/webrtc/src/transport/life_cycle/whep.rs index fcc54f2a..b3b12ac7 100644 --- a/transports/webrtc/src/transport/life_cycle/whep.rs +++ b/transports/webrtc/src/transport/life_cycle/whep.rs @@ -304,7 +304,7 @@ mod tests { assert_eq!(life_cycle.pop_action(), Some(Out::ToEndpoint(event))); assert_eq!(life_cycle.pop_action(), None); - // on endpint RemoteRemoved => should request disconnected + // on endpoint RemoteRemoved => should request disconnected life_cycle.on_endpoint_event( 1000, &TransportOutgoingEvent::Rpc(EndpointRpcOut::TrackRemoved(TrackInfo { @@ -401,7 +401,7 @@ mod tests { assert_eq!(life_cycle.pop_action(), Some(Out::ToEndpoint(event))); assert_eq!(life_cycle.pop_action(), None); - // on endpint RemoteRemoved => should request disconnected + // on endpoint RemoteRemoved => should request disconnected life_cycle.on_endpoint_event( 1000, &TransportOutgoingEvent::Rpc(EndpointRpcOut::TrackRemoved(TrackInfo { diff --git a/transports/webrtc/src/transport/rtp_packet_convert.rs b/transports/webrtc/src/transport/rtp_packet_convert.rs index 89d25b0f..d983c02c 100644 --- a/transports/webrtc/src/transport/rtp_packet_convert.rs +++ b/transports/webrtc/src/transport/rtp_packet_convert.rs @@ -81,7 +81,7 @@ impl RtpPacketConverter { time: rtp.header.timestamp, marker: rtp.header.marker, // ext_vals: MediaPacketExtensions { - // abs_send_time: rtp.header.ext_vals.abs_send_time.map(|t| (t.numer(), t.denom())), + // abs_send_time: rtp.header.ext_vals.abs_send_time.map(|t| (t.number(), t.denom())), // transport_cc: rtp.header.ext_vals.transport_cc, // }, nackable: nackable,