Feature/UUID

src/any.rs

@@ -369,6 +369,7 @@ any! {
     Mfra,
         Tfra,
         Mfro,
+    Uuid,
     ],
     boxed: [
         Trak,

src/lib.rs

@@ -158,6 +158,8 @@ mod prft;
 mod sidx;
 mod styp;
 mod types;
+mod uuid;
+mod uuid_boxes;
 
 pub use any::*;
 pub use atom::*;
@@ -180,6 +182,8 @@ pub use prft::*;
 pub use sidx::*;
 pub use styp::*;
 pub use types::*;
+pub use uuid::*;
+pub use uuid_boxes::*;
 
 #[cfg(feature = "tokio")]
 mod tokio;

src/test/c2pa.rs

@@ -0,0 +1,32 @@
+use crate::*;
+
+use std::io::Cursor;
+
+#[test]
+fn read_c2pa_from_c2pa_mp4() -> Result<()> {
+    // Example file from c2pa, and independently verified with bento4 - mp4dump and c2patool
+    // https://github.com/c2pa-org/public-testfiles/tree/main/legacy/1.4/video/mp4
+    const ENCODED: &[u8] = include_bytes!("c2pa.mp4");
+
+    let mut cursor = Cursor::new(ENCODED);
+
+    let recieved_ftyp = Ftyp::decode(&mut cursor)?;
+    let expected_ftyp = Ftyp {
+        major_brand: b"mp42".into(),
+        minor_version: 0,
+        compatible_brands: vec![b"isom".into(), b"mp42".into()],
+    };
+
+    assert_eq!(recieved_ftyp, expected_ftyp);
+
+    let uuid = Uuid::decode(&mut cursor)?;
+
+    let c2pa_data = match uuid {
+        Uuid::C2pa(data) => data,
+        other => panic!("Expected Uuid::C2pa, got {:?}", other),
+    };
+
+    assert_eq!(c2pa_data.box_purpose, "manifest");
+
+    Ok(())
+}

src/test/mod.rs

@@ -1,6 +1,7 @@
 mod av1;
 mod av1_mdta;
 mod bbb;
+mod c2pa;
 mod esds;
 mod flac;
 mod h264;

src/types.rs

@@ -351,9 +351,67 @@ impl From<usize> for Zeroed {
     }
 }
 
