use new util Marshal trait

Author: rainliu

Cargo.toml

@@ -12,7 +12,7 @@ repository = "https://github.com/webrtc-rs/rtp"
 # 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.2", default-features = false, features = ["marshal"] }
 bytes = "1"
 rand = "0.8.0"
 thiserror = "1.0.25"

src/extension/abs_send_time_extension/abs_send_time_extension_test.rs

@@ -55,6 +55,7 @@ fn test_abs_send_time_extension_roundtrip() -> Result<()> {
 
     for test in &tests {
         let mut raw = BytesMut::with_capacity(test.marshal_size());
+        raw.resize(test.marshal_size(), 0);
         test.marshal_to(&mut raw)?;
         let raw = raw.freeze();
         let buf = &mut raw.clone();
@@ -79,6 +80,7 @@ fn test_abs_send_time_extension_estimate() -> Result<()> {
             timestamp: send_ntp >> 14,
         };
         let mut raw = BytesMut::with_capacity(send.marshal_size());
+        raw.resize(send.marshal_size(), 0);
         send.marshal_to(&mut raw)?;
         let raw = raw.freeze();
         let buf = &mut raw.clone();

src/extension/abs_send_time_extension/mod.rs

@@ -45,10 +45,7 @@ impl MarshalSize for AbsSendTimeExtension {
 
 impl Marshal for AbsSendTimeExtension {
     /// MarshalTo serializes the members to buffer.
-    fn marshal_to<B>(&self, buf: &mut B) -> Result<usize>
-    where
-        B: BufMut,
-    {
+    fn marshal_to(&self, mut buf: &mut [u8]) -> Result<usize> {
         if buf.remaining_mut() < ABS_SEND_TIME_EXTENSION_SIZE {
             return Err(Error::ErrBufferTooSmall.into());
         }

src/extension/audio_level_extension/audio_level_extension_test.rs

@@ -22,6 +22,7 @@ fn test_audio_level_extension_voice_true() -> Result<()> {
     assert_eq!(a1, a2);
 
     let mut dst = BytesMut::with_capacity(a2.marshal_size());
+    dst.resize(a2.marshal_size(), 0);
     a2.marshal_to(&mut dst)?;
     assert_eq!(raw, dst.freeze());
 
@@ -40,6 +41,7 @@ fn test_audio_level_extension_voice_false() -> Result<()> {
     assert_eq!(a1, a2);
 
     let mut dst = BytesMut::with_capacity(a2.marshal_size());
+    dst.resize(a2.marshal_size(), 0);
     a2.marshal_to(&mut dst)?;
     assert_eq!(raw, dst.freeze());
 
@@ -54,6 +56,7 @@ fn test_audio_level_extension_level_overflow() -> Result<()> {
     };
 
     let mut dst = BytesMut::with_capacity(a.marshal_size());
+    dst.resize(a.marshal_size(), 0);
     let result = a.marshal_to(&mut dst);
     assert!(result.is_err());
 

src/extension/audio_level_extension/mod.rs

@@ -64,10 +64,7 @@ impl MarshalSize for AudioLevelExtension {
 
 impl Marshal for AudioLevelExtension {
     /// MarshalTo serializes the members to buffer
-    fn marshal_to<B>(&self, buf: &mut B) -> Result<usize>
-    where
-        B: BufMut,
-    {
+    fn marshal_to(&self, mut buf: &mut [u8]) -> Result<usize> {
         if buf.remaining_mut() < AUDIO_LEVEL_EXTENSION_SIZE {
             return Err(Error::ErrBufferTooSmall.into());
         }

src/extension/transport_cc_extension/mod.rs

@@ -51,10 +51,7 @@ impl MarshalSize for TransportCcExtension {
 
 impl Marshal for TransportCcExtension {
     /// Marshal serializes the members to buffer
-    fn marshal_to<B>(&self, buf: &mut B) -> Result<usize>
-    where
-        B: BufMut,
-    {
+    fn marshal_to(&self, mut buf: &mut [u8]) -> Result<usize> {
         if buf.remaining_mut() < TRANSPORT_CC_EXTENSION_SIZE {
             return Err(Error::ErrBufferTooSmall.into());
         }

src/extension/transport_cc_extension/transport_cc_extension_test.rs

@@ -21,6 +21,7 @@ fn test_transport_cc_extension() -> Result<()> {
     assert_eq!(t1, t2);
 
     let mut dst = BytesMut::with_capacity(t2.marshal_size());
+    dst.resize(t2.marshal_size(), 0);
     t2.marshal_to(&mut dst)?;
     assert_eq!(raw, dst.freeze());
 

src/header.rs

@@ -214,10 +214,7 @@ impl MarshalSize for Header {
 
 impl Marshal for Header {
     /// Marshal serializes the header and writes to the buffer.
-    fn marshal_to<B>(&self, writer: &mut B) -> Result<usize>
-    where
-        B: BufMut,
-    {
+    fn marshal_to(&self, mut buf: &mut [u8]) -> Result<usize> {
         /*
          *  0                   1                   2                   3
          *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
@@ -232,7 +229,7 @@ impl Marshal for Header {
          * |                             ....                              |
          * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          */
-        if writer.remaining_mut() < self.marshal_size() {
+        if buf.remaining_mut() < self.marshal_size() {
             return Err(Error::ErrBufferTooSmall.into());
         }
 
@@ -245,27 +242,27 @@ impl Marshal for Header {
         if self.extension {
             b0 |= 1 << EXTENSION_SHIFT;
         }
-        writer.put_u8(b0);
+        buf.put_u8(b0);
 
         // The second byte contains the marker bit and payload type.
         let mut b1 = self.payload_type;
         if self.marker {
             b1 |= 1 << MARKER_SHIFT;
         }
-        writer.put_u8(b1);
+        buf.put_u8(b1);
 
-        writer.put_u16(self.sequence_number);
-        writer.put_u32(self.timestamp);
-        writer.put_u32(self.ssrc);
+        buf.put_u16(self.sequence_number);
+        buf.put_u32(self.timestamp);
+        buf.put_u32(self.ssrc);
 
         let mut n = 12;
         for csrc in &self.csrc {
-            writer.put_u32(*csrc);
+            buf.put_u32(*csrc);
             n += 4;
         }
 
         if self.extension {
-            writer.put_u16(self.extension_profile);
+            buf.put_u16(self.extension_profile);
             n += 2;
 
             // calculate extensions size and round to 4 bytes boundaries
@@ -278,27 +275,27 @@ impl Marshal for Header {
                 return Err(Error::HeaderExtensionPayloadNot32BitWords.into());
             }
             let extension_payload_size = (extension_payload_len as u16 + 3) / 4;
-            writer.put_u16(extension_payload_size);
+            buf.put_u16(extension_payload_size);
             n += 2;
 
             match self.extension_profile {
                 // RFC 8285 RTP One Byte Header Extension
                 EXTENSION_PROFILE_ONE_BYTE => {
                     for extension in &self.extensions {
-                        writer.put_u8((extension.id << 4) | (extension.payload.len() as u8 - 1));
+                        buf.put_u8((extension.id << 4) | (extension.payload.len() as u8 - 1));
                         n += 1;
-                        writer.put(&*extension.payload);
+                        buf.put(&*extension.payload);
                         n += extension.payload.len();
                     }
                 }
                 // RFC 8285 RTP Two Byte Header Extension
                 EXTENSION_PROFILE_TWO_BYTE => {
                     for extension in &self.extensions {
-                        writer.put_u8(extension.id);
+                        buf.put_u8(extension.id);
                         n += 1;
-                        writer.put_u8(extension.payload.len() as u8);
+                        buf.put_u8(extension.payload.len() as u8);
                         n += 1;
-                        writer.put(&*extension.payload);
+                        buf.put(&*extension.payload);
                         n += extension.payload.len();
                     }
                 }
@@ -313,15 +310,15 @@ impl Marshal for Header {
                         if ext_len % 4 != 0 {
                             return Err(Error::HeaderExtensionPayloadNot32BitWords.into());
                         }
-                        writer.put(&*extension.payload);
+                        buf.put(&*extension.payload);
                         n += ext_len;
                     }
                 }
             };
 
             // add padding to reach 4 bytes boundaries
             for _ in extension_payload_len..extension_payload_size as usize * 4 {
-                writer.put_u8(0);
+                buf.put_u8(0);
                 n += 1;
             }
         }

src/packet/mod.rs

@@ -82,15 +82,13 @@ impl MarshalSize for Packet {
 
 impl Marshal for Packet {
     /// MarshalTo serializes the packet and writes to the buffer.
-    fn marshal_to<B>(&self, buf: &mut B) -> Result<usize>
-    where
-        B: BufMut,
-    {
+    fn marshal_to(&self, mut buf: &mut [u8]) -> Result<usize> {
         if buf.remaining_mut() < self.marshal_size() {
             return Err(Error::ErrBufferTooSmall.into());
         }
 
         let n = self.header.marshal_to(buf)?;
+        buf = &mut buf[n..];
         buf.put(&*self.payload);
         let padding_len = if self.header.padding {
             let mut padding_len = get_padding(self.payload.len());

src/packet/packet_test.rs

@@ -1,6 +1,6 @@
 use super::*;
 use bytes::{Bytes, BytesMut};
-use std::collections::HashMap;
+//use std::collections::HashMap;
 
 #[test]
 fn test_basic() -> Result<()> {
@@ -53,8 +53,8 @@ fn test_basic() -> Result<()> {
         "wrong computed marshal size"
     );
 
-    let mut raw = BytesMut::new();
-    let n = packet.marshal_to(&mut raw)?;
+    let raw = packet.marshal()?;
+    let n = raw.len();
     assert_eq!(n, raw_pkt.len(), "wrong marshal size");
 
     assert_eq!(
@@ -115,6 +115,9 @@ fn test_extension() -> Result<()> {
         result.is_err(),
         "Marshal did not error on packet with invalid extension length"
     );
+    if let Err(err) = result {
+        assert!(Error::ErrBufferTooSmall.equal(&err));
+    }
 
     Ok(())
 }
@@ -158,12 +161,8 @@ fn test_packet_marshal_unmarshal() -> Result<()> {
         payload: Bytes::from_static(&[0xFFu8; 15]),
         ..Default::default()
     };
-    let mut raw = BytesMut::new();
-    let _ = pkt.marshal_to(&mut raw)?;
-
-    let raw = raw.freeze();
-    let buf = &mut raw.clone();
-    let p = Packet::unmarshal(buf)?;
+    let mut raw = pkt.marshal()?;
+    let p = Packet::unmarshal(&mut raw)?;
 
     assert_eq!(pkt, p);
 
@@ -199,8 +198,7 @@ fn test_rfc8285_one_byte_extension() -> Result<()> {
         payload: raw_pkt.slice(20..),
     };
 
-    let mut dst = BytesMut::new();
-    let _ = p.marshal_to(&mut dst)?;
+    let dst =  p.marshal()?;
     assert_eq!(dst, raw_pkt);
 
     Ok(())
@@ -266,8 +264,7 @@ fn test_rfc8285_one_byte_two_extension_of_two_bytes() -> Result<()> {
         payload: raw_pkt.slice(20..),
     };
 
-    let mut dst = BytesMut::new();
-    let _ = p.marshal_to(&mut dst)?;
+    let dst = p.marshal()?;
     assert_eq!(dst, raw_pkt);
 
     Ok(())
@@ -329,7 +326,7 @@ fn test_rfc8285_one_byte_multiple_extensions_with_padding() -> Result<()> {
         0x98, 0x36, 0xbe, 0x88, 0x9e,
     ];
 
-    let checker = |name: &str, buf: &mut [u8], p: &mut Packet| -> Result<()> {
+    let checker = |name: &str, buf: &mut [u8], p: &Packet| -> Result<()> {
         let size = p.marshal_to(buf)?;
 
         assert_eq!(
@@ -342,8 +339,16 @@ fn test_rfc8285_one_byte_multiple_extensions_with_padding() -> Result<()> {
         Ok(())
     };
 
-    checker("CleanBuffer", &mut dst_buf[0], &mut p)?;
-    checker("DirtyBuffer", &mut dst_buf[1], &mut p)
+    checker("CleanBuffer", &mut dst_buf[0], &packet)?;
+    checker("DirtyBuffer", &mut dst_buf[1], &packet)?;
+
+    let result = packet.marshal_to(&mut dst_buf[2]);
+    assert!(result.is_err());
+    if let Err(err) = result {
+        assert!(Error::ErrBufferTooSmall.equal(&err));
+    }
+
+    Ok(())
 }
 
 /*