feat: add useful functions

Author: lennartkloock

crates/av1/src/boxes.rs

@@ -32,3 +32,10 @@ pub struct AV1CodecConfigurationBox<'a> {
     /// The AV1 codec configuration record.
     pub av1_config: AV1CodecConfigurationRecord<'a>,
 }
+
+impl<'a> AV1CodecConfigurationBox<'a> {
+    /// Creates a new AV1 codec configuration box.
+    pub fn new(av1_config: AV1CodecConfigurationRecord<'a>) -> Self {
+        Self { av1_config }
+    }
+}

crates/bytes-util/src/cow/bytes/mod.rs

@@ -98,6 +98,40 @@ impl<'a> BytesCow<'a> {
             Self::Bytes(bytes) => bytes.is_empty(),
         }
     }
+
+    /// Pads the bytes to a [`u64`].
+    ///
+    /// The bytes are expected to be in big-endian order.
+    ///
+    /// # Panics
+    ///
+    /// The caller must ensure that the length of the bytes is less than or equal to 8,
+    /// otherwise this function will panic.
+    pub fn pad_to_u64_be(&self) -> u64 {
+        assert!(self.len() <= 8);
+
+        // We copy the bytes into an 8 byte array and convert it to a u64
+        let mut buf = [0u8; 8];
+        buf[4 - self.len()..].copy_from_slice(self.as_bytes());
+        u64::from_be_bytes(buf)
+    }
+
+    /// Pads the bytes to a [`u32`].
+    ///
+    /// The bytes are expected to be in big-endian order.
+    ///
+    /// # Panics
+    ///
+    /// The caller must ensure that the length of the bytes is less than or equal to 4,
+    /// otherwise this function will panic.
+    pub fn pad_to_u32_be(&self) -> u32 {
+        assert!(self.len() <= 4);
+
+        // We copy the bytes into a 4 byte array and convert it to a u32
+        let mut buf = [0u8; 4];
+        buf[4 - self.len()..].copy_from_slice(self.as_bytes());
+        u32::from_be_bytes(buf)
+    }
 }
 
 impl<T> PartialEq<T> for BytesCow<'_>

crates/h264/src/boxes.rs

@@ -17,6 +17,13 @@ pub struct AVCConfigurationBox<'a> {
     pub avc_config: AVCDecoderConfigurationRecord<'a>,
 }
 
+impl<'a> AVCConfigurationBox<'a> {
+    /// Creates a new AVC configuration box.
+    pub fn new(avc_config: AVCDecoderConfigurationRecord<'a>) -> Self {
+        Self { avc_config }
+    }
+}
+
 // This doesn't make sense to me, the following 4 box types (avc1 - avc4) are all the same
 
 /// AVC sample entry

crates/h265/src/boxes.rs

@@ -17,6 +17,13 @@ pub struct HEVCConfigurationBox<'a> {
     pub hevc_config: HEVCDecoderConfigurationRecord<'a>,
 }
 
+impl<'a> HEVCConfigurationBox<'a> {
+    /// Creates a new HEVC configuration box.
+    pub fn new(hevc_config: HEVCDecoderConfigurationRecord<'a>) -> Self {
+        Self { hevc_config }
+    }
+}
+
 /// HEVC Sample Entry
 ///
 /// ISO/IEC 14496-15 - 8.4.1

crates/isobmff/src/boxes/audio_media.rs

@@ -44,6 +44,20 @@ pub struct AudioSampleEntry {
     pub samplerate: u32,
 }
 
