Struct Decoder 

pub struct Decoder { /* private fields */ }

Decoder for MCRAW container files.

Opens a .mcraw file via memory-mapped I/O and provides access to container metadata, raw frame data, and audio chunks.

Implementations

impl Decoder

pub fn from_path(path: impl AsRef<Path>) -> Result<Self>

Open and decode an MCRAW file at the given path.

Examples found in repository

examples/decode.rs (line 47)

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: decode <input.mcraw> [-n <num_frames>]");
        std::process::exit(1);
    }

    let input_path = &args[1];
    let mut end_frame: Option<usize> = None;

    if args.len() > 3 && args[2] == "-n" {
        end_frame = Some(args[3].parse().expect("invalid frame count"));
    }

    let decoder = Decoder::from_path(input_path).expect("failed to open decoder");

    let timestamps: Vec<i64> = decoder.frame_timestamps().collect();

    println!("Found {} frames", timestamps.len());

    let end = end_frame.unwrap_or(timestamps.len()).min(timestamps.len());

    //
    // Audio
    //
    {
        let audio_chunks = decoder.load_audio().expect("failed to load audio");
        if !audio_chunks.is_empty() {
            println!(
                "Audio: {} chunks, {} Hz, {} channels",
                audio_chunks.len(),
                decoder.audio_sample_rate_hz(),
                decoder.num_audio_channels()
            );
            write_audio(&audio_chunks, "audio.raw");
        } else {
            println!("Audio: none");
        }
    }

    //
    // Frames
    //
    for i in 0..end {
        let (pixels, meta) = decoder
            .load_frame(timestamps[i])
            .unwrap_or_else(|e| panic!("failed to decode frame {}: {}", i, e));

        let width = meta["width"].as_u64().unwrap_or(0) as usize;
        let height = meta["height"].as_u64().unwrap_or(0) as usize;

        let filename = format!("frame_{:06}.raw", i);
        println!("Frame {}: {} (ts={})", i, fmt_metadata(&meta), timestamps[i]);
        write_raw_frame(&pixels, width, height, &filename);
    }
}

pub fn container_metadata(&self) -> &Value

Returns a reference to the container-level metadata (JSON).

pub fn prefetch(&self, timestamp: i64)

Hint the OS to prefetch a frame’s compressed bytes into the page cache.

Uses madvise(MADV_WILLNEED) on Unix to bring the frame’s mmap range into the page cache ahead of the actual read. Platform-specific implementation — this is a no-op on non-Unix targets.

pub fn frame_timestamps(&self) -> impl Iterator<Item = i64> + '_

Returns an iterator over all frame timestamps in the container.

Examples found in repository

examples/decode.rs (line 49)

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: decode <input.mcraw> [-n <num_frames>]");
        std::process::exit(1);
    }

    let input_path = &args[1];
    let mut end_frame: Option<usize> = None;

    if args.len() > 3 && args[2] == "-n" {
        end_frame = Some(args[3].parse().expect("invalid frame count"));
    }

    let decoder = Decoder::from_path(input_path).expect("failed to open decoder");

    let timestamps: Vec<i64> = decoder.frame_timestamps().collect();

    println!("Found {} frames", timestamps.len());

    let end = end_frame.unwrap_or(timestamps.len()).min(timestamps.len());

    //
    // Audio
    //
    {
        let audio_chunks = decoder.load_audio().expect("failed to load audio");
        if !audio_chunks.is_empty() {
            println!(
                "Audio: {} chunks, {} Hz, {} channels",
                audio_chunks.len(),
                decoder.audio_sample_rate_hz(),
                decoder.num_audio_channels()
            );
            write_audio(&audio_chunks, "audio.raw");
        } else {
            println!("Audio: none");
        }
    }

    //
    // Frames
    //
    for i in 0..end {
        let (pixels, meta) = decoder
            .load_frame(timestamps[i])
            .unwrap_or_else(|e| panic!("failed to decode frame {}: {}", i, e));

        let width = meta["width"].as_u64().unwrap_or(0) as usize;
        let height = meta["height"].as_u64().unwrap_or(0) as usize;

        let filename = format!("frame_{:06}.raw", i);
        println!("Frame {}: {} (ts={})", i, fmt_metadata(&meta), timestamps[i]);
        write_raw_frame(&pixels, width, height, &filename);
    }
}

