fix: update transmuxer

Author: lennartkloock

Cargo.lock

@@ -238,7 +238,7 @@ impl Serialize for StringCow<'_> {
 }
 
 /// A 24-bit signed integer in big-endian byte order.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Default)]
 pub struct I24Be(pub i32);
 
 impl<'a> Deserialize<'a> for I24Be {
@@ -271,7 +271,7 @@ impl Deref for I24Be {
 }
 
 /// A 48-bit signed integer in big-endian byte order.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Default)]
 pub struct I48Be(pub i64);
 
 impl<'a> Deserialize<'a> for I48Be {
@@ -304,7 +304,7 @@ impl Deref for I48Be {
 }
 
 /// A 24-bit unsigned integer in big-endian byte order.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Default)]
 pub struct U24Be(pub u32);
 
 impl<'a> Deserialize<'a> for U24Be {
@@ -337,7 +337,7 @@ impl Deref for U24Be {
 }
 
 /// A 48-bit unsigned integer in big-endian byte order.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Default)]
 pub struct U48Be(pub u64);
 
 impl<'a> Deserialize<'a> for U48Be {

crates/bytes-util/src/zero_copy/serde.rs

@@ -19,6 +19,7 @@ byteorder = "1.5.0"
 bytes = "1.10.1"
 bitflags = "2.9.0"
 base64 = "0.22.1"
+fixed = "1.29.0"
 isobmff-derive = { path = "./derive", version = "0.1.0" }
 nutype-enum = { path = "../nutype_enum", version = "0.1.4" }
 scuffle-bytes-util = { path = "../bytes-util", version = "0.2.0" }

crates/isobmff/Cargo.toml

@@ -1,5 +1,7 @@
 use std::io;
 
+use fixed::types::extra::{U8, U16};
+use fixed::{FixedI16, FixedU32};
 use scuffle_bytes_util::zero_copy::{Deserialize, DeserializeSeed, Serialize, SerializeSeed};
 use scuffle_bytes_util::{BitWriter, BytesCow};
 
@@ -10,14 +12,50 @@ use crate::{BoxHeader, FullBoxHeader, IsoBox, IsoSized};
 /// Sound media header
 ///
 /// ISO/IEC 14496-12 - 12.2.2
-#[derive(IsoBox, Debug)]
-#[iso_box(box_type = b"smhd", crate_path = crate)]
+#[derive(IsoBox, Debug, Default)]
+#[iso_box(box_type = b"smhd", skip_impl(deserialize_seed, serialize, sized), crate_path = crate)]
 pub struct SoundMediaHeaderBox {
     pub full_header: FullBoxHeader,
-    pub balance: i16,
+    pub balance: FixedI16<U8>,
     pub reserved: u16,
 }
 
+impl<'a> DeserializeSeed<'a, BoxHeader> for SoundMediaHeaderBox {
+    fn deserialize_seed<R>(mut reader: R, _seed: BoxHeader) -> io::Result<Self>
+    where
+        R: scuffle_bytes_util::zero_copy::ZeroCopyReader<'a>,
+    {
+        let full_header = FullBoxHeader::deserialize(&mut reader)?;
+        let balance = FixedI16::from_bits(i16::deserialize(&mut reader)?);
+        let reserved = u16::deserialize(&mut reader)?;
+
+        Ok(Self {
+            full_header,
+            balance,
+            reserved,
+        })
+    }
+}
+
+impl Serialize for SoundMediaHeaderBox {
+    fn serialize<W>(&self, mut writer: W) -> io::Result<()>
+    where
+        W: std::io::Write,
+    {
+        self.serialize_box_header(&mut writer)?;
+        self.full_header.serialize(&mut writer)?;
+        self.balance.to_bits().serialize(&mut writer)?;
+        self.reserved.serialize(&mut writer)?;
+        Ok(())
+    }
+}
+
+impl IsoSized for SoundMediaHeaderBox {
+    fn size(&self) -> usize {
+        Self::add_header_size(self.full_header.size() + 2 + 2)
+    }
+}
+
 /// Audio sample entry
 ///
 /// ISO/IEC 14496-12 - 12.2.3
@@ -41,11 +79,11 @@ pub struct AudioSampleEntry {
     pub samplesize: u16,
     pub pre_defined: u16,
     pub reserved2: u16,
-    pub samplerate: u32,
+    pub samplerate: FixedU32<U16>,
 }
 
 impl AudioSampleEntry {
-    pub fn new(sample_entry: SampleEntry, channelcount: u16, samplesize: u16, samplerate: u32) -> Self {
+    pub fn new(sample_entry: SampleEntry, channelcount: u16, samplesize: u16, samplerate: FixedU32<U16>) -> Self {
         Self {
             sample_entry,
             reserved1: 0,
@@ -69,7 +107,7 @@ impl<'a> Deserialize<'a> for AudioSampleEntry {
         let samplesize = u16::deserialize(&mut reader)?;
         let pre_defined = u16::deserialize(&mut reader)?;
         let reserved2 = u16::deserialize(&mut reader)?;
-        let samplerate = u32::deserialize(&mut reader)?;
+        let samplerate = FixedU32::from_bits(u32::deserialize(&mut reader)?);
 
         Ok(Self {
             sample_entry,
@@ -94,7 +132,7 @@ impl Serialize for AudioSampleEntry {
         self.samplesize.serialize(&mut writer)?;
         self.pre_defined.serialize(&mut writer)?;
         self.reserved2.serialize(&mut writer)?;
-        self.samplerate.serialize(&mut writer)?;
+        self.samplerate.to_bits().serialize(&mut writer)?;
         Ok(())
     }
 }
@@ -142,7 +180,7 @@ pub struct AudioSampleEntryV1 {
     pub samplesize: u16,
     pub pre_defined: u16,
     pub reserved2: u16,
-    pub samplerate: u32,
+    pub samplerate: FixedU32<U16>,
 }
 
 impl<'a> Deserialize<'a> for AudioSampleEntryV1 {
@@ -157,7 +195,7 @@ impl<'a> Deserialize<'a> for AudioSampleEntryV1 {
         let samplesize = u16::deserialize(&mut reader)?;
         let pre_defined = u16::deserialize(&mut reader)?;
         let reserved2 = u16::deserialize(&mut reader)?;
-        let samplerate = u32::deserialize(&mut reader)?;
+        let samplerate = FixedU32::from_bits(u32::deserialize(&mut reader)?);
 
         Ok(Self {
             sample_entry,
@@ -184,7 +222,7 @@ impl Serialize for AudioSampleEntryV1 {
         self.samplesize.serialize(&mut writer)?;
         self.pre_defined.serialize(&mut writer)?;
         self.reserved2.serialize(&mut writer)?;
-        self.samplerate.serialize(&mut writer)?;
+        self.samplerate.to_bits().serialize(&mut writer)?;
         Ok(())
     }
 }

crates/isobmff/src/boxes/audio_media.rs

@@ -16,6 +16,12 @@ pub struct MediaDataBox<'a> {
     pub data: BytesCow<'a>,
 }
 
+impl<'a> MediaDataBox<'a> {
+    pub fn new(data: BytesCow<'a>) -> Self {
+        Self { data }
+    }
+}
+
 impl Debug for MediaDataBox<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("MediaDataBox").field("data.len", &self.data.len()).finish()

crates/isobmff/src/boxes/general.rs

@@ -1,5 +1,8 @@
 //! Movie structure boxes defined in ISO/IEC 14496-12 - 8.2
 
+use fixed::traits::ToFixed;
+use fixed::types::extra::{U8, U16};
+use fixed::{FixedI16, FixedI32};
 use scuffle_bytes_util::zero_copy::{Deserialize, DeserializeSeed, Serialize};
 
 use super::{MetaBox, MovieExtendsBox, TrackBox, UserDataBox};
@@ -36,15 +39,34 @@ pub struct MovieHeaderBox {
     pub modification_time: u64,
     pub timescale: u32,
     pub duration: u64,
-    pub rate: i32,
-    pub volume: i16,
+    pub rate: FixedI32<U16>,
+    pub volume: FixedI16<U8>,
     pub reserved1: u16,
     pub reserved2: u64,
     pub matrix: [i32; 9],
     pub pre_defined: [u32; 6],
     pub next_track_id: u32,
 }
 
+impl MovieHeaderBox {
+    pub fn new(creation_time: u64, modification_time: u64, timescale: u32, duration: u64, next_track_id: u32) -> Self {
+        Self {
+            full_header: FullBoxHeader::default(),
+            creation_time,
+            modification_time,
+            timescale,
+            duration,
+            rate: 1.to_fixed(),
+            volume: 1.to_fixed(),
+            reserved1: 0,
+            reserved2: 0,
+            matrix: [0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000],
+            pre_defined: [0; 6],
+            next_track_id,
+        }
+    }
+}
+
 impl<'a> DeserializeSeed<'a, BoxHeader> for MovieHeaderBox {
     fn deserialize_seed<R>(mut reader: R, _seed: BoxHeader) -> std::io::Result<Self>
     where
@@ -69,8 +91,8 @@ impl<'a> DeserializeSeed<'a, BoxHeader> for MovieHeaderBox {
             u32::deserialize(&mut reader)? as u64
         };
 
-        let rate = i32::deserialize(&mut reader)?;
-        let volume = i16::deserialize(&mut reader)?;
+        let rate = FixedI32::from_bits(i32::deserialize(&mut reader)?);
+        let volume = FixedI16::from_bits(i16::deserialize(&mut reader)?);
 
         let reserved1 = u16::deserialize(&mut reader)?;
         let reserved2 = u64::deserialize(&mut reader)?;
@@ -124,8 +146,8 @@ impl Serialize for MovieHeaderBox {
             (self.duration as u32).serialize(&mut writer)?;
         }
 
-        self.rate.serialize(&mut writer)?;
-        self.volume.serialize(&mut writer)?;
+        self.rate.to_bits().serialize(&mut writer)?;
+        self.volume.to_bits().serialize(&mut writer)?;
         self.reserved1.serialize(&mut writer)?;
         self.reserved2.serialize(&mut writer)?;
         self.matrix.serialize(&mut writer)?;