use std::io::{self, Seek, SeekFrom, Write};
use super::mp4::{bx, concat, fullbox, UNITY_MATRIX};
const MOVIE_TIMESCALE: u32 = 1000;
#[derive(Clone)]
pub struct VideoConfig {
pub width: u32,
pub height: u32,
pub timescale: u32,
pub avcc: Vec<u8>,
}
#[derive(Clone, PartialEq, Eq)]
pub enum AudioCoding {
PcmS16le,
Aac { asc: Vec<u8> },
}
#[derive(Clone)]
pub struct AudioConfig {
pub sample_rate: u32,
pub channels: u16,
pub bits_per_sample: u16,
pub coding: AudioCoding,
pub encoder_delay: u32,
}
impl AudioConfig {
pub fn pcm_s16le(sample_rate: u32, channels: u16) -> Self {
AudioConfig {
sample_rate,
channels,
bits_per_sample: 16,
coding: AudioCoding::PcmS16le,
encoder_delay: 0, }
}
pub fn aac(sample_rate: u32, channels: u16, asc: Vec<u8>, encoder_delay: u32) -> Self {
AudioConfig {
sample_rate,
channels,
bits_per_sample: 16,
coding: AudioCoding::Aac { asc },
encoder_delay,
}
}
pub fn bytes_per_frame(&self) -> usize {
usize::from(self.channels) * usize::from(self.bits_per_sample / 8)
}
fn is_pcm(&self) -> bool {
self.coding == AudioCoding::PcmS16le
}
}
fn descriptor(tag: u8, payload: &[u8]) -> Vec<u8> {
let mut v = vec![tag];
let mut len = payload.len();
let mut groups = Vec::new();
loop {
groups.push((len & 0x7f) as u8);
len >>= 7;
if len == 0 {
break;
}
}
for (i, g) in groups.iter().enumerate().rev() {
v.push(if i == 0 { *g } else { *g | 0x80 });
}
v.extend_from_slice(payload);
v
}
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub struct Mp4StreamStats {
pub video_samples: u32,
pub audio_frames: u32,
pub keyframes: u32,
pub media_bytes: u64,
pub video_duration_ticks: u64,
pub audio_duration_ticks: u64,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Kind {
Video,
Audio,
}
#[derive(Default)]
struct Track {
sizes: Vec<u32>,
durations: Vec<(u32, u32)>,
sync: Vec<u32>,
all_sync: bool,
chunks: Vec<(u64, u32)>,
samples: u32,
duration: u64,
}
impl Track {
fn new() -> Self {
Track {
all_sync: true,
..Default::default()
}
}
fn add_duration(&mut self, d: u32) {
match self.durations.last_mut() {
Some((count, delta)) if *delta == d => *count += 1,
_ => self.durations.push((1, d)),
}
self.duration += u64::from(d);
}
fn add_chunk(&mut self, offset: u64, n: u32, contiguous: bool) {
if contiguous {
if let Some(last) = self.chunks.last_mut() {
last.1 += n;
return;
}
}
self.chunks.push((offset, n));
}
fn mark_sync(&mut self, sample: u32, sync: bool) {
if sync {
self.sync.push(sample);
} else {
self.all_sync = false;
}
}
fn sync_sample_table(&self) -> Option<Vec<u8>> {
if self.all_sync {
return None;
}
Some(fullbox(b"stss", 0, 0, &{
let mut v = Vec::with_capacity(4 + self.sync.len() * 4);
v.extend_from_slice(&(self.sync.len() as u32).to_be_bytes());
for s in &self.sync {
v.extend_from_slice(&s.to_be_bytes());
}
v
}))
}
fn time_to_sample(&self) -> Vec<u8> {
fullbox(b"stts", 0, 0, &{
let mut v = Vec::with_capacity(4 + self.durations.len() * 8);
v.extend_from_slice(&(self.durations.len() as u32).to_be_bytes());
for (count, delta) in &self.durations {
v.extend_from_slice(&count.to_be_bytes());
v.extend_from_slice(&delta.to_be_bytes());
}
v
})
}
fn sample_size(&self, constant_size: Option<u32>) -> Vec<u8> {
fullbox(b"stsz", 0, 0, &{
let mut v = Vec::new();
match constant_size {
Some(size) => {
v.extend_from_slice(&size.to_be_bytes());
v.extend_from_slice(&self.samples.to_be_bytes());
}
None => {
v.extend_from_slice(&0u32.to_be_bytes());
v.extend_from_slice(&(self.sizes.len() as u32).to_be_bytes());
for s in &self.sizes {
v.extend_from_slice(&s.to_be_bytes());
}
}
}
v
})
}
fn sample_to_chunk(&self) -> Vec<u8> {
let mut entries: Vec<(u32, u32)> = Vec::new(); for (i, (_, n)) in self.chunks.iter().enumerate() {
let first_chunk = (i + 1) as u32;
match entries.last() {
Some((_, prev)) if prev == n => {}
_ => entries.push((first_chunk, *n)),
}
}
fullbox(b"stsc", 0, 0, &{
let mut v = Vec::with_capacity(4 + entries.len() * 12);
v.extend_from_slice(&(entries.len() as u32).to_be_bytes());
for (first, per) in &entries {
v.extend_from_slice(&first.to_be_bytes());
v.extend_from_slice(&per.to_be_bytes());
v.extend_from_slice(&1u32.to_be_bytes()); }
v
})
}
fn chunk_offsets(&self) -> Vec<u8> {
let needs_64 = self
.chunks
.iter()
.any(|(off, _)| *off > u64::from(u32::MAX));
if needs_64 {
fullbox(b"co64", 0, 0, &{
let mut v = Vec::with_capacity(4 + self.chunks.len() * 8);
v.extend_from_slice(&(self.chunks.len() as u32).to_be_bytes());
for (off, _) in &self.chunks {
v.extend_from_slice(&off.to_be_bytes());
}
v
})
} else {
fullbox(b"stco", 0, 0, &{
let mut v = Vec::with_capacity(4 + self.chunks.len() * 4);
v.extend_from_slice(&(self.chunks.len() as u32).to_be_bytes());
for (off, _) in &self.chunks {
v.extend_from_slice(&(*off as u32).to_be_bytes());
}
v
})
}
}
}
pub struct Mp4StreamWriter<W: Write + Seek> {
out: W,
video_cfg: VideoConfig,
audio_cfg: Option<AudioConfig>,
video: Track,
audio: Track,
mdat_header_offset: u64,
payload_start: u64,
payload_len: u64,
last_kind: Option<Kind>,
keyframes: u32,
pcm_remainder: Vec<u8>,
finished: bool,
}
impl<W: Write + Seek> Mp4StreamWriter<W> {
pub fn new(mut out: W, video: VideoConfig, audio: Option<AudioConfig>) -> io::Result<Self> {
assert!(video.timescale > 0, "video timescale must be non-zero");
let ftyp = if audio.as_ref().is_some_and(AudioConfig::is_pcm) {
bx(b"ftyp", &{
let mut v = Vec::new();
v.extend_from_slice(b"qt ");
v.extend_from_slice(&0x0000_0200u32.to_be_bytes()); v.extend_from_slice(b"qt ");
v
})
} else {
bx(b"ftyp", &{
let mut v = Vec::new();
v.extend_from_slice(b"isom");
v.extend_from_slice(&0u32.to_be_bytes());
for brand in [b"isom", b"iso2", b"avc1", b"mp41"] {
v.extend_from_slice(brand);
}
v
})
};
out.write_all(&ftyp)?;
let mdat_header_offset = ftyp.len() as u64;
out.write_all(&1u32.to_be_bytes())?; out.write_all(b"mdat")?;
out.write_all(&0u64.to_be_bytes())?; let payload_start = mdat_header_offset + 16;
Ok(Mp4StreamWriter {
out,
video_cfg: video,
audio_cfg: audio,
video: Track::new(),
audio: Track::new(),
mdat_header_offset,
payload_start,
payload_len: 0,
last_kind: None,
keyframes: 0,
pcm_remainder: Vec::new(),
finished: false,
})
}
pub fn write_video_sample(
&mut self,
sample: &[u8],
duration: u32,
sync: bool,
) -> io::Result<()> {
if sample.is_empty() {
return Ok(());
}
let offset = self.payload_start + self.payload_len;
self.out.write_all(sample)?;
self.payload_len += sample.len() as u64;
let contiguous = self.last_kind == Some(Kind::Video);
self.video.sizes.push(sample.len() as u32);
self.video.samples += 1;
self.video.add_duration(duration);
self.video.add_chunk(offset, 1, contiguous);
self.video.mark_sync(self.video.samples, sync);
if sync {
self.keyframes += 1;
}
self.last_kind = Some(Kind::Video);
Ok(())
}
pub fn write_audio_sample(&mut self, pcm: &[u8]) -> io::Result<()> {
let Some(cfg) = self.audio_cfg.clone() else {
return Ok(()); };
if !cfg.is_pcm() {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"this track is AAC — use write_audio_packet",
));
}
let frame = cfg.bytes_per_frame();
if frame == 0 || pcm.is_empty() && self.pcm_remainder.is_empty() {
return Ok(());
}
let joined: &[u8] = if self.pcm_remainder.is_empty() {
pcm
} else {
self.pcm_remainder.extend_from_slice(pcm);
&self.pcm_remainder
};
let frames = joined.len() / frame;
let usable = frames * frame;
if frames == 0 {
if self.pcm_remainder.is_empty() {
self.pcm_remainder.extend_from_slice(pcm);
}
return Ok(());
}
let offset = self.payload_start + self.payload_len;
self.out.write_all(&joined[..usable])?;
self.payload_len += usable as u64;
let leftover = joined[usable..].to_vec();
let contiguous = self.last_kind == Some(Kind::Audio);
self.audio.samples += frames as u32;
match self.audio.durations.last_mut() {
Some((count, delta)) if *delta == 1 => *count += frames as u32,
_ => self.audio.durations.push((frames as u32, 1)),
}
self.audio.duration += frames as u64;
self.audio.add_chunk(offset, frames as u32, contiguous);
self.pcm_remainder = leftover;
self.last_kind = Some(Kind::Audio);
Ok(())
}
pub fn write_audio_packet(&mut self, packet: &[u8], duration: u32) -> io::Result<()> {
let Some(cfg) = self.audio_cfg.as_ref() else {
return Ok(()); };
if cfg.is_pcm() {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"this track is PCM — use write_audio_sample",
));
}
if packet.is_empty() {
return Ok(());
}
let offset = self.payload_start + self.payload_len;
self.out.write_all(packet)?;
self.payload_len += packet.len() as u64;
let contiguous = self.last_kind == Some(Kind::Audio);
self.audio.sizes.push(packet.len() as u32);
self.audio.samples += 1;
self.audio.add_duration(duration);
self.audio.add_chunk(offset, 1, contiguous);
self.last_kind = Some(Kind::Audio);
Ok(())
}
pub fn finish(self) -> io::Result<Mp4StreamStats> {
self.finish_with_sink().map(|(stats, _)| stats)
}
pub fn finish_with_sink(mut self) -> io::Result<(Mp4StreamStats, W)> {
self.finished = true;
let mdat_total = 16 + self.payload_len;
self.out
.seek(SeekFrom::Start(self.mdat_header_offset + 8))?;
self.out.write_all(&mdat_total.to_be_bytes())?;
self.out.seek(SeekFrom::End(0))?;
let moov = self.build_moov();
self.out.write_all(&moov)?;
self.out.flush()?;
let stats = Mp4StreamStats {
video_samples: self.video.samples,
audio_frames: self.audio.samples,
keyframes: self.keyframes,
media_bytes: self.payload_len,
video_duration_ticks: self.video.duration,
audio_duration_ticks: self.audio.duration,
};
Ok((stats, self.out))
}
fn movie_ticks(duration: u64, timescale: u32) -> u32 {
if timescale == 0 {
return 0;
}
(duration.saturating_mul(u64::from(MOVIE_TIMESCALE)) / u64::from(timescale)) as u32
}
fn build_moov(&self) -> Vec<u8> {
let video_movie_ticks =
Self::movie_ticks(self.video.duration, self.video_cfg.timescale);
let audio_movie_ticks = self
.audio_cfg
.as_ref()
.map(|c| Self::movie_ticks(self.audio.duration, c.sample_rate))
.unwrap_or(0);
let movie_duration = video_movie_ticks.max(audio_movie_ticks);
let video_trak = self.build_video_trak(video_movie_ticks);
let audio_trak = self
.audio_cfg
.as_ref()
.map(|c| self.build_audio_trak(c, audio_movie_ticks));
let next_track_id = if audio_trak.is_some() { 3u32 } else { 2 };
let mvhd = fullbox(b"mvhd", 0, 0, &{
let mut v = Vec::new();
v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&MOVIE_TIMESCALE.to_be_bytes());
v.extend_from_slice(&movie_duration.to_be_bytes());
v.extend_from_slice(&0x0001_0000u32.to_be_bytes()); v.extend_from_slice(&0x0100u16.to_be_bytes()); v.extend_from_slice(&0u16.to_be_bytes()); v.extend_from_slice(&[0u8; 8]); v.extend_from_slice(&UNITY_MATRIX);
v.extend_from_slice(&[0u8; 24]); v.extend_from_slice(&next_track_id.to_be_bytes());
v
});
let mut children = vec![mvhd, video_trak];
children.extend(audio_trak);
bx(b"moov", &concat(&children))
}
fn build_video_trak(&self, movie_ticks: u32) -> Vec<u8> {
let cfg = &self.video_cfg;
let avc1 = bx(b"avc1", &{
let mut v = Vec::new();
v.extend_from_slice(&[0u8; 6]); v.extend_from_slice(&1u16.to_be_bytes()); v.extend_from_slice(&[0u8; 16]); v.extend_from_slice(&(cfg.width as u16).to_be_bytes());
v.extend_from_slice(&(cfg.height as u16).to_be_bytes());
v.extend_from_slice(&0x0048_0000u32.to_be_bytes()); v.extend_from_slice(&0x0048_0000u32.to_be_bytes()); v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&1u16.to_be_bytes()); v.extend_from_slice(&[0u8; 32]); v.extend_from_slice(&0x0018u16.to_be_bytes()); v.extend_from_slice(&(-1i16).to_be_bytes()); v.extend_from_slice(&bx(b"avcC", &cfg.avcc));
v
});
let stsd = fullbox(b"stsd", 0, 0, &{
let mut v = Vec::new();
v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&avc1);
v
});
let mut stbl_children = vec![stsd, self.video.time_to_sample()];
stbl_children.extend(self.video.sync_sample_table());
stbl_children.push(self.video.sample_to_chunk());
stbl_children.push(self.video.sample_size(None));
stbl_children.push(self.video.chunk_offsets());
let stbl = bx(b"stbl", &concat(&stbl_children));
let vmhd = fullbox(b"vmhd", 0, 1, &[0u8; 8]);
let minf = bx(
b"minf",
&concat(&[vmhd, handler(b"vide"), data_information(), stbl]),
);
let mdia = bx(
b"mdia",
&concat(&[
media_header(cfg.timescale, self.video.duration),
handler(b"vide"),
minf,
]),
);
let tkhd = fullbox(b"tkhd", 0, 7, &{
let mut v = Vec::new();
v.extend_from_slice(&0u32.to_be_bytes());
v.extend_from_slice(&0u32.to_be_bytes());
v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&movie_ticks.to_be_bytes());
v.extend_from_slice(&[0u8; 8]); v.extend_from_slice(&0u16.to_be_bytes()); v.extend_from_slice(&0u16.to_be_bytes()); v.extend_from_slice(&0u16.to_be_bytes()); v.extend_from_slice(&0u16.to_be_bytes()); v.extend_from_slice(&UNITY_MATRIX);
v.extend_from_slice(&(cfg.width << 16).to_be_bytes());
v.extend_from_slice(&(cfg.height << 16).to_be_bytes());
v
});
bx(b"trak", &concat(&[tkhd, mdia]))
}
fn build_audio_trak(&self, cfg: &AudioConfig, movie_ticks: u32) -> Vec<u8> {
let mut entry = Vec::new();
entry.extend_from_slice(&[0u8; 6]); entry.extend_from_slice(&1u16.to_be_bytes()); entry.extend_from_slice(&0u16.to_be_bytes()); entry.extend_from_slice(&0u16.to_be_bytes()); entry.extend_from_slice(&0u32.to_be_bytes()); entry.extend_from_slice(&cfg.channels.to_be_bytes());
entry.extend_from_slice(&cfg.bits_per_sample.to_be_bytes());
entry.extend_from_slice(&0u16.to_be_bytes()); entry.extend_from_slice(&0u16.to_be_bytes()); entry.extend_from_slice(&(cfg.sample_rate << 16).to_be_bytes());
let sample_entry = match &cfg.coding {
AudioCoding::PcmS16le => bx(b"sowt", &entry),
AudioCoding::Aac { asc } => {
let dec_specific = descriptor(0x05, asc);
let dec_config = descriptor(0x04, &{
let mut v = Vec::new();
v.push(0x40); v.push(0x15); v.extend_from_slice(&[0, 0, 0]); v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&dec_specific);
v
});
let sl_config = descriptor(0x06, &[0x02]);
let es = descriptor(0x03, &{
let mut v = Vec::new();
v.extend_from_slice(&1u16.to_be_bytes()); v.push(0x00); v.extend_from_slice(&dec_config);
v.extend_from_slice(&sl_config);
v
});
entry.extend_from_slice(&fullbox(b"esds", 0, 0, &es));
bx(b"mp4a", &entry)
}
};
let stsd = fullbox(b"stsd", 0, 0, &{
let mut v = Vec::new();
v.extend_from_slice(&1u32.to_be_bytes());
v.extend_from_slice(&sample_entry);
v
});
let constant_size = cfg.is_pcm().then(|| cfg.bytes_per_frame() as u32);
let stbl = bx(
b"stbl",
&concat(&[
stsd,
self.audio.time_to_sample(),
self.audio.sample_to_chunk(),
self.audio.sample_size(constant_size),
self.audio.chunk_offsets(),
]),
);
let smhd = fullbox(b"smhd", 0, 0, &[0u8; 4]); let minf = bx(
b"minf",
&concat(&[smhd, handler(b"soun"), data_information(), stbl]),
);
let mdia = bx(
b"mdia",
&concat(&[
media_header(cfg.sample_rate, self.audio.duration),
handler(b"soun"),
minf,
]),
);
let edts = if cfg.encoder_delay > 0 && self.audio.duration > u64::from(cfg.encoder_delay) {
let media = self.audio.duration - u64::from(cfg.encoder_delay);
let elst = fullbox(b"elst", 0, 0, &{
let mut v = Vec::new();
v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&Self::movie_ticks(media, cfg.sample_rate).to_be_bytes());
v.extend_from_slice(&cfg.encoder_delay.to_be_bytes()); v.extend_from_slice(&0x0001_0000u32.to_be_bytes()); v
});
Some(bx(b"edts", &elst))
} else {
None
};
let tkhd = fullbox(b"tkhd", 0, 7, &{
let mut v = Vec::new();
v.extend_from_slice(&0u32.to_be_bytes());
v.extend_from_slice(&0u32.to_be_bytes());
v.extend_from_slice(&2u32.to_be_bytes()); v.extend_from_slice(&0u32.to_be_bytes());
v.extend_from_slice(&movie_ticks.to_be_bytes());
v.extend_from_slice(&[0u8; 8]);
v.extend_from_slice(&0u16.to_be_bytes()); v.extend_from_slice(&0u16.to_be_bytes()); v.extend_from_slice(&0x0100u16.to_be_bytes()); v.extend_from_slice(&0u16.to_be_bytes()); v.extend_from_slice(&UNITY_MATRIX);
v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&0u32.to_be_bytes()); v
});
let mut parts = vec![tkhd];
parts.extend(edts);
parts.push(mdia);
bx(b"trak", &concat(&parts))
}
}
fn media_header(timescale: u32, duration: u64) -> Vec<u8> {
fullbox(b"mdhd", 0, 0, &{
let mut v = Vec::new();
v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(×cale.to_be_bytes());
v.extend_from_slice(&(duration.min(u64::from(u32::MAX)) as u32).to_be_bytes());
v.extend_from_slice(&0x55c4u16.to_be_bytes()); v.extend_from_slice(&0u16.to_be_bytes()); v
})
}
fn handler(kind: &[u8; 4]) -> Vec<u8> {
fullbox(b"hdlr", 0, 0, &{
let mut v = Vec::new();
v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(kind);
v.extend_from_slice(&[0u8; 12]); v.extend_from_slice(b"threers\0");
v
})
}
fn data_information() -> Vec<u8> {
let dref = fullbox(b"dref", 0, 0, &{
let mut v = Vec::new();
v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&fullbox(b"url ", 0, 1, &[])); v
});
bx(b"dinf", &dref)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::codec::mp4_demux::demux_video;
use std::io::Cursor;
const SPS: &[u8] = &[
0x27, 0x64, 0x00, 0x33, 0xac, 0x56, 0x80, 0x47, 0x01, 0x33, 0xe6, 0x9e, 0x6e, 0x04, 0x04,
0x04, 0x04,
];
const PPS: &[u8] = &[0x28, 0xee, 0x3c, 0xb0];
fn video_config() -> VideoConfig {
VideoConfig {
width: 1126,
height: 2436,
timescale: 1_000_000,
avcc: crate::codec::h264::avcc::build_avcc(SPS, PPS),
}
}
fn avcc_frame(n: usize, fill: u8) -> Vec<u8> {
let mut v = Vec::with_capacity(4 + n);
v.extend_from_slice(&(n as u32).to_be_bytes());
v.extend(std::iter::repeat_n(fill, n));
v
}
fn contains_tag(data: &[u8], tag: &[u8; 4]) -> bool {
data.windows(4).any(|w| w == tag)
}
type Frame = (Vec<u8>, u32, bool);
fn write_video_only(frames: &[Frame]) -> Vec<u8> {
let mut w = Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), None).unwrap();
for (data, dur, sync) in frames {
w.write_video_sample(data, *dur, *sync).unwrap();
}
w.finish_with_sink().unwrap().1.into_inner()
}
#[test]
fn roundtrips_through_the_demuxer() {
let frames: Vec<Frame> = vec![
(avcc_frame(120, 0xa1), 16_666, true),
(avcc_frame(40, 0xa2), 16_666, false),
(avcc_frame(55, 0xa3), 33_333, false),
(avcc_frame(200, 0xa4), 16_666, true),
(avcc_frame(30, 0xa5), 16_666, false),
];
let bytes = write_video_only(&frames);
let track = demux_video(&bytes).expect("demux");
assert_eq!((track.width, track.height), (1126, 2436));
assert_eq!(track.timescale, 1_000_000);
assert_eq!(track.config, crate::codec::h264::avcc::build_avcc(SPS, PPS));
assert_eq!(track.samples.len(), frames.len());
for (i, (data, dur, sync)) in frames.iter().enumerate() {
let s = &track.samples[i];
assert_eq!(s.size as usize, data.len(), "sample {i} size");
assert_eq!(s.duration, *dur, "sample {i} duration");
assert_eq!(s.sync, *sync, "sample {i} sync flag");
let start = s.offset as usize;
assert_eq!(
&bytes[start..start + s.size as usize],
data.as_slice(),
"sample {i} bytes at its recorded offset"
);
}
}
#[test]
fn variable_durations_survive_the_round_trip() {
let durations = [16_666u32, 16_666, 16_666, 500_000, 16_666];
let frames: Vec<Frame> = durations
.iter()
.enumerate()
.map(|(i, d)| (avcc_frame(32 + i, 0xb0 + i as u8), *d, i == 0))
.collect();
let bytes = write_video_only(&frames);
let track = demux_video(&bytes).unwrap();
let got: Vec<u32> = track.samples.iter().map(|s| s.duration).collect();
assert_eq!(got, durations);
}
#[test]
fn stss_is_omitted_when_every_sample_is_a_keyframe() {
let frames: Vec<Frame> = (0..3u8)
.map(|i| (avcc_frame(16, 0xc0 + i), 16_666, true))
.collect();
let bytes = write_video_only(&frames);
assert!(
!contains_tag(&bytes, b"stss"),
"an all-keyframe track should omit stss; its absence already means \
every sample is a sync sample"
);
let track = demux_video(&bytes).unwrap();
assert!(track.samples.iter().all(|s| s.sync));
}
#[test]
fn stss_lists_only_real_keyframes() {
let sync_flags = [true, false, false, false, true, false];
let frames: Vec<Frame> = sync_flags
.iter()
.enumerate()
.map(|(i, s)| (avcc_frame(16 + i, 0xd0 + i as u8), 16_666, *s))
.collect();
let bytes = write_video_only(&frames);
assert!(contains_tag(&bytes, b"stss"), "a mixed track needs an stss");
let track = demux_video(&bytes).unwrap();
let got: Vec<bool> = track.samples.iter().map(|s| s.sync).collect();
assert_eq!(got, sync_flags);
}
#[test]
fn mdat_length_is_patched_after_the_fact() {
let frames: Vec<Frame> = vec![(avcc_frame(100, 0xe1), 16_666, true)];
let bytes = write_video_only(&frames);
let ftyp_len = u32::from_be_bytes(bytes[0..4].try_into().unwrap()) as usize;
assert_eq!(&bytes[ftyp_len + 4..ftyp_len + 8], b"mdat");
assert_eq!(
u32::from_be_bytes(bytes[ftyp_len..ftyp_len + 4].try_into().unwrap()),
1,
"mdat should use the 64-bit extended size form so it can be patched \
without moving the payload"
);
let largesize = u64::from_be_bytes(bytes[ftyp_len + 8..ftyp_len + 16].try_into().unwrap());
assert_eq!(largesize, 16 + 104, "mdat size must include its own header");
}
#[test]
fn audio_track_is_written_and_interleaved_with_video() {
let cfg = AudioConfig::pcm_s16le(48_000, 2);
assert_eq!(cfg.bytes_per_frame(), 4);
let mut w =
Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), Some(cfg)).unwrap();
for i in 0..4u8 {
w.write_video_sample(&avcc_frame(64, 0xf0 + i), 16_666, i == 0)
.unwrap();
w.write_audio_sample(&vec![i; 480 * 4]).unwrap();
}
let (stats, cursor) = w.finish_with_sink().unwrap();
let bytes = cursor.into_inner();
assert_eq!(stats.video_samples, 4);
assert_eq!(stats.audio_frames, 4 * 480);
assert_eq!(stats.keyframes, 1);
assert!(contains_tag(&bytes, b"sowt"), "missing pcm sample entry");
assert!(contains_tag(&bytes, b"smhd"), "missing sound media header");
assert!(contains_tag(&bytes, b"qt "), "a pcm file brands as qt");
let track = demux_video(&bytes).unwrap();
assert_eq!(track.samples.len(), 4);
for (i, s) in track.samples.iter().enumerate() {
assert_eq!(s.size, 68, "sample {i} size");
let start = s.offset as usize;
assert_eq!(
u32::from_be_bytes(bytes[start..start + 4].try_into().unwrap()),
64,
"sample {i} offset should point at its length prefix"
);
}
}
const ASC: &[u8] = &[0x11, 0x90];
#[test]
fn aac_writes_an_mp4a_entry_with_the_config_inside_it() {
let cfg = AudioConfig::aac(48_000, 2, ASC.to_vec(), 0);
let mut w =
Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), Some(cfg)).unwrap();
for i in 0..4u8 {
w.write_video_sample(&avcc_frame(64, 0xf0 + i), 16_666, i == 0)
.unwrap();
w.write_audio_packet(&vec![i; 180 + i as usize], 1024).unwrap();
}
let (stats, cursor) = w.finish_with_sink().unwrap();
let bytes = cursor.into_inner();
assert_eq!(stats.audio_frames, 4);
assert_eq!(stats.audio_duration_ticks, 4 * 1024);
assert!(contains_tag(&bytes, b"mp4a"), "missing the aac sample entry");
assert!(contains_tag(&bytes, b"esds"), "missing the decoder config");
assert!(!contains_tag(&bytes, b"sowt"), "this is not a pcm track");
assert!(!contains_tag(&bytes, b"qt "), "an aac file must stay isom");
let want = [0x05u8, ASC.len() as u8, ASC[0], ASC[1]];
assert!(
bytes.windows(want.len()).any(|w| w == want),
"the DecoderSpecificInfo should carry the ASC as written"
);
let track = demux_video(&bytes).unwrap();
assert_eq!(track.samples.len(), 4);
}
#[test]
fn an_edit_list_hides_the_encoder_priming() {
let cfg = AudioConfig::aac(48_000, 2, ASC.to_vec(), 2048);
let mut w =
Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), Some(cfg)).unwrap();
w.write_video_sample(&avcc_frame(16, 1), 16_666, true).unwrap();
for _ in 0..8 {
w.write_audio_packet(&[7u8; 128], 1024).unwrap();
}
let bytes = w.finish_with_sink().unwrap().1.into_inner();
assert!(contains_tag(&bytes, b"elst"), "no edit list");
let want: Vec<u8> = {
let mut v = Vec::new();
v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&128u32.to_be_bytes()); v.extend_from_slice(&2048u32.to_be_bytes()); v.extend_from_slice(&0x0001_0000u32.to_be_bytes()); v
};
assert!(
bytes.windows(want.len()).any(|w| w == want),
"the edit list should start the track at the first real sample"
);
}
#[test]
fn no_priming_means_no_edit_list() {
let cfg = AudioConfig::aac(48_000, 2, ASC.to_vec(), 0);
let mut w =
Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), Some(cfg)).unwrap();
w.write_video_sample(&avcc_frame(16, 1), 16_666, true).unwrap();
w.write_audio_packet(&[7u8; 128], 1024).unwrap();
let bytes = w.finish_with_sink().unwrap().1.into_inner();
assert!(!contains_tag(&bytes, b"elst"), "nothing to skip, nothing to say");
}
#[test]
fn aac_packets_keep_their_own_sizes() {
let cfg = AudioConfig::aac(44_100, 1, ASC.to_vec(), 0);
let mut w =
Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), Some(cfg)).unwrap();
w.write_video_sample(&avcc_frame(16, 1), 16_666, true).unwrap();
let packets: [&[u8]; 3] = [&[1u8; 97], &[2u8; 211], &[3u8; 64]];
for p in packets {
w.write_audio_packet(p, 1024).unwrap();
}
let (stats, cursor) = w.finish_with_sink().unwrap();
let bytes = cursor.into_inner();
assert_eq!(stats.audio_frames, 3);
let want: Vec<u8> = {
let mut v = vec![0, 0, 0, 0]; v.extend_from_slice(&3u32.to_be_bytes());
for p in packets {
v.extend_from_slice(&(p.len() as u32).to_be_bytes());
}
v
};
assert!(
bytes.windows(want.len()).any(|w| w == want),
"each packet's own length must reach the sample size table"
);
}
#[test]
fn the_two_codings_refuse_each_other() {
let mut aac =
Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(),
Some(AudioConfig::aac(48_000, 2, ASC.to_vec(), 0))).unwrap();
assert!(aac.write_audio_sample(&[0; 16]).is_err(), "pcm into an aac track");
let mut pcm =
Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(),
Some(AudioConfig::pcm_s16le(48_000, 2))).unwrap();
assert!(pcm.write_audio_packet(&[0; 16], 1024).is_err(), "a packet into pcm");
}
#[test]
fn descriptor_lengths_use_the_base_128_form() {
assert_eq!(descriptor(0x05, &[0xaa, 0xbb]), vec![0x05, 0x02, 0xaa, 0xbb]);
let long = vec![0u8; 200];
let d = descriptor(0x04, &long);
assert_eq!(&d[..3], &[0x04, 0x81, 0x48], "200 is 0x81 0x48 in base 128");
assert_eq!(d.len(), 3 + 200);
}
#[test]
fn partial_pcm_frames_are_carried_rather_than_dropped() {
let cfg = AudioConfig::pcm_s16le(48_000, 2);
let mut w =
Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), Some(cfg)).unwrap();
w.write_video_sample(&avcc_frame(16, 1), 16_666, true)
.unwrap();
w.write_audio_sample(&[1, 2, 3, 4, 5, 6]).unwrap();
w.write_audio_sample(&[7, 8]).unwrap();
let stats = w.finish().unwrap();
assert_eq!(stats.audio_frames, 2, "the split frame must not be lost");
assert_eq!(stats.audio_duration_ticks, 2);
}
#[test]
fn a_capture_with_no_samples_still_produces_a_parsable_file() {
let w = Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), None).unwrap();
let bytes = w.finish_with_sink().unwrap().1.into_inner();
assert!(contains_tag(&bytes, b"moov"));
assert!(contains_tag(&bytes, b"avcC"));
}
}