pub fn audio_sample_rate_hz(&self) -> i64

Audio sample rate in Hz, read from container metadata.

Examples found in repository

examples/decode.rs (line 64)

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: decode <input.mcraw> [-n <num_frames>]");
        std::process::exit(1);
    }

    let input_path = &args[1];
    let mut end_frame: Option<usize> = None;

    if args.len() > 3 && args[2] == "-n" {
        end_frame = Some(args[3].parse().expect("invalid frame count"));
    }

    let decoder = Decoder::from_path(input_path).expect("failed to open decoder");

    let timestamps: Vec<i64> = decoder.frame_timestamps().collect();

    println!("Found {} frames", timestamps.len());

    let end = end_frame.unwrap_or(timestamps.len()).min(timestamps.len());

    //
    // Audio
    //
    {
        let audio_chunks = decoder.load_audio().expect("failed to load audio");
        if !audio_chunks.is_empty() {
            println!(
                "Audio: {} chunks, {} Hz, {} channels",
                audio_chunks.len(),
                decoder.audio_sample_rate_hz(),
                decoder.num_audio_channels()
            );
            write_audio(&audio_chunks, "audio.raw");
        } else {
            println!("Audio: none");
        }
    }

    //
    // Frames
    //
    for i in 0..end {
        let (pixels, meta) = decoder
            .load_frame(timestamps[i])
            .unwrap_or_else(|e| panic!("failed to decode frame {}: {}", i, e));

        let width = meta["width"].as_u64().unwrap_or(0) as usize;
        let height = meta["height"].as_u64().unwrap_or(0) as usize;

        let filename = format!("frame_{:06}.raw", i);
        println!("Frame {}: {} (ts={})", i, fmt_metadata(&meta), timestamps[i]);
        write_raw_frame(&pixels, width, height, &filename);
    }
}

pub fn num_audio_channels(&self) -> i64

Number of audio channels, read from container metadata.

Examples found in repository

examples/decode.rs (line 65)

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: decode <input.mcraw> [-n <num_frames>]");
        std::process::exit(1);
    }

    let input_path = &args[1];
    let mut end_frame: Option<usize> = None;

    if args.len() > 3 && args[2] == "-n" {
        end_frame = Some(args[3].parse().expect("invalid frame count"));
    }

    let decoder = Decoder::from_path(input_path).expect("failed to open decoder");

    let timestamps: Vec<i64> = decoder.frame_timestamps().collect();

    println!("Found {} frames", timestamps.len());

    let end = end_frame.unwrap_or(timestamps.len()).min(timestamps.len());

    //
    // Audio
    //
    {
        let audio_chunks = decoder.load_audio().expect("failed to load audio");
        if !audio_chunks.is_empty() {
            println!(
                "Audio: {} chunks, {} Hz, {} channels",
                audio_chunks.len(),
                decoder.audio_sample_rate_hz(),
                decoder.num_audio_channels()
            );
            write_audio(&audio_chunks, "audio.raw");
        } else {
            println!("Audio: none");
        }
    }

    //
    // Frames
    //
    for i in 0..end {
        let (pixels, meta) = decoder
            .load_frame(timestamps[i])
            .unwrap_or_else(|e| panic!("failed to decode frame {}: {}", i, e));

        let width = meta["width"].as_u64().unwrap_or(0) as usize;
        let height = meta["height"].as_u64().unwrap_or(0) as usize;

        let filename = format!("frame_{:06}.raw", i);
        println!("Frame {}: {} (ts={})", i, fmt_metadata(&meta), timestamps[i]);
        write_raw_frame(&pixels, width, height, &filename);
    }
}

pub fn load_frame_metadata(&self, timestamp: i64) -> Result<Value>

Load metadata for a specific frame without decoding pixel data.

pub fn load_frame(&self, timestamp: i64) -> Result<(Vec<u16>, Value)>

Load and decode a single frame by timestamp.

