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), IR timeline conditioning — PTS/DTS rebase-to-zero / offset / 33-bit MPEG wrap-unroll / discontinuity-gap insertion (rebase_to_zero, apply_offset, unroll_33bit_wraps, insert_discontinuity_gap, over each Track::start_decode_time anchor) — 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.

Command-line packager (cli feature)

The optional cli feature builds a transmux binary that wires the demux and mux spokes into an any-to-any packager: it autodetects the input container from its leading bytes, runs it through the [Media] hub IR, and writes the chosen output format. The library itself stays no_std; only this feature pulls clap + std. It follows the workspace CLI standard (docs/CLI-STANDARD.md) — clap derive, named flags, auto --help/--version.

$ cargo install transmux --features cli      # or: cargo run -p transmux --features cli --

# TS → CMAF (autodetected input; format inferred from the .cmaf extension)
$ transmux in.ts -o out.cmaf

# MP4 → CMAF-HLS, 4-second segments
$ transmux in.mp4 -o out.m3u8 -f hls --segment-duration 4

# WebM → progressive single-file MP4
$ transmux in.webm -o out.mp4 -f progressive

# PS → DASH MPD (low-latency chunked variant)
$ transmux in.ps -o out.mpd -f dash --ll

Input autodetect signatures: MPEG-TS (0x47 sync at 0 and +188), MP4/CMAF (ftyp/styp/moov/moof box at offset 4), MPEG-PS (00 00 01 BA), WebM/Matroska (EBML 1A 45 DF A3), FLV ("FLV").

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.