transmux — any-to-any media container muxing hub

Demux any supported container into one neutral in-memory IR (Media/Track) and mux from it into any supported container — so every {input} → {output} composes. Built to spec (ISO/IEC 14496-12, 13818-1, 23009-1; RFC 8216/3550; [MS-SSTR]). No transcode, no codec bitstream en/decode. no_std + alloc.

The spokes are the broadcast_common inverse-pair traits Unpackage (container → IR) and Package (IR → container):

Plus transforms — resegment/trim/track-select (Repackage), streaming CMAF (Segmenter) — CENC decrypt (CencDecryptor), and RTP de/packetize + SDP (RtpPacketizer/RtpDepacketizer).

Scope — container muxing only

transmux packages coded media; it never encodes or decodes it. It parses codec config/parameter headers (SPS/PPS/VPS, AAC ASC, syncframe BSI, EBML/box config) only far enough to build the container boxes and derive metadata (dimensions, profile, sample rate, codecs= MIME). Compressed samples are opaque payloads copied through byte-for-byte — decode/encode is the caller's job (WebCodecs, FFmpeg, hardware).

Every box has a symmetric Parse / Serialize with byte-identical round-trip coverage against real fixtures; every demux/mux spoke is gated on byte-exact round-trips through the IR.

Feature matrix

Container — ISOBMFF / CMAF boxes

Codecs — sample entries + config (header parse only)

Text / captions

Pipeline & packaging

Hub spokes (Unpackage / Package)

✅ = implemented + round-trip-tested · ⬜ = planned (issue linked)

Quick start

use transmux::{build_init_segment, build_media_segment, CodecConfig, TrackSpec,
               Sample, FragmentTrackData};

// Describe each track (codec config synthesised by the caller from SPS/PPS, ADTS…).
let tracks: Vec<TrackSpec> = /* … */ Vec::new();
let init = build_init_segment(&tracks, 1000)?;         // ftyp + moov

// Feed samples per fragment.
let video: Vec<Sample> = /* … */ Vec::new();
let media = build_media_segment(1, &[FragmentTrackData {
    track_id: 1,
    base_media_decode_time: 0,
    samples: &video,
}])?;                                                  // styp + moof + mdat
# Ok::<(), transmux::Error>(())

For a live/streaming source, Segmenter owns the segment-cutting state machine:

use transmux::{Segmenter, Sample};
# fn tracks() -> Vec<transmux::TrackSpec> { Vec::new() }
# if false {
let mut seg = Segmenter::new(tracks(), 1000, 2.0)?;    // ~2 s segments
let init = seg.init_segment()?;                        // ftyp + moov, once
seg.push(1, /* Sample */ unimplemented!())?;           // coded AUs, decode order
for media in seg.take_ready() { /* write out */ }
seg.flush()?;                                          // trailing segment at EOS
# }
# Ok::<(), transmux::Error>(())

Codec metadata comes straight from the parsed headers — no external SPS parser:

# if false {
let sps = transmux::AvcSps(sps_nal_bytes);
let info = sps.decode()?;              // profile / level / width·height / chroma …
let mime = sps.rfc6381()?;             // e.g. "avc1.4D400D" for WebCodecs / MSE
# }

tests/ts_to_cmaf.rs demonstrates the full path end-to-end: demux a real H.264+AAC TS, synthesise avcC/esds, and emit byte-identical-config CMAF.

Spec grounding

Every layout cites its source (ISO/IEC 14496-12 boxes; 14496-1 §7.2.6 esds; ITU-T H.264 §7.3.2.1.1 / H.265 §7.3.2.2 SPS; ETSI TS 102 366 Annex F AC-3/E-AC-3). Codec-config tests decode real ffmpeg-encoded fixtures and assert against an independent oracle (trace_headers fields; ffmpeg's own MP4-muxer config boxes).

License

MIT OR Apache-2.0.