Returns (pixels, metadata) where pixels is a Vec<u16> in row-major order (Bayer raw data).

Examples found in repository

examples/decode.rs (line 78)

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: decode <input.mcraw> [-n <num_frames>]");
        std::process::exit(1);
    }

    let input_path = &args[1];
    let mut end_frame: Option<usize> = None;

    if args.len() > 3 && args[2] == "-n" {
        end_frame = Some(args[3].parse().expect("invalid frame count"));
    }

    let decoder = Decoder::from_path(input_path).expect("failed to open decoder");

    let timestamps: Vec<i64> = decoder.frame_timestamps().collect();

    println!("Found {} frames", timestamps.len());

    let end = end_frame.unwrap_or(timestamps.len()).min(timestamps.len());

    //
    // Audio
    //
    {
        let audio_chunks = decoder.load_audio().expect("failed to load audio");
        if !audio_chunks.is_empty() {
            println!(
                "Audio: {} chunks, {} Hz, {} channels",
                audio_chunks.len(),
                decoder.audio_sample_rate_hz(),
                decoder.num_audio_channels()
            );
            write_audio(&audio_chunks, "audio.raw");
        } else {
            println!("Audio: none");
        }
    }

    //
    // Frames
    //
    for i in 0..end {
        let (pixels, meta) = decoder
            .load_frame(timestamps[i])
            .unwrap_or_else(|e| panic!("failed to decode frame {}: {}", i, e));

        let width = meta["width"].as_u64().unwrap_or(0) as usize;
        let height = meta["height"].as_u64().unwrap_or(0) as usize;

        let filename = format!("frame_{:06}.raw", i);
        println!("Frame {}: {} (ts={})", i, fmt_metadata(&meta), timestamps[i]);
        write_raw_frame(&pixels, width, height, &filename);
    }
}

pub fn load_frame_into( &self, timestamp: i64, out: &mut [u16], ) -> Result<[f32; 3]>

Decode a single frame by timestamp into a caller-owned buffer.

Avoids the per-frame allocation that load_frame does. Returns only asShotNeutral as [f32; 3] — if you need other metadata fields, use load_frame instead.

pub fn load_all_frames_parallel(&self) -> Result<Vec<(i64, Vec<u16>, Value)>>

Decode all frames in parallel using rayon.

Only available when the parallel feature is enabled (default).

pub fn load_audio(&self) -> Result<Vec<AudioChunk>>

Load all audio chunks from the container.

Examples found in repository

examples/decode.rs (line 59)

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: decode <input.mcraw> [-n <num_frames>]");
        std::process::exit(1);
    }

    let input_path = &args[1];
    let mut end_frame: Option<usize> = None;

    if args.len() > 3 && args[2] == "-n" {
        end_frame = Some(args[3].parse().expect("invalid frame count"));
    }

    let decoder = Decoder::from_path(input_path).expect("failed to open decoder");

    let timestamps: Vec<i64> = decoder.frame_timestamps().collect();

    println!("Found {} frames", timestamps.len());

    let end = end_frame.unwrap_or(timestamps.len()).min(timestamps.len());

    //
    // Audio
    //
    {
        let audio_chunks = decoder.load_audio().expect("failed to load audio");
        if !audio_chunks.is_empty() {
            println!(
                "Audio: {} chunks, {} Hz, {} channels",
                audio_chunks.len(),
                decoder.audio_sample_rate_hz(),
                decoder.num_audio_channels()
            );
            write_audio(&audio_chunks, "audio.raw");
        } else {
            println!("Audio: none");
        }
    }

    //
    // Frames
    //
    for i in 0..end {
        let (pixels, meta) = decoder
            .load_frame(timestamps[i])
            .unwrap_or_else(|e| panic!("failed to decode frame {}: {}", i, e));

        let width = meta["width"].as_u64().unwrap_or(0) as usize;
        let height = meta["height"].as_u64().unwrap_or(0) as usize;

        let filename = format!("frame_{:06}.raw", i);
        println!("Frame {}: {} (ts={})", i, fmt_metadata(&meta), timestamps[i]);
        write_raw_frame(&pixels, width, height, &filename);
    }
}