+impl AudioSampleEntry {
+    pub fn new(sample_entry: SampleEntry, channelcount: u16, samplesize: u16, samplerate: u32) -> Self {
+        Self {
+            sample_entry,
+            reserved1: 0,
+            channelcount,
+            samplesize,
+            pre_defined: 0,
+            reserved2: 0,
+            samplerate,
+        }
+    }
+}
+
 impl<'a> Deserialize<'a> for AudioSampleEntry {
     fn deserialize<R>(mut reader: R) -> std::io::Result<Self>
     where

crates/isobmff/src/boxes/metadata.rs

@@ -7,7 +7,6 @@ use super::{
     Brand, DataInformationBox, ExtendedTypeBox, FDItemInformationBox, HandlerBox, ProtectionSchemeInfoBox,
     ScrambleSchemeInfoBox,
 };
-use crate::utils::pad_cow_to_u64;
 use crate::{BoxHeader, FullBoxHeader, IsoBox, IsoSized, UnknownBox, Utf8String};
 
 /// Meta box
@@ -142,17 +141,17 @@ impl<'a> DeserializeSeed<'a, BoxHeader> for ItemLocationBox {
             };
 
             let data_reference_index = u16::deserialize(&mut reader)?;
-            let base_offset = pad_cow_to_u64(reader.try_read(base_offset_size as usize)?);
+            let base_offset = reader.try_read(base_offset_size as usize)?.pad_to_u64_be();
             let extent_count = u16::deserialize(&mut reader)?;
             let mut extents = Vec::with_capacity(extent_count as usize);
             for _ in 0..extent_count {
                 let item_reference_index = if (full_header.version == 1 || full_header.version == 2) && index_size > 0 {
-                    Some(pad_cow_to_u64(reader.try_read(index_size as usize)?))
+                    Some(reader.try_read(index_size as usize)?.pad_to_u64_be())
                 } else {
                     None
                 };
-                let extent_offset = pad_cow_to_u64(reader.try_read(offset_size as usize)?);
-                let extent_length = pad_cow_to_u64(reader.try_read(length_size as usize)?);
+                let extent_offset = reader.try_read(offset_size as usize)?.pad_to_u64_be();
+                let extent_length = reader.try_read(length_size as usize)?.pad_to_u64_be();
 
                 extents.push(ItemLocationBoxExtent {
                     item_reference_index,

crates/isobmff/src/boxes/movie_fragments.rs

@@ -7,7 +7,6 @@ use super::{
     CompositionToDecodeBox, MetaBox, SampleAuxiliaryInformationOffsetsBox, SampleAuxiliaryInformationSizesBox,
     SampleGroupDescriptionBox, SampleToGroupBox, SubSampleInformationBox, UserDataBox,
 };
-use crate::utils::pad_cow_to_u32;
 use crate::{BoxHeader, FullBoxHeader, IsoBox, IsoSized, UnknownBox};
 
 /// Movie extends box
@@ -667,9 +666,9 @@ impl<'a> DeserializeSeed<'a, BoxHeader> for TrackFragmentRandomAccessBox {
             };
 
             // The length of the following fields is bound to 3 bytes because the length fields are all 2 bits
-            let traf_number = pad_cow_to_u32(reader.try_read(length_size_of_traf_num as usize + 1)?);
-            let trun_number = pad_cow_to_u32(reader.try_read(length_size_of_trun_num as usize + 1)?);
-            let sample_number = pad_cow_to_u32(reader.try_read(length_size_of_sample_num as usize + 1)?);
+            let traf_number = reader.try_read(length_size_of_traf_num as usize + 1)?.pad_to_u32_be();
+            let trun_number = reader.try_read(length_size_of_trun_num as usize + 1)?.pad_to_u32_be();
+            let sample_number = reader.try_read(length_size_of_sample_num as usize + 1)?.pad_to_u32_be();
 
             entries.push(TrackFragmentRandomAccessBoxEntry {
                 time,

crates/isobmff/src/boxes/sample_table.rs

@@ -68,18 +68,31 @@ pub struct SampleTableBox<'a> {
 /// - [`btrt`](BitRateBox)
 #[derive(Debug)]
 pub struct SampleEntry {
+    pub reserved: [u8; 6],
     pub data_reference_index: u16,
 }
 
+impl Default for SampleEntry {
+    fn default() -> Self {
+        Self {
+            reserved: [0; 6],
+            data_reference_index: 1,
+        }
+    }
+}
+
 impl<'a> Deserialize<'a> for SampleEntry {
     fn deserialize<R>(mut reader: R) -> io::Result<Self>
     where
         R: ZeroCopyReader<'a>,
     {
-        <[u8; 6]>::deserialize(&mut reader)?; // reserved
+        let reserved = <[u8; 6]>::deserialize(&mut reader)?;
         let data_reference_index = u16::deserialize(&mut reader)?;
 
-        Ok(Self { data_reference_index })
+        Ok(Self {
+            reserved,
+            data_reference_index,
+        })
     }
 }
 
@@ -88,15 +101,15 @@ impl Serialize for SampleEntry {
     where
         W: std::io::Write,
     {
-        [0u8; 6].serialize(&mut writer)?; // reserved
+        self.reserved.serialize(&mut writer)?;
         self.data_reference_index.serialize(&mut writer)?;
         Ok(())
     }
 }
 
 impl IsoSized for SampleEntry {
     fn size(&self) -> usize {
-        6 + self.data_reference_index.size()
+        self.reserved.size() + self.data_reference_index.size()
     }
 }
 

crates/isobmff/src/boxes/video_media.rs

@@ -43,11 +43,31 @@ pub struct VisualSampleEntry {
     pub vert_resolution: u32,
     pub reserved2: u32,
     pub frame_count: u16,
-    pub compressor_name: [char; 32],
+    pub compressor_name: [u8; 32],
     pub depth: u16,
     pub pre_defined4: i16,
 }
 
+impl VisualSampleEntry {
+    pub fn new(sample_entry: SampleEntry, width: u16, height: u16, compressor_name: [u8; 32]) -> Self {
+        Self {
+            sample_entry,
+            pre_defined: 0,
+            reserved1: 0,
+            pre_defined2: [0; 3],
+            width,
+            height,
+            horiz_resolution: 0x00480000,
+            vert_resolution: 0x00480000,
+            reserved2: 0,
+            frame_count: 1,
+            compressor_name,
+            depth: 0x0018,
+            pre_defined4: -1,
+        }
+    }
+}
+
 impl<'a> Deserialize<'a> for VisualSampleEntry {
     fn deserialize<R>(mut reader: R) -> std::io::Result<Self>
     where
@@ -63,7 +83,7 @@ impl<'a> Deserialize<'a> for VisualSampleEntry {
         let vert_resolution = u32::deserialize(&mut reader)?;
         let reserved2 = u32::deserialize(&mut reader)?;
         let frame_count = u16::deserialize(&mut reader)?;
-        let compressor_name = <[char; 32]>::deserialize(&mut reader)?;
+        let compressor_name = <[u8; 32]>::deserialize(&mut reader)?;
         let depth = u16::deserialize(&mut reader)?;
         let pre_defined4 = i16::deserialize(&mut reader)?;
 
@@ -151,6 +171,15 @@ pub struct PixelAspectRatioBox {
     pub v_spacing: u32,
 }
 
+impl Default for PixelAspectRatioBox {
+    fn default() -> Self {
+        Self {
+            h_spacing: 1,
+            v_spacing: 1,
+        }
+    }
+}
+
 /// Colour information
 ///
 /// ISO/IEC 14496-12 - 12.1.5

crates/isobmff/src/boxes/volemetric_visual_media.rs

@@ -23,7 +23,7 @@ pub struct VolumetricVisualMediaHeaderBox {
 #[derive(Debug)]
 pub struct VolumetricVisualSampleEntry {
     pub sample_entry: SampleEntry,
-    pub compressorname: [char; 32],
+    pub compressorname: [u8; 32],
 }
 
 impl<'a> Deserialize<'a> for VolumetricVisualSampleEntry {
@@ -32,7 +32,7 @@ impl<'a> Deserialize<'a> for VolumetricVisualSampleEntry {
         R: scuffle_bytes_util::zero_copy::ZeroCopyReader<'a>,
     {
         let sample_entry = SampleEntry::deserialize(&mut reader)?;
-        let compressorname = <[char; 32]>::deserialize(&mut reader)?;
+        let compressorname = <[u8; 32]>::deserialize(&mut reader)?;
 
         Ok(Self {
             sample_entry,