mp4ameta 0.13.0

A library for reading and writing iTunes style MPEG-4 audio metadata.
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

use super::*;

pub const HEADER_SIZE_V0: usize = 100;
pub const HEADER_SIZE_V1: usize = 112;
const BUF_SIZE_V0: usize = HEADER_SIZE_V0 - 4;
const BUF_SIZE_V1: usize = HEADER_SIZE_V1 - 4;

const_assert!(std::mem::size_of::<MvhdBufV0>() == BUF_SIZE_V0);
const_assert!(std::mem::size_of::<MvhdBufV1>() == BUF_SIZE_V1);

#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Mvhd {
    pub version: u8,
    pub flags: [u8; 3],
    pub timescale: u32,
    pub duration: u64,
}

#[derive(Default)]
#[repr(C)]
struct MvhdBufV0 {
    creation_time: [u8; 4],
    modification_time: [u8; 4],
    timescale: [u8; 4],
    duration: [u8; 4],
    preferred_rate: [u8; 4],
    preferred_volume: [u8; 2],
    reserved: [u8; 10],
    matrix: [[[u8; 4]; 3]; 3],
    preview_time: [u8; 4],
    preview_duration: [u8; 4],
    poster_time: [u8; 4],
    selection_time: [u8; 4],
    selection_duration: [u8; 4],
    current_time: [u8; 4],
    next_track_id: [u8; 4],
}

impl MvhdBufV0 {
    fn bytes_mut(&mut self) -> &mut [u8; BUF_SIZE_V0] {
        // SAFETY: alignment and size match because all fields are byte arrays
        unsafe { std::mem::transmute(self) }
    }
}

#[derive(Default)]
#[repr(C)]
struct MvhdBufV1 {
    creation_time: [u8; 8],
    modification_time: [u8; 8],
    timescale: [u8; 4],
    duration: [u8; 8],
    preferred_rate: [u8; 4],
    preferred_volume: [u8; 2],
    reserved: [u8; 10],
    matrix: [[[u8; 4]; 3]; 3],
    preview_time: [u8; 4],
    preview_duration: [u8; 4],
    poster_time: [u8; 4],
    selection_time: [u8; 4],
    selection_duration: [u8; 4],
    current_time: [u8; 4],
    next_track_id: [u8; 4],
}

impl MvhdBufV1 {
    fn bytes_mut(&mut self) -> &mut [u8; BUF_SIZE_V1] {
        // SAFETY: alignment and size match because all fields are byte arrays
        unsafe { std::mem::transmute(self) }
    }
}

impl Atom for Mvhd {
    const FOURCC: Fourcc = MOVIE_HEADER;
}

impl ParseAtom for Mvhd {
    fn parse_atom(
        reader: &mut (impl Read + Seek),
        _cfg: &ParseConfig<'_>,
        size: Size,
    ) -> crate::Result<Self> {
        let mut mvhd = Self::default();

        let (version, flags) = head::parse_full(reader)?;
        mvhd.version = version;
        mvhd.flags = flags;

        match version {
            0 => {
                expect_size("Movie header (mvhd) version 0", size, HEADER_SIZE_V0 as u64)?;

                let mut buf = MvhdBufV0::default();
                reader.read_exact(buf.bytes_mut())?;
                mvhd.timescale = u32::from_be_bytes(buf.timescale);
                mvhd.duration = u32::from_be_bytes(buf.duration) as u64;
            }
            1 => {
                expect_size("Movie header (mvhd) version 1", size, HEADER_SIZE_V1 as u64)?;

                let mut buf = MvhdBufV1::default();
                reader.read_exact(buf.bytes_mut())?;
                mvhd.timescale = u32::from_be_bytes(buf.timescale);
                mvhd.duration = u64::from_be_bytes(buf.duration);
            }
            _ => {
                return unknown_version("movie header (mvhd)", version);
            }
        }

        Ok(mvhd)
    }
}

impl AtomSize for Mvhd {
    fn size(&self) -> Size {
        match self.version {
            0 => Size::from(HEADER_SIZE_V0 as u64),
            1 => Size::from(HEADER_SIZE_V1 as u64),
            _ => Size::from(0),
        }
    }
}