Merge pull request #8 from webrtc-rs/marshal

Marshal

Author: Rain

crates/rtcp/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rtcp"
-version = "0.2.2"
+version = "0.2.3"
 authors = ["Rain Liu <[email protected]>", "Michael Uti <[email protected]>"]
 edition = "2018"
 description = "A pure Rust implementation of RTCP"
@@ -12,7 +12,7 @@ repository = "https://github.com/webrtc-rs/rtcp"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-util = { package = "webrtc-util", version = "0.2.1", default-features = false, features = ["marshal"] }
+util = { package = "webrtc-util", version = "0.2.3", default-features = false, features = ["marshal"] }
 bytes = "1"
 thiserror = "1.0.25"
 anyhow = "1.0.41"

crates/rtcp/src/compound_packet/compound_packet_test.rs

@@ -34,23 +34,21 @@ const REAL_PACKET: [u8; 116] = [
 
 #[test]
 fn test_read_eof() {
-    let short_header = Bytes::from_static(&[
+    let mut short_header = Bytes::from_static(&[
         0x81, 0xc9, // missing type & len
     ]);
-
-    let result = unmarshal(&short_header);
+    let result = unmarshal(&mut short_header);
     assert!(result.is_err(), "missing type & len");
 }
 
 #[test]
 fn test_bad_compound() {
-    let bad_compound = Bytes::copy_from_slice(&REAL_PACKET[..34]);
-    let result = unmarshal(&bad_compound);
+    let mut bad_compound = Bytes::copy_from_slice(&REAL_PACKET[..34]);
+    let result = unmarshal(&mut bad_compound);
     assert!(result.is_err(), "trailing data!");
 
-    let bad_compound = Bytes::copy_from_slice(&REAL_PACKET[84..104]);
-
-    let p = unmarshal(&bad_compound).expect("Error unmarshalling packet");
+    let mut bad_compound = Bytes::copy_from_slice(&REAL_PACKET[84..104]);
+    let p = unmarshal(&mut bad_compound).expect("Error unmarshalling packet");
     let compound = p.as_any().downcast_ref::<CompoundPacket>().unwrap();
 
     // this should return an error,
@@ -340,10 +338,12 @@ fn test_compound_packet_roundtrip() {
         }
 
         let data1 = result.unwrap();
+        let c = CompoundPacket::unmarshal(&mut data1.clone())
+            .expect(format!("unmarshal {} error", name).as_str());
 
-        let c = CompoundPacket::unmarshal(&data1).expect("Unmarshall should be nil");
-
-        let data2 = c.marshal().expect("Marshal should be nil");
+        let data2 = c
+            .marshal()
+            .expect(format!("marshal {} error", name).as_str());
 
         assert_eq!(
             data1, data2,

crates/rtcp/src/compound_packet/mod.rs

@@ -1,11 +1,16 @@
 #[cfg(test)]
 mod compound_packet_test;
 
-use crate::{error::Error, packet::*, receiver_report::*, sender_report::*, source_description::*};
+use crate::{
+    error::Error, header::*, packet::*, receiver_report::*, sender_report::*,
+    source_description::*, util::*,
+};
+use util::marshal::{Marshal, MarshalSize, Unmarshal};
 
 use anyhow::Result;
-use bytes::{Bytes, BytesMut};
+use bytes::{Buf, Bytes};
 use std::any::Any;
+use std::fmt;
 
 /// A CompoundPacket is a collection of RTCP packets transmitted as a single packet with
 /// the underlying protocol (for example UDP).
@@ -19,10 +24,20 @@ use std::any::Any;
 /// to identify the source and to begin associating media for purposes such as lip-sync.
 ///
 /// Other RTCP packet types may follow in any order. Packet types may appear more than once.
-#[derive(PartialEq, Default, Clone)]
+#[derive(Debug, Default, PartialEq, Clone)]
 pub struct CompoundPacket(pub Vec<Box<dyn Packet>>);
 
+impl fmt::Display for CompoundPacket {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
 impl Packet for CompoundPacket {
+    fn header(&self) -> Header {
+        Header::default()
+    }
+
     /// destination_ssrc returns the synchronization sources associated with this
     /// CompoundPacket's reception report.
     fn destination_ssrc(&self) -> Vec<u32> {
@@ -33,56 +48,70 @@ impl Packet for CompoundPacket {
         }
     }
 
-    fn size(&self) -> usize {
+    fn raw_size(&self) -> usize {
         let mut l = 0;
         for packet in &self.0 {
             l += packet.marshal_size();
         }
         l
     }
 
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn equal(&self, other: &dyn Packet) -> bool {
+        other
+            .as_any()
+            .downcast_ref::<CompoundPacket>()
+            .map_or(false, |a| self == a)
+    }
+
+    fn cloned(&self) -> Box<dyn Packet> {
+        Box::new(self.clone())
+    }
+}
+
+impl MarshalSize for CompoundPacket {
+    fn marshal_size(&self) -> usize {
+        let l = self.raw_size();
+        // align to 32-bit boundary
+        l + get_padding_size(l)
+    }
+}
+
+impl Marshal for CompoundPacket {
     /// Marshal encodes the CompoundPacket as binary.
-    fn marshal(&self) -> Result<Bytes> {
+    fn marshal_to(&self, mut buf: &mut [u8]) -> Result<usize> {
         self.validate()?;
 
-        let mut out = BytesMut::new();
         for packet in &self.0 {
-            let a = packet.marshal()?;
-            out.extend(a);
+            let n = packet.marshal_to(buf)?;
+            buf = &mut buf[n..];
         }
-        Ok(out.freeze())
+
+        Ok(self.marshal_size())
     }
+}
 
-    fn unmarshal(raw_data: &Bytes) -> Result<Self> {
+impl Unmarshal for CompoundPacket {
+    fn unmarshal<B>(raw_packet: &mut B) -> Result<Self>
+    where
+        Self: Sized,
+        B: Buf,
+    {
         let mut packets = vec![];
 
-        let mut raw_data = raw_data.clone();
-        while !raw_data.is_empty() {
-            let (p, processed) = unmarshaller(&raw_data)?;
+        while raw_packet.has_remaining() {
+            let p = unmarshaller(raw_packet)?;
             packets.push(p);
-            raw_data = raw_data.split_off(processed);
         }
 
         let c = CompoundPacket(packets);
         c.validate()?;
 
         Ok(c)
     }
-
-    fn equal_to(&self, other: &dyn Packet) -> bool {
-        other
-            .as_any()
-            .downcast_ref::<CompoundPacket>()
-            .map_or(false, |a| self == a)
-    }
-
-    fn clone_to(&self) -> Box<dyn Packet> {
-        Box::new(self.clone())
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
 }
 
 impl CompoundPacket {

crates/rtcp/src/error.rs

@@ -37,6 +37,9 @@ pub enum Error {
     /// Packet received is too short.
     #[error("Packet status chunk must be 2 bytes")]
     PacketTooShort,
+    /// Buffer is too short.
+    #[error("Buffer too short to be written")]
+    BufferTooShort,
     /// Wrong packet type.
     #[error("Wrong packet type")]
     WrongType,

crates/rtcp/src/goodbye/goodbye_test.rs

@@ -103,8 +103,8 @@ fn test_goodbye_unmarshal() {
         ),
     ];
 
-    for (name, data, want, want_error) in tests {
-        let got = Goodbye::unmarshal(&data);
+    for (name, mut data, want, want_error) in tests {
+        let got = Goodbye::unmarshal(&mut data);
 
         assert_eq!(
             got.is_err(),
@@ -225,8 +225,9 @@ fn test_goodbye_round_trip() {
                 err,
             );
         } else {
-            let data = got.ok().unwrap();
-            let actual = Goodbye::unmarshal(&data).expect(format!("Unmarshal {}", name).as_str());
+            let mut data = got.ok().unwrap();
+            let actual =
+                Goodbye::unmarshal(&mut data).expect(format!("Unmarshal {}", name).as_str());
 
             assert_eq!(
                 actual, want,