mp4san 0.5.3

An MP4 file sanitizer.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Unstable API for parsing individual MP4 box types.

mod array;
mod co64;
pub mod error;
mod ftyp;
mod header;
mod integers;
mod mdia;
mod minf;
mod moov;
mod mp4box;
mod stbl;
mod stco;
mod trak;
mod value;

pub use array::{ArrayEntry, ArrayEntryMut, BoundedArray, UnboundedArray};
pub use co64::Co64Box;
pub use error::ParseError;
pub use ftyp::FtypBox;
pub use header::{box_type, fourcc, BoxHeader, BoxSize, BoxType, BoxUuid, ConstFullBoxHeader, FullBoxHeader};
pub use integers::Mp4Prim;
pub use mdia::MdiaBox;
pub use minf::MinfBox;
pub use moov::MoovBox;
pub use mp4box::{AnyMp4Box, BoxData, Boxes, BoxesValidator, Mp4Box, ParseBox, ParsedBox};
pub use stbl::{StblBox, StblCoMut};
pub use stco::StcoBox;
pub use trak::TrakBox;
pub use value::{Mp4Value, Mp4ValueReaderExt, Mp4ValueWriterExt};

pub use mediasan_common::parse::FourCC;
pub use mp4san_derive::{ParseBox, ParsedBox};

#[cfg(test)]
mod test {
    use bytes::BytesMut;

    use super::*;

    #[derive(Clone, Debug, PartialEq, ParseBox, ParsedBox)]
    #[box_type = b"\xffX0\x00"]
    pub struct NotARealBox {
        pub bar_ax: u64,
        pub foo_by: u32,
    }

    #[derive(Clone, Debug, PartialEq, ParseBox, ParsedBox)]
    #[box_type = 4283969538] // 0xff583002
    pub struct AnotherFakeBox;

    #[derive(Clone, Debug, PartialEq, ParseBox, ParsedBox)]
    #[box_type = "c12fdd3f-1e93-464c-baee-7c4480628f58"]
    pub struct FakeUuidTypeBox;

    #[derive(Clone, Debug, PartialEq, ParseBox, ParsedBox)]
    #[box_type = "xa04"]
    pub struct Fifth;

    #[derive(Clone, Debug, ParseBox, ParsedBox)]
    #[box_type = "test"]
    pub struct ArrayBox {
        pub array_32: BoundedArray<u32, i32>,
        pub array_16: BoundedArray<u16, i16>,
        pub unbounded_array: UnboundedArray<u8>,
    }

    #[test]
    fn test_size_simple() {
        let not_a_real = NotARealBox { bar_ax: u64::MAX, foo_by: u32::MAX };
        assert_eq!(
            not_a_real.encoded_len(),
            (<u64 as Mp4Prim>::encoded_len() + <u32 as Mp4Prim>::encoded_len()) as u64
        );
    }

    #[test]
    fn test_size_exttype() {
        assert_eq!(FakeUuidTypeBox.encoded_len(), 0);
    }

    #[test]
    fn test_type_bytes() {
        assert_eq!(
            NotARealBox::box_type(),
            BoxType::FourCC(FourCC { value: *b"\xffX0\x00" })
        );
    }

    #[test]
    fn test_type_compact_int_decimal() {
        assert_eq!(
            AnotherFakeBox::box_type(),
            BoxType::FourCC(FourCC { value: 4283969538u32.to_be_bytes() })
        );
    }

    #[test]
    fn test_type_extended() {
        let expected = BoxType::Uuid(BoxUuid { value: 0xc12fdd3f_1e93_464c_baee_7c4480628f58u128.to_be_bytes() });
        assert_eq!(FakeUuidTypeBox::box_type(), expected);
    }

    #[test]
    fn test_type_compact_str() {
        assert_eq!(Fifth::box_type(), BoxType::FourCC(FourCC { value: *b"xa04" }));
    }

    #[test]
    fn put_buf_empty() {
        let mut buf = vec![];
        FakeUuidTypeBox.put_buf(&mut buf);
        assert_eq!(buf, b"");
    }

    #[test]
    fn put_buf() {
        let mut buf = vec![];
        NotARealBox { bar_ax: 0x0102030405060708, foo_by: 0x090a0b0c }.put_buf(&mut buf);
        assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c");
    }

    #[test]
    fn parse() {
        let mut data = BytesMut::from(&b"\0\0\0\x14\xffX0\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c"[..]);
        let data_len = data.len();
        let header = BoxHeader::parse(&mut data).unwrap();
        assert_eq!(header.box_size(), Some(data_len as u64));
        assert_eq!(
            NotARealBox::parse(&mut data).unwrap(),
            NotARealBox { bar_ax: 0x0102030405060708, foo_by: 0x090a0b0c }
        );
    }
}