oxideav-avi

Pure-Rust AVI (RIFF) container — demuxer + muxer for the legacy Microsoft AVI 1.0 format with a wide FourCC / WAVEFORMATEX mapping table into stable oxideav codec ids. Zero C dependencies.

Part of the oxideav framework but usable standalone.

Installation

[dependencies]
oxideav-core = "0.1"
oxideav-container = "0.1"
oxideav-avi = "0.0"

Feature matrix

OpenDML 2.0 muxing is opt-in via muxer::open_with_kind with an AviKind::OpenDml(RiffSegmentLimit::OneGiB) (or Bytes(n) for testing). The muxer rolls a new RIFF AVIX segment whenever the running segment would exceed the byte ceiling; the primary segment carries an indx super-index in the first stream's strl with one entry per segment back-patched in write_trailer, and each segment emits a per-stream ix## AVISTDINDEX chunk at the tail of its movi LIST. Demuxer-side, seek_to falls back to the ix## standard indexes when no AVI 1.0 idx1 is present (typical for OpenDML-only files written by recent ffmpeg / VirtualDub2 with --max_riff_size set). The legacy muxer::open (which Avi10 defaults to) refuses to grow past ~2 GiB and returns Error::Unsupported.

Codec mapping

AVI identifies video streams by a 4-byte biCompression FourCC in the strf/BITMAPINFOHEADER, and audio streams by a 16-bit wFormatTag in the strf/WAVEFORMATEX. oxideav-avi translates these both ways into the stable codec ids used everywhere else in oxideav.

FourCC matching is case-insensitive. Unknown tags round-trip as avi:<fourcc> (video) or avi:tag_xxxx (audio) rather than failing — so a caller can still walk an unrecognised stream, it just won't find a decoder.

Video FourCC to codec id

Audio wFormatTag to codec id

Muxer-side packaging (strf + strh) is implemented for a subset of the above: mjpeg, ffv1, mpeg1video, mpeg2video, mpeg4video, h263, h264, h265, vp8, vp9, av1, magicyuv, rgb24, all six raw PCM variants (pcm_u8/s16le/s24le/s32le/f32le/f64le), pcm_alaw, pcm_mulaw, mp2, mp3, aac, ac3, eac3, flac. Other codec ids return Error::Unsupported at open().

For codec ids that share several FourCCs (e.g. mpeg4video → XVID/DIVX/...; magicyuv → 17 native FourCCs), the muxer picks a default FourCC unless the caller hints otherwise. For magicyuv, the hint is the leading 4 bytes of CodecParameters::extradata if they spell one of the 17 native FourCCs; otherwise M8RG is used.

Quick use

Demux

use oxideav_container::{ContainerRegistry, ReadSeek};

let mut containers = ContainerRegistry::new();
oxideav_avi::register(&mut containers);

let input: Box<dyn ReadSeek> =
    Box::new(std::io::Cursor::new(std::fs::read("capture.avi")?));
let mut dmx = containers.open_demuxer("avi", input)?;

for s in dmx.streams() {
    eprintln!("stream {}: {} ({:?})", s.index, s.params.codec_id, s.params.media_type);
}

loop {
    match dmx.next_packet() {
        Ok(pkt) => {
            // feed into the matching decoder
        }
        Err(oxideav_core::Error::Eof) => break,
        Err(e) => return Err(e.into()),
    }
}
# Ok::<(), Box<dyn std::error::Error>>(())

seek_to(stream, pts) lands on the nearest keyframe at or before the target, using the idx1 index. Files without idx1 (streamed AVI, half-written recordings) return Error::Unsupported for seek; linear decode still works.

Mux

use oxideav_container::{ContainerRegistry, WriteSeek};
use oxideav_core::{CodecId, CodecParameters, MediaType, Packet,
                   Rational, SampleFormat, StreamInfo, TimeBase};

let mut containers = ContainerRegistry::new();
oxideav_avi::register(&mut containers);

// One video + one audio stream.
let mut v = CodecParameters::video(CodecId::new("mjpeg"));
v.width = Some(640);
v.height = Some(480);
v.frame_rate = Some(Rational::new(25, 1));

let mut a = CodecParameters::audio(CodecId::new("pcm_s16le"));
a.channels = Some(2);
a.sample_rate = Some(48_000);
a.sample_format = Some(SampleFormat::S16);

let streams = [
    StreamInfo { index: 0, time_base: TimeBase::new(1, 25),
                 duration: None, start_time: Some(0), params: v },
    StreamInfo { index: 1, time_base: TimeBase::new(1, 48_000),
                 duration: None, start_time: Some(0), params: a },
];

let out: Box<dyn WriteSeek> =
    Box::new(std::fs::File::create("out.avi")?);
let mut mux = containers.open_muxer("avi", out, &streams)?;
mux.write_header()?;
// mux.write_packet(&pkt)? for each encoded packet, interleaved
mux.write_trailer()?;
# Ok::<(), Box<dyn std::error::Error>>(())

The muxer always emits a legacy idx1 index at the end of the file so the resulting AVI is seekable. The 2 GiB ceiling is enforced strictly — if write_packet would push the file past ~2 GiB, it returns Error::Unsupported so the caller can roll a new segment.

Container id

• Container: "avi", matches .avi by extension and the RIFF....AVI magic.
• Registered via oxideav_avi::register(&mut ContainerRegistry).

License

MIT — see LICENSE.