transmux — MPEG-2 TS → CMAF/fMP4 remux

Container-layer remux from MPEG-2 Transport Stream to fragmented MP4 / CMAF, built to spec (ISO/IEC 14496-12:2015, RFC 8216). Samples-in: the caller supplies demuxed encoded access units + codec config; transmux produces the initialization and media segments (and the HLS playlists). No transcode, no codec bitstream decoding. no_std + alloc.

Scope — container multiplexing only

transmux packages coded media; it never encodes or decodes it. It parses codec config/parameter headers (SPS/PPS/VPS, AAC ASC, AC-3/E-AC-3 syncframe BSI) only far enough to build the container boxes and derive metadata (dimensions, profile, sample rate, codecs= MIME). The compressed samples themselves are opaque payloads copied through byte-for-byte — decode/encode is the caller's job (WebCodecs, FFmpeg, hardware). Demux (TS → elementary streams) also lives in the caller.

Every box has a symmetric Parse / Serialize with byte-identical round-trip coverage against real fMP4 fixtures.

Feature matrix

Container — ISOBMFF / CMAF boxes

Codecs — sample entries + config (header parse only)

Text / captions

Pipeline & packaging

✅ = 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.