mp4 Rust Library

You can add the mp4 library to your Rust project using cargo add or by manually editing your Cargo.toml file.

cargo add mp4

Or add this to your Cargo.toml:

mp4 = "0.14.0"

When creating a new track (e.g., for writing a new MP4 file), use TrackConfig to define the track's properties. TrackConfig is constructed from a MediaConfig which specifies the codec-specific parameters.

Common TrackType values include Video, Audio, and Subtitle. The timescale determines the temporal resolution of the track.

// Example: Configuring a video track with H264
let media_conf = MediaConfig::AvcConfig(AvcConfig {
    width: 1920,
    height: 1080,
    // ... other AvcConfig fields
});

let config = TrackConfig {
    track_type: TrackType::Video,
    timescale: 1000,
    language: String::from("eng"),
    media_conf,
};

The repository includes example CLI tools that you can run directly using cargo run. These are useful for inspecting MP4 files from the command line.

• mp4info: Displays information about a movie file.
• mp4dump: Dumps the contents of an MP4 file.

# Run mp4info
cargo run --example mp4info <movie.mp4>

# Run mp4dump
cargo run --example mp4dump <movie.mp4>

Use Mp4Config to define the global metadata for your MP4 file. This includes the brand identifiers and the timescale used for all tracks.

Fields:

• major_brand: A FourCC representing the primary brand (e.g., isom).
• minor_version: A u32 version number.
• compatible_brands: A Vec<FourCC> of other brands the file is compatible with.
• timescale: A u32 value defining the number of units per second, used to calculate durations.

The Mp4TrackWriter (internal/utility) is used to build a track by feeding it Mp4Sample objects. It manages the underlying MP4 boxes like stsz (sample sizes), stts (time-to-sample), and co64 (chunk offsets) automatically.

To complete a track, you must call write_end, which flushes any remaining buffered data and returns the final TrakBox required to finalize the MP4 container.

// Note: Mp4TrackWriter is marked pub(crate) in this file,
// implying it is used by higher-level components in the mp4 crate.
// The pattern for usage is:
// 1. Initialize writer with TrackConfig
// 2. Loop: writer.write_sample(writer, &sample, movie_timescale)?
// 3. Finalize: writer.write_end(writer)?

The UrlBox is used within a DrefBox to provide a string-based location (URL or file path) for track data.

Fields:

• version: u8
• flags: u32
• location: String (The actual path or URL)

Key methods:

• get_type(): Returns BoxType::UrlBox.
• get_size(): Returns the size including the header and the null-terminated location string.
• to_json(): Serializes the box to a JSON string.
• summary(): Returns a summary string in the format location=<location_string>.

use mp4::mp4box::UrlBox;

let url_box = UrlBox {
    version: 0,
    flags: 1,
    location: "/path/to/track.mp4".to_string(),
};

println!("{}", url_box.summary()); // Outputs: location=/path/to/track.mp4

The CttsBox (Composition Time to Sample) and CttsEntry types are used to handle MP4 box data that defines the composition time offsets for samples.

CttsBox

Represents the ctts box. It contains:

• version: u8
• flags: u32
• entries: A Vec<CttsEntry> (Note: this field is skipped during JSON serialization).

CttsEntry

Represents an individual entry within the box:

• sample_count: u32
• sample_offset: i32 (The offset applied to the sample's composition time).

use crate::mp4box::CttsBox;
use crate::mp4box::CttsEntry;

let ctts = CttsBox {
    version: 0,
    flags: 0,
    entries: vec![
        CttsEntry {
            sample_count: 1,
            sample_offset: 200,
        },
        CttsEntry {
            sample_count: 2,
            sample_offset: -100,
        },
    ],
};

MP4 files use an epoch starting from 1904-01-01. Use the creation_time function to convert these values to the standard Unix epoch (1970-01-01).

let mp4_time: u64 = 2082844800; // Example value
let unix_time = creation_time(mp4_time);