mp4forge 0.8.0

Rust library and CLI for inspecting, probing, extracting, muxing, and rewriting MP4 structures
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

//! AVS3 sample-entry and decoder-configuration box definitions.

use std::io::Write;

use super::iso14496_12::VisualSampleEntry;
use crate::boxes::BoxRegistry;
use crate::codec::{
    CodecBox, CodecError, FieldHooks, FieldTable, FieldValue, FieldValueError, FieldValueRead,
    FieldValueWrite, ImmutableBox, MutableBox,
};
use crate::{FourCc, codec_field};

fn missing_field(field_name: &'static str) -> FieldValueError {
    FieldValueError::MissingField { field_name }
}

fn unexpected_field(field_name: &'static str, value: FieldValue) -> FieldValueError {
    FieldValueError::UnexpectedType {
        field_name,
        expected: "matching codec field value",
        actual: value.kind_name(),
    }
}

fn invalid_value(field_name: &'static str, reason: &'static str) -> FieldValueError {
    FieldValueError::InvalidValue { field_name, reason }
}

fn u8_from_unsigned(field_name: &'static str, value: u64) -> Result<u8, FieldValueError> {
    u8::try_from(value).map_err(|_| invalid_value(field_name, "value does not fit in u8"))
}

fn u16_from_unsigned(field_name: &'static str, value: u64) -> Result<u16, FieldValueError> {
    u16::try_from(value).map_err(|_| invalid_value(field_name, "value does not fit in u16"))
}

/// AVS3 decoder-configuration box carried by `avs3` sample entries.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Av3c {
    /// Decoder-configuration record version.
    pub configuration_version: u8,
    /// Declared byte length of the sequence header.
    pub sequence_header_length: u16,
    /// Opaque AVS3 sequence-header bytes.
    pub sequence_header: Vec<u8>,
    /// Two-bit library-dependency identifier.
    pub library_dependency_idc: u8,
}

impl FieldHooks for Av3c {
    fn field_length(&self, name: &'static str) -> Option<u32> {
        match name {
            "SequenceHeader" => Some(u32::from(self.sequence_header_length)),
            _ => None,
        }
    }
}

impl ImmutableBox for Av3c {
    fn box_type(&self) -> FourCc {
        FourCc::from_bytes(*b"av3c")
    }
}

impl MutableBox for Av3c {}

impl FieldValueRead for Av3c {
    fn field_value(&self, field_name: &'static str) -> Result<FieldValue, FieldValueError> {
        match field_name {
            "ConfigurationVersion" => {
                Ok(FieldValue::Unsigned(u64::from(self.configuration_version)))
            }
            "SequenceHeaderLength" => {
                Ok(FieldValue::Unsigned(u64::from(self.sequence_header_length)))
            }
            "SequenceHeader" => Ok(FieldValue::Bytes(self.sequence_header.clone())),
            "LibraryDependencyIDC" => {
                Ok(FieldValue::Unsigned(u64::from(self.library_dependency_idc)))
            }
            _ => Err(missing_field(field_name)),
        }
    }
}

impl FieldValueWrite for Av3c {
    fn set_field_value(
        &mut self,
        field_name: &'static str,
        value: FieldValue,
    ) -> Result<(), FieldValueError> {
        match (field_name, value) {
            ("ConfigurationVersion", FieldValue::Unsigned(value)) => {
                self.configuration_version = u8_from_unsigned(field_name, value)?;
                Ok(())
            }
            ("SequenceHeaderLength", FieldValue::Unsigned(value)) => {
                self.sequence_header_length = u16_from_unsigned(field_name, value)?;
                Ok(())
            }
            ("SequenceHeader", FieldValue::Bytes(value)) => {
                self.sequence_header = value;
                Ok(())
            }
            ("LibraryDependencyIDC", FieldValue::Unsigned(value)) => {
                self.library_dependency_idc = u8_from_unsigned(field_name, value)?;
                Ok(())
            }
            (field_name, value) => Err(unexpected_field(field_name, value)),
        }
    }
}

impl CodecBox for Av3c {
    const FIELD_TABLE: FieldTable = FieldTable::new(&[
        codec_field!("ConfigurationVersion", 0, with_bit_width(8)),
        codec_field!("SequenceHeaderLength", 1, with_bit_width(16)),
        codec_field!(
            "SequenceHeader",
            2,
            with_bit_width(8),
            with_dynamic_length(),
            as_bytes()
        ),
        codec_field!(
            "Reserved",
            3,
            with_bit_width(6),
            with_constant("63"),
            as_hidden()
        ),
        codec_field!("LibraryDependencyIDC", 4, with_bit_width(2), as_hex()),
    ]);

    fn custom_marshal(&self, _writer: &mut dyn Write) -> Result<Option<u64>, CodecError> {
        if usize::from(self.sequence_header_length) != self.sequence_header.len() {
            return Err(invalid_value(
                "SequenceHeader",
                "length does not match SequenceHeaderLength",
            )
            .into());
        }
        if self.library_dependency_idc > 0x03 {
            return Err(
                invalid_value("LibraryDependencyIDC", "value does not fit in 2 bits").into(),
            );
        }
        Ok(None)
    }
}

/// Registers the currently implemented AVS3 boxes in `registry`.
pub fn register_boxes(registry: &mut BoxRegistry) {
    registry.register_any::<VisualSampleEntry>(FourCc::from_bytes(*b"avs3"));
    registry.register::<Av3c>(FourCc::from_bytes(*b"av3c"));
}