+/// A 16-byte code used to identify UUID boxes.
+#[derive(Copy, Clone, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct ExtendedType([u8; 16]);
+
+impl ExtendedType {
+    pub const fn new(value: &[u8; 16]) -> Self {
+        ExtendedType(*value)
+    }
+}
+
+impl From<&[u8; 16]> for ExtendedType {
+    fn from(val: &[u8; 16]) -> ExtendedType {
+        ExtendedType(*val)
+    }
+}
+
+impl From<[u8; 16]> for ExtendedType {
+    fn from(val: [u8; 16]) -> ExtendedType {
+        ExtendedType(val)
+    }
+}
+
+impl From<ExtendedType> for [u8; 16] {
+    fn from(et: ExtendedType) -> [u8; 16] {
+        et.0
+    }
+}
+
+impl Encode for ExtendedType {
+    fn encode<B: BufMut>(&self, buf: &mut B) -> Result<()> {
+        self.0.encode(buf)
+    }
+}
+impl Decode for ExtendedType {
+    fn decode<B: Buf>(buf: &mut B) -> Result<Self> {
+        Ok(ExtendedType(<[u8; 16]>::decode(buf)?))
+    }
+}
+
+impl fmt::Display for ExtendedType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:02x?}", self.0)
+    }
+}
+
+impl fmt::Debug for ExtendedType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:02x?}", self.0)
+    }
+}
+
+impl AsRef<[u8; 16]> for ExtendedType {
+    fn as_ref(&self) -> &[u8; 16] {
+        &self.0
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use crate::{Compressor, Decode as _, Encode as _};
+    use crate::{Compressor, Decode as _, Encode as _, ExtendedType};
 
     #[test]
     fn check_compressor_encode_minimal() {
@@ -416,4 +474,23 @@ mod tests {
         let result = compressor.encode(&mut buf);
         assert!(result.is_err());
     }
+
+    #[test]
+    fn test_extended_type_creation_and_conversion() {
+        let bytes: [u8; 16] = [
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+            0x0e, 0x0f,
+        ];
+
+        let et_new = ExtendedType::new(&bytes);
+        let et_from = ExtendedType::from(bytes);
+        let et_ref_from = ExtendedType::from(&bytes);
+
+        assert_eq!(et_new, et_from);
+        assert_eq!(et_from, et_ref_from);
+
+        let output = <[u8; 16]>::from(et_new);
+
+        assert_eq!(bytes, output);
+    }
 }

src/uuid.rs

@@ -0,0 +1,138 @@
+use crate::*;
+
+pub trait UuidAtom: Sized {
+    const EXTENDED_TYPE: ExtendedType;
+
+    fn decode_uuid_body<B: Buf>(buf: &mut B) -> Result<Self>;
+    fn encode_uuid_body<B: BufMut>(&self, buf: &mut B) -> Result<()>;
+}
+
+pub(crate) trait UuidAtomExt: Sized {
+    const EXTENDED_TYPE_EXT: ExtendedType;
+    type Ext: Ext;
+
+    fn decode_uuid_body_ext<B: Buf>(buf: &mut B, ext: Self::Ext) -> Result<Self>;
+    fn encode_uuid_body_ext<B: BufMut>(&self, buf: &mut B) -> Result<Self::Ext>;
+}
+
+impl<T: UuidAtomExt> UuidAtom for T {
+    const EXTENDED_TYPE: ExtendedType = Self::EXTENDED_TYPE_EXT;
+
+    // logic borrowed from ./atom_ext.rs
+    fn decode_uuid_body<B: Buf>(buf: &mut B) -> Result<Self> {
+        let ext = Ext::decode(u32::decode(buf)?)?;
+        UuidAtomExt::decode_uuid_body_ext(buf, ext)
+    }
+
+    fn encode_uuid_body<B: BufMut>(&self, buf: &mut B) -> Result<()> {
+        // Here's the magic, we reserve space for the version/flags first
+        let start = buf.len();
+        0u32.encode(buf)?;
+
+        // That way we can return them as part of the trait, avoiding boilerplate
+        let ext = self.encode_uuid_body_ext(buf)?;
+
+        // Go back and update the version/flags
+        let header = ext.encode()?;
+        buf.set_slice(start, &header.to_be_bytes());
+
+        Ok(())
+    }
+}
+
+// This can be encapuslated in a macro to allow new uuid boxes to be made
+// without adding new match arms. In the same way as in ./any.rs
+#[derive(Clone, Eq, PartialEq, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[non_exhaustive]
+pub enum Uuid {
+    C2pa(C2pa),
+    Unknown(ExtendedType, Vec<u8>),
+}
+
+impl Atom for Uuid {
+    const KIND: FourCC = FourCC::new(b"uuid");
+
+    fn decode_body<B: Buf>(buf: &mut B) -> Result<Self> {
+        let et = ExtendedType::decode(buf)?;
+
+        match et {
+            C2pa::EXTENDED_TYPE => Ok(Uuid::C2pa(C2pa::decode_uuid_body(buf)?)),
+            _ => {
+                let payload = Vec::<u8>::decode(buf)?;
+                Ok(Uuid::Unknown(et, payload))
+            }
+        }
+    }
+
+    fn encode_body<B: BufMut>(&self, buf: &mut B) -> Result<()> {
+        match self {
+            Uuid::C2pa(c2pa) => {
+                C2pa::EXTENDED_TYPE.encode(buf)?;
+                c2pa.encode_uuid_body(buf)?;
+            }
+            Uuid::Unknown(et, payload) => {
+                et.encode(buf)?;
+                payload.encode(buf)?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_c2pa_round_trip() -> Result<()> {
+        let original = Uuid::C2pa(C2pa {
+            box_purpose: "urn:uuid:...".to_string(),
+            data: vec![1, 2, 3, 4],
+        });
+
+        // 1. Encode into a byte buffer
+        let mut buf = Vec::new();
+        original.encode_body(&mut buf)?;
+
+        // 2. Decode back from the buffer
+        let mut cursor = &buf[..];
+        let decoded = Uuid::decode_body(&mut cursor)?;
+
+        // 3. Assert equality
+        assert_eq!(original, decoded, "They werent equal");
+        Ok(())
+    }
+
+    #[test]
+    fn test_c2pa_uuid_golden_vector() -> Result<()> {
+        let mut bytes = Vec::new();
+
+        // 1. C2pa Extended Type bytes (16 bytes from the specification)
+        bytes.extend_from_slice(&[
+            0xD8, 0xFE, 0xC3, 0xD6, 0x1B, 0x0E, 0x48, 0x3C, 0x92, 0x97, 0x58, 0x28, 0x87, 0x7E,
+            0xC4, 0x81,
+        ]);
+
+        // 2. FullBox version and flags (version = 0, flags = 0 -> 4 bytes of 0x00)
+        bytes.extend_from_slice(&[0x00, 0x00, 0x00, 0x00]);
+
+        // 3. box_purpose string bytes (null-terminated UTF-8 string)
+        bytes.extend_from_slice(b"urn:uuid:test\0");
+
+        // 4. Data payload bytes (0xDEADBEEF)
+        bytes.extend_from_slice(&[0xDE, 0xAD, 0xBE, 0xEF]);
+
+        let mut cursor = &bytes[..];
+        let decoded = Uuid::decode_body(&mut cursor)?;
+
+        let expected = Uuid::C2pa(C2pa {
+            box_purpose: "urn:uuid:test".to_string(),
+            data: vec![0xDE, 0xAD, 0xBE, 0xEF],
+        });
+
+        assert_eq!(decoded, expected);
+        Ok(())
+    }
+}

src/uuid_boxes/c2pa.rs

@@ -0,0 +1,59 @@
+use crate::*;
+
+/// Represents the C2PA box/atom.
+/// https://spec.c2pa.org/specifications/specifications/2.4/specs/C2PA_Specification.html#uuid_box
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct C2pa {
+    pub box_purpose: String,
+    pub data: Vec<u8>,
+}
+
+impl UuidAtomExt for C2pa {
+    const EXTENDED_TYPE_EXT: ExtendedType = ExtendedType::new(&[
+        0xD8, 0xFE, 0xC3, 0xD6, 0x1B, 0x0E, 0x48, 0x3C, 0x92, 0x97, 0x58, 0x28, 0x87, 0x7E, 0xC4,
+        0x81,
+    ]);
+
+    // The ext version is restricted to 0, and flags 0 for C2PA, so they are ignored
+    type Ext = ();
+
+    fn decode_uuid_body_ext<B: Buf>(buf: &mut B, _ext: ()) -> Result<Self> {
+        Ok(C2pa {
+            box_purpose: String::decode(buf)?,
+            data: Vec::decode(buf)?,
+        })
+    }
+
+    fn encode_uuid_body_ext<B: BufMut>(&self, buf: &mut B) -> Result<()> {
+        self.box_purpose.as_str().encode(buf)?;
+        self.data.encode(buf)?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Testing the encoding and decoding logic
+    #[test]
+    fn test_round_trip() -> Result<()> {
+        let input = C2pa {
+            box_purpose: String::from("uuid:test"),
+            data: vec![0xDE, 0xAD, 0xBE, 0xEF],
+        };
+
+        let mut buf = Vec::new();
+
+        C2pa::encode_uuid_body_ext(&input, &mut buf)?;
+
+        let mut cursor = &buf[..];
+
+        let output = C2pa::decode_uuid_body_ext(&mut cursor, ())?;
+
+        assert_eq!(input, output);
+
+        Ok(())
+    }
+}

src/uuid_boxes/mod.rs

@@ -0,0 +1,2 @@
+mod c2pa;
+pub use c2pa::*;