Parse unknown metadata and write metadata (#91)

* validate meta box handler type, parse meta with unknown handlers

* parse meta in moov and trak position

* write meta and udta

* fix clippy nit

Author: jessa0

src/mp4box/data.rs

@@ -13,6 +13,39 @@ pub struct DataBox {
     pub data_type: DataType,
 }
 
+impl DataBox {
+    pub fn get_type(&self) -> BoxType {
+        BoxType::DataBox
+    }
+
+    pub fn get_size(&self) -> u64 {
+        let mut size = HEADER_SIZE;
+        size += 4; // data_type
+        size += 4; // reserved
+        size += self.data.len() as u64;
+        size
+    }
+}
+
+impl Mp4Box for DataBox {
+    fn box_type(&self) -> BoxType {
+        self.get_type()
+    }
+
+    fn box_size(&self) -> u64 {
+        self.get_size()
+    }
+
+    fn to_json(&self) -> Result<String> {
+        Ok(serde_json::to_string(&self).unwrap())
+    }
+
+    fn summary(&self) -> Result<String> {
+        let s = format!("type={:?} len={}", self.data_type, self.data.len());
+        Ok(s)
+    }
+}
+
 impl<R: Read + Seek> ReadBox<&mut R> for DataBox {
     fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = box_start(reader)?;
@@ -28,3 +61,58 @@ impl<R: Read + Seek> ReadBox<&mut R> for DataBox {
         Ok(DataBox { data, data_type })
     }
 }
+
+impl<W: Write> WriteBox<&mut W> for DataBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
+        let size = self.box_size();
+        BoxHeader::new(self.box_type(), size).write(writer)?;
+
+        writer.write_u32::<BigEndian>(self.data_type.clone() as u32)?;
+        writer.write_u32::<BigEndian>(0)?; // reserved = 0
+        writer.write_all(&self.data)?;
+
+        Ok(size)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::mp4box::BoxHeader;
+    use std::io::Cursor;
+
+    #[test]
+    fn test_data() {
+        let src_box = DataBox {
+            data_type: DataType::Text,
+            data: b"test_data".to_vec(),
+        };
+        let mut buf = Vec::new();
+        src_box.write_box(&mut buf).unwrap();
+        assert_eq!(buf.len(), src_box.box_size() as usize);
+
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::DataBox);
+        assert_eq!(src_box.box_size(), header.size);
+
+        let dst_box = DataBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
+    }
+
+    #[test]
+    fn test_data_empty() {
+        let src_box = DataBox::default();
+        let mut buf = Vec::new();
+        src_box.write_box(&mut buf).unwrap();
+        assert_eq!(buf.len(), src_box.box_size() as usize);
+
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::DataBox);
+        assert_eq!(src_box.box_size(), header.size);
+
+        let dst_box = DataBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
+    }
+}

src/mp4box/ilst.rs

@@ -13,6 +13,39 @@ pub struct IlstBox {
     pub items: HashMap<MetadataKey, IlstItemBox>,
 }
 
+impl IlstBox {
+    pub fn get_type(&self) -> BoxType {
+        BoxType::IlstBox
+    }
+
+    pub fn get_size(&self) -> u64 {
+        let mut size = HEADER_SIZE;
+        for item in self.items.values() {
+            size += item.get_size();
+        }
+        size
+    }
+}
+
+impl Mp4Box for IlstBox {
+    fn box_type(&self) -> BoxType {
+        self.get_type()
+    }
+
+    fn box_size(&self) -> u64 {
+        self.get_size()
+    }
+
+    fn to_json(&self) -> Result<String> {
+        Ok(serde_json::to_string(&self).unwrap())
+    }
+
+    fn summary(&self) -> Result<String> {
+        let s = format!("item_count={}", self.items.len());
+        Ok(s)
+    }
+}
+
 impl<R: Read + Seek> ReadBox<&mut R> for IlstBox {
     fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = box_start(reader)?;
@@ -54,11 +87,36 @@ impl<R: Read + Seek> ReadBox<&mut R> for IlstBox {
     }
 }
 
+impl<W: Write> WriteBox<&mut W> for IlstBox {
+    fn write_box(&self, writer: &mut W) -> Result<u64> {
+        let size = self.box_size();
+        BoxHeader::new(self.box_type(), size).write(writer)?;
+
+        for (key, value) in &self.items {
+            let name = match key {
+                MetadataKey::Title => BoxType::NameBox,
+                MetadataKey::Year => BoxType::DayBox,
+                MetadataKey::Poster => BoxType::CovrBox,
+                MetadataKey::Summary => BoxType::DescBox,
+            };
+            BoxHeader::new(name, value.get_size()).write(writer)?;
+            value.data.write_box(writer)?;
+        }
+        Ok(size)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Default, Serialize)]
 pub struct IlstItemBox {
     pub data: DataBox,
 }
 
+impl IlstItemBox {
+    fn get_size(&self) -> u64 {
+        HEADER_SIZE + self.data.box_size()
+    }
+}
+
 impl<R: Read + Seek> ReadBox<&mut R> for IlstItemBox {
     fn read_box(reader: &mut R, size: u64) -> Result<Self> {
         let start = box_start(reader)?;
@@ -130,3 +188,56 @@ fn item_to_u32(item: &IlstItemBox) -> Option<u32> {
         _ => None,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::mp4box::BoxHeader;
+    use std::io::Cursor;
+
+    #[test]
+    fn test_ilst() {
+        let src_year = IlstItemBox {
+            data: DataBox {
+                data_type: DataType::Text,
+                data: b"test_year".to_vec(),
+            },
+        };
+        let src_box = IlstBox {
+            items: [
+                (MetadataKey::Title, IlstItemBox::default()),
+                (MetadataKey::Year, src_year),
+                (MetadataKey::Poster, IlstItemBox::default()),
+                (MetadataKey::Summary, IlstItemBox::default()),
+            ]
+            .into(),
+        };
+        let mut buf = Vec::new();
+        src_box.write_box(&mut buf).unwrap();
+        assert_eq!(buf.len(), src_box.box_size() as usize);
+
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::IlstBox);
+        assert_eq!(src_box.box_size(), header.size);
+
+        let dst_box = IlstBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
+    }
+
+    #[test]
+    fn test_ilst_empty() {
+        let src_box = IlstBox::default();
+        let mut buf = Vec::new();
+        src_box.write_box(&mut buf).unwrap();
+        assert_eq!(buf.len(), src_box.box_size() as usize);
+
+        let mut reader = Cursor::new(&buf);
+        let header = BoxHeader::read(&mut reader).unwrap();
+        assert_eq!(header.name, BoxType::IlstBox);
+        assert_eq!(src_box.box_size(), header.size);
+
+        let dst_box = IlstBox::read_box(&mut reader, header.size).unwrap();
+        assert_eq!(src_box, dst_box);
+    }
+}