scuffle_mp4/boxes/types/
hmhd.rs

1use std::io;
2
3use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
4use bytes::Bytes;
5
6use crate::boxes::header::{BoxHeader, FullBoxHeader};
7use crate::boxes::traits::BoxType;
8
9#[derive(Debug, Clone, PartialEq)]
10/// Hint Media Header Box
11/// ISO/IEC 14496-12:2022(E) - 12.4.3
12pub struct Hmhd {
13    pub header: FullBoxHeader,
14    pub max_pdu_size: u16,
15    pub avg_pdu_size: u16,
16    pub max_bitrate: u32,
17    pub avg_bitrate: u32,
18    pub reserved: u32,
19}
20
21impl BoxType for Hmhd {
22    const NAME: [u8; 4] = *b"hmhd";
23
24    fn demux(header: BoxHeader, data: Bytes) -> io::Result<Self> {
25        let mut reader = io::Cursor::new(data);
26
27        let header = FullBoxHeader::demux(header, &mut reader)?;
28
29        let max_pdu_size = reader.read_u16::<BigEndian>()?;
30        let avg_pdu_size = reader.read_u16::<BigEndian>()?;
31        let max_bitrate = reader.read_u32::<BigEndian>()?;
32        let avg_bitrate = reader.read_u32::<BigEndian>()?;
33        let reserved = reader.read_u32::<BigEndian>()?;
34
35        Ok(Self {
36            header,
37            max_pdu_size,
38            avg_pdu_size,
39            max_bitrate,
40            avg_bitrate,
41            reserved,
42        })
43    }
44
45    fn primitive_size(&self) -> u64 {
46        self.header.size()
47        + 2 // max_pdu_size
48        + 2 // avg_pdu_size
49        + 4 // max_bitrate
50        + 4 // avg_bitrate
51        + 4 // reserved
52    }
53
54    fn primitive_mux<T: io::Write>(&self, writer: &mut T) -> io::Result<()> {
55        self.header.mux(writer)?;
56
57        writer.write_u16::<BigEndian>(self.max_pdu_size)?;
58        writer.write_u16::<BigEndian>(self.avg_pdu_size)?;
59        writer.write_u32::<BigEndian>(self.max_bitrate)?;
60        writer.write_u32::<BigEndian>(self.avg_bitrate)?;
61        writer.write_u32::<BigEndian>(self.reserved)?;
62
63        Ok(())
64    }
65
66    fn validate(&self) -> io::Result<()> {
67        if self.header.version != 0 {
68            return Err(io::Error::new(io::ErrorKind::InvalidData, "hmhd version must be 0"));
69        }
70
71        if self.header.flags != 0 {
72            return Err(io::Error::new(io::ErrorKind::InvalidData, "hmhd flags must be 0"));
73        }
74
75        if self.reserved != 0 {
76            return Err(io::Error::new(io::ErrorKind::InvalidData, "hmhd reserved must be 0"));
77        }
78
79        Ok(())
80    }
81}