pencil in SendingPacket and StreamDirection

Author: cody-the-casual-dev

src/client/mod.rs

@@ -24,6 +24,7 @@ use url::Url;
 
 use crate::client::parse::SessionHeader;
 use crate::codec::CodecItem;
+use crate::rtp::SendingPacket;
 use crate::{
     Error, ErrorInt, RtspMessageContext, StreamContext, StreamContextInner, TcpStreamContext,
     UdpStreamContext,
@@ -687,6 +688,13 @@ impl std::ops::Deref for Tool {
     }
 }
 
+//enum sending or Receiving
+#[derive(Copy, Clone, Debug)]
+pub enum StreamDirection{
+    Receiving,
+    Sending,
+}
+
 /// Information about a stream offered within a presentation.
 ///
 /// Currently if multiple formats are offered, this only describes the first.
@@ -702,6 +710,7 @@ pub struct Stream {
     channels: Option<NonZeroU16>,
     framerate: Option<f32>,
     control: Option<Url>,
+    direction: StreamDirection
 }
 
 impl std::fmt::Debug for Stream {
@@ -714,6 +723,7 @@ impl std::fmt::Debug for Stream {
             .field("clock_rate", &self.clock_rate_hz)
             .field("channels", &self.channels)
             .field("framerate", &self.framerate)
+            .field("direction", &self.direction)
             .field("depacketizer", &self.depacketizer)
             .field("state", &self.state)
             .finish()
@@ -781,6 +791,10 @@ impl Stream {
     pub fn control(&self) -> Option<&Url> {
         self.control.as_ref()
     }
+
+    pub fn direction(&self) -> StreamDirection {
+        self.direction
+    }
 }
 
 struct UdpSockets {
@@ -2330,6 +2344,28 @@ impl PinnedDrop for SessionInner {
     }
 }
 
+impl futures::Sink<SendingPacket> for Session<Playing>{
+    type Error = futures::io::Error;
+
+    fn poll_ready(self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn start_send(self: Pin<&mut Self>, item: SendingPacket) -> Result<(), Self::Error> {
+        //self.0.conn.as_mut().unwrap().inner.send(item);
+        Ok(())
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_close(self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+
 impl futures::Stream for Session<Playing> {
     type Item = Result<PacketItem, Error>;
 

src/client/parse.rs

@@ -7,7 +7,7 @@ use sdp_types::Media;
 use std::{net::IpAddr, num::NonZeroU16};
 use url::Url;
 
-use super::{Presentation, Stream};
+use super::{Presentation, Stream, StreamDirection};
 
 /// A static payload type in the [RTP parameters
 /// registry](https://www.iana.org/assignments/rtp-parameters/rtp-parameters.xhtml#rtp-parameters-1).
@@ -257,6 +257,7 @@ fn parse_media(base_url: &Url, media_description: &Media) -> Result<Stream, Stri
     let mut fmtp = None;
     let mut control = None;
     let mut framerate = None;
+    let mut direction = StreamDirection::Receiving;
     for a in &media_description.attributes {
         match a.attribute.as_str() {
             "rtpmap" => {
@@ -313,6 +314,9 @@ fn parse_media(base_url: &Url, media_description: &Media) -> Result<Stream, Stri
                     }
                 }
             }
+            "sendonly" => {
+                direction=StreamDirection::Sending;
+            }
             _ => (),
         }
     }
@@ -376,6 +380,7 @@ fn parse_media(base_url: &Url, media_description: &Media) -> Result<Stream, Stri
         channels,
         framerate,
         state: super::StreamState::Uninit,
+        direction,
     })
 }
 

src/rtp.rs

@@ -229,6 +229,21 @@ impl RawPacketBuilder {
     }
 }
 
+pub struct SendingPacket{
+    stream_id: usize,
+    raw: RawPacket,
+    payload_range: Range<u16>,    
+}
+
+impl std::fmt::Debug for SendingPacket {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SendingPacket")
+            .field("streamId", &self.stream_id)
+            .field("payload_type", &self.raw.payload_type())
+            .finish()
+    }
+}
+
 /// A received RTP packet.
 ///
 /// This holds more information than the packet itself: also a