1use std::io::{self, Seek, SeekFrom, Write};
53
54use super::mp4::{bx, concat, fullbox, UNITY_MATRIX};
55
56const MOVIE_TIMESCALE: u32 = 1000;
58
59#[derive(Clone)]
61pub struct VideoConfig {
62 pub width: u32,
64 pub height: u32,
66 pub timescale: u32,
69 pub avcc: Vec<u8>,
72}
73
74#[derive(Clone, PartialEq, Eq)]
82pub enum AudioCoding {
83 PcmS16le,
86 Aac {
94 asc: Vec<u8>,
96 },
97}
98
99#[derive(Clone)]
101pub struct AudioConfig {
102 pub sample_rate: u32,
104 pub channels: u16,
106 pub bits_per_sample: u16,
108 pub coding: AudioCoding,
110 pub encoder_delay: u32,
119}
120
121impl AudioConfig {
122 pub fn pcm_s16le(sample_rate: u32, channels: u16) -> Self {
124 AudioConfig {
125 sample_rate,
126 channels,
127 bits_per_sample: 16,
128 coding: AudioCoding::PcmS16le,
129 encoder_delay: 0, }
131 }
132
133 pub fn aac(sample_rate: u32, channels: u16, asc: Vec<u8>, encoder_delay: u32) -> Self {
138 AudioConfig {
139 sample_rate,
140 channels,
141 bits_per_sample: 16,
142 coding: AudioCoding::Aac { asc },
143 encoder_delay,
144 }
145 }
146
147 pub fn bytes_per_frame(&self) -> usize {
150 usize::from(self.channels) * usize::from(self.bits_per_sample / 8)
151 }
152
153 fn is_pcm(&self) -> bool {
154 self.coding == AudioCoding::PcmS16le
155 }
156}
157
158fn descriptor(tag: u8, payload: &[u8]) -> Vec<u8> {
161 let mut v = vec![tag];
162 let mut len = payload.len();
163 let mut groups = Vec::new();
166 loop {
167 groups.push((len & 0x7f) as u8);
168 len >>= 7;
169 if len == 0 {
170 break;
171 }
172 }
173 for (i, g) in groups.iter().enumerate().rev() {
174 v.push(if i == 0 { *g } else { *g | 0x80 });
175 }
176 v.extend_from_slice(payload);
177 v
178}
179
180#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
182pub struct Mp4StreamStats {
183 pub video_samples: u32,
185 pub audio_frames: u32,
187 pub keyframes: u32,
189 pub media_bytes: u64,
191 pub video_duration_ticks: u64,
193 pub audio_duration_ticks: u64,
195}
196
197#[derive(Clone, Copy, PartialEq, Eq)]
198enum Kind {
199 Video,
200 Audio,
201}
202
203#[derive(Default)]
206struct Track {
207 sizes: Vec<u32>,
209 durations: Vec<(u32, u32)>,
211 sync: Vec<u32>,
214 all_sync: bool,
215 chunks: Vec<(u64, u32)>,
217 samples: u32,
218 duration: u64,
219}
220
221impl Track {
222 fn new() -> Self {
223 Track {
224 all_sync: true,
225 ..Default::default()
226 }
227 }
228
229 fn add_duration(&mut self, d: u32) {
230 match self.durations.last_mut() {
231 Some((count, delta)) if *delta == d => *count += 1,
232 _ => self.durations.push((1, d)),
233 }
234 self.duration += u64::from(d);
235 }
236
237 fn add_chunk(&mut self, offset: u64, n: u32, contiguous: bool) {
240 if contiguous && let Some(last) = self.chunks.last_mut() {
241 last.1 += n;
242 return;
243 }
244 self.chunks.push((offset, n));
245 }
246
247 fn mark_sync(&mut self, sample: u32, sync: bool) {
248 if sync {
249 self.sync.push(sample);
250 } else {
251 self.all_sync = false;
252 }
253 }
254
255 fn sync_sample_table(&self) -> Option<Vec<u8>> {
258 if self.all_sync {
259 return None;
260 }
261 Some(fullbox(b"stss", 0, 0, &{
262 let mut v = Vec::with_capacity(4 + self.sync.len() * 4);
263 v.extend_from_slice(&(self.sync.len() as u32).to_be_bytes());
264 for s in &self.sync {
265 v.extend_from_slice(&s.to_be_bytes());
266 }
267 v
268 }))
269 }
270
271 fn time_to_sample(&self) -> Vec<u8> {
272 fullbox(b"stts", 0, 0, &{
273 let mut v = Vec::with_capacity(4 + self.durations.len() * 8);
274 v.extend_from_slice(&(self.durations.len() as u32).to_be_bytes());
275 for (count, delta) in &self.durations {
276 v.extend_from_slice(&count.to_be_bytes());
277 v.extend_from_slice(&delta.to_be_bytes());
278 }
279 v
280 })
281 }
282
283 fn sample_size(&self, constant_size: Option<u32>) -> Vec<u8> {
285 fullbox(b"stsz", 0, 0, &{
286 let mut v = Vec::new();
287 match constant_size {
288 Some(size) => {
289 v.extend_from_slice(&size.to_be_bytes());
290 v.extend_from_slice(&self.samples.to_be_bytes());
291 }
292 None => {
293 v.extend_from_slice(&0u32.to_be_bytes());
294 v.extend_from_slice(&(self.sizes.len() as u32).to_be_bytes());
295 for s in &self.sizes {
296 v.extend_from_slice(&s.to_be_bytes());
297 }
298 }
299 }
300 v
301 })
302 }
303
304 fn sample_to_chunk(&self) -> Vec<u8> {
306 let mut entries: Vec<(u32, u32)> = Vec::new(); for (i, (_, n)) in self.chunks.iter().enumerate() {
308 let first_chunk = (i + 1) as u32;
309 match entries.last() {
310 Some((_, prev)) if prev == n => {}
311 _ => entries.push((first_chunk, *n)),
312 }
313 }
314 fullbox(b"stsc", 0, 0, &{
315 let mut v = Vec::with_capacity(4 + entries.len() * 12);
316 v.extend_from_slice(&(entries.len() as u32).to_be_bytes());
317 for (first, per) in &entries {
318 v.extend_from_slice(&first.to_be_bytes());
319 v.extend_from_slice(&per.to_be_bytes());
320 v.extend_from_slice(&1u32.to_be_bytes()); }
322 v
323 })
324 }
325
326 fn chunk_offsets(&self) -> Vec<u8> {
328 let needs_64 = self
329 .chunks
330 .iter()
331 .any(|(off, _)| *off > u64::from(u32::MAX));
332 if needs_64 {
333 fullbox(b"co64", 0, 0, &{
334 let mut v = Vec::with_capacity(4 + self.chunks.len() * 8);
335 v.extend_from_slice(&(self.chunks.len() as u32).to_be_bytes());
336 for (off, _) in &self.chunks {
337 v.extend_from_slice(&off.to_be_bytes());
338 }
339 v
340 })
341 } else {
342 fullbox(b"stco", 0, 0, &{
343 let mut v = Vec::with_capacity(4 + self.chunks.len() * 4);
344 v.extend_from_slice(&(self.chunks.len() as u32).to_be_bytes());
345 for (off, _) in &self.chunks {
346 v.extend_from_slice(&(*off as u32).to_be_bytes());
347 }
348 v
349 })
350 }
351 }
352}
353
354pub struct Mp4StreamWriter<W: Write + Seek> {
356 out: W,
357 video_cfg: VideoConfig,
358 audio_cfg: Option<AudioConfig>,
359 video: Track,
360 audio: Track,
361 mdat_header_offset: u64,
363 payload_start: u64,
365 payload_len: u64,
366 last_kind: Option<Kind>,
367 keyframes: u32,
368 pcm_remainder: Vec<u8>,
370 finished: bool,
371}
372
373impl<W: Write + Seek> Mp4StreamWriter<W> {
374 pub fn new(mut out: W, video: VideoConfig, audio: Option<AudioConfig>) -> io::Result<Self> {
378 assert!(video.timescale > 0, "video timescale must be non-zero");
379
380 let ftyp = if audio.as_ref().is_some_and(AudioConfig::is_pcm) {
387 bx(b"ftyp", &{
388 let mut v = Vec::new();
389 v.extend_from_slice(b"qt ");
390 v.extend_from_slice(&0x0000_0200u32.to_be_bytes()); v.extend_from_slice(b"qt ");
392 v
393 })
394 } else {
395 bx(b"ftyp", &{
396 let mut v = Vec::new();
397 v.extend_from_slice(b"isom");
398 v.extend_from_slice(&0u32.to_be_bytes());
399 for brand in [b"isom", b"iso2", b"avc1", b"mp41"] {
400 v.extend_from_slice(brand);
401 }
402 v
403 })
404 };
405 out.write_all(&ftyp)?;
406
407 let mdat_header_offset = ftyp.len() as u64;
411 out.write_all(&1u32.to_be_bytes())?; out.write_all(b"mdat")?;
413 out.write_all(&0u64.to_be_bytes())?; let payload_start = mdat_header_offset + 16;
415
416 Ok(Mp4StreamWriter {
417 out,
418 video_cfg: video,
419 audio_cfg: audio,
420 video: Track::new(),
421 audio: Track::new(),
422 mdat_header_offset,
423 payload_start,
424 payload_len: 0,
425 last_kind: None,
426 keyframes: 0,
427 pcm_remainder: Vec::new(),
428 finished: false,
429 })
430 }
431
432 pub fn write_video_sample(
440 &mut self,
441 sample: &[u8],
442 duration: u32,
443 sync: bool,
444 ) -> io::Result<()> {
445 if sample.is_empty() {
446 return Ok(());
447 }
448 let offset = self.payload_start + self.payload_len;
449 self.out.write_all(sample)?;
450 self.payload_len += sample.len() as u64;
451
452 let contiguous = self.last_kind == Some(Kind::Video);
453 self.video.sizes.push(sample.len() as u32);
454 self.video.samples += 1;
455 self.video.add_duration(duration);
456 self.video.add_chunk(offset, 1, contiguous);
457 self.video.mark_sync(self.video.samples, sync);
458 if sync {
459 self.keyframes += 1;
460 }
461 self.last_kind = Some(Kind::Video);
462 Ok(())
463 }
464
465 pub fn write_audio_sample(&mut self, pcm: &[u8]) -> io::Result<()> {
469 let Some(cfg) = self.audio_cfg.clone() else {
470 return Ok(()); };
472 if !cfg.is_pcm() {
473 return Err(io::Error::new(
474 io::ErrorKind::InvalidInput,
475 "this track is AAC — use write_audio_packet",
476 ));
477 }
478 let frame = cfg.bytes_per_frame();
479 if frame == 0 || pcm.is_empty() && self.pcm_remainder.is_empty() {
480 return Ok(());
481 }
482
483 let joined: &[u8] = if self.pcm_remainder.is_empty() {
486 pcm
487 } else {
488 self.pcm_remainder.extend_from_slice(pcm);
489 &self.pcm_remainder
490 };
491
492 let frames = joined.len() / frame;
493 let usable = frames * frame;
494 if frames == 0 {
495 if self.pcm_remainder.is_empty() {
496 self.pcm_remainder.extend_from_slice(pcm);
497 }
498 return Ok(());
499 }
500
501 let offset = self.payload_start + self.payload_len;
502 self.out.write_all(&joined[..usable])?;
503 self.payload_len += usable as u64;
504 let leftover = joined[usable..].to_vec();
505
506 let contiguous = self.last_kind == Some(Kind::Audio);
507 self.audio.samples += frames as u32;
508 match self.audio.durations.last_mut() {
511 Some((count, delta)) if *delta == 1 => *count += frames as u32,
512 _ => self.audio.durations.push((frames as u32, 1)),
513 }
514 self.audio.duration += frames as u64;
515 self.audio.add_chunk(offset, frames as u32, contiguous);
516
517 self.pcm_remainder = leftover;
518 self.last_kind = Some(Kind::Audio);
519 Ok(())
520 }
521
522 pub fn write_audio_packet(&mut self, packet: &[u8], duration: u32) -> io::Result<()> {
533 let Some(cfg) = self.audio_cfg.as_ref() else {
534 return Ok(()); };
536 if cfg.is_pcm() {
537 return Err(io::Error::new(
538 io::ErrorKind::InvalidInput,
539 "this track is PCM — use write_audio_sample",
540 ));
541 }
542 if packet.is_empty() {
543 return Ok(());
544 }
545
546 let offset = self.payload_start + self.payload_len;
547 self.out.write_all(packet)?;
548 self.payload_len += packet.len() as u64;
549
550 let contiguous = self.last_kind == Some(Kind::Audio);
551 self.audio.sizes.push(packet.len() as u32);
552 self.audio.samples += 1;
553 self.audio.add_duration(duration);
554 self.audio.add_chunk(offset, 1, contiguous);
555 self.last_kind = Some(Kind::Audio);
556 Ok(())
557 }
558
559 pub fn finish(self) -> io::Result<Mp4StreamStats> {
561 self.finish_with_sink().map(|(stats, _)| stats)
562 }
563
564 pub fn finish_with_sink(mut self) -> io::Result<(Mp4StreamStats, W)> {
567 self.finished = true;
568
569 let mdat_total = 16 + self.payload_len;
571 self.out
572 .seek(SeekFrom::Start(self.mdat_header_offset + 8))?;
573 self.out.write_all(&mdat_total.to_be_bytes())?;
574 self.out.seek(SeekFrom::End(0))?;
575
576 let moov = self.build_moov();
577 self.out.write_all(&moov)?;
578 self.out.flush()?;
579
580 let stats = Mp4StreamStats {
581 video_samples: self.video.samples,
582 audio_frames: self.audio.samples,
583 keyframes: self.keyframes,
584 media_bytes: self.payload_len,
585 video_duration_ticks: self.video.duration,
586 audio_duration_ticks: self.audio.duration,
587 };
588 Ok((stats, self.out))
589 }
590
591 fn movie_ticks(duration: u64, timescale: u32) -> u32 {
593 if timescale == 0 {
594 return 0;
595 }
596 (duration.saturating_mul(u64::from(MOVIE_TIMESCALE)) / u64::from(timescale)) as u32
597 }
598
599 fn build_moov(&self) -> Vec<u8> {
600 let video_movie_ticks = Self::movie_ticks(self.video.duration, self.video_cfg.timescale);
601 let audio_movie_ticks = self
602 .audio_cfg
603 .as_ref()
604 .map(|c| Self::movie_ticks(self.audio.duration, c.sample_rate))
605 .unwrap_or(0);
606 let movie_duration = video_movie_ticks.max(audio_movie_ticks);
607
608 let video_trak = self.build_video_trak(video_movie_ticks);
609 let audio_trak = self
610 .audio_cfg
611 .as_ref()
612 .map(|c| self.build_audio_trak(c, audio_movie_ticks));
613 let next_track_id = if audio_trak.is_some() { 3u32 } else { 2 };
614
615 let mvhd = fullbox(b"mvhd", 0, 0, &{
616 let mut v = Vec::new();
617 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());
620 v.extend_from_slice(&movie_duration.to_be_bytes());
621 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);
626 v.extend_from_slice(&[0u8; 24]); v.extend_from_slice(&next_track_id.to_be_bytes());
628 v
629 });
630
631 let mut children = vec![mvhd, video_trak];
632 children.extend(audio_trak);
633 bx(b"moov", &concat(&children))
634 }
635
636 fn build_video_trak(&self, movie_ticks: u32) -> Vec<u8> {
637 let cfg = &self.video_cfg;
638
639 let avc1 = bx(b"avc1", &{
640 let mut v = Vec::new();
641 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());
645 v.extend_from_slice(&(cfg.height as u16).to_be_bytes());
646 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));
654 v
655 });
656 let stsd = fullbox(b"stsd", 0, 0, &{
657 let mut v = Vec::new();
658 v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&avc1);
660 v
661 });
662
663 let mut stbl_children = vec![stsd, self.video.time_to_sample()];
664 stbl_children.extend(self.video.sync_sample_table());
665 stbl_children.push(self.video.sample_to_chunk());
666 stbl_children.push(self.video.sample_size(None));
667 stbl_children.push(self.video.chunk_offsets());
668 let stbl = bx(b"stbl", &concat(&stbl_children));
669
670 let vmhd = fullbox(b"vmhd", 0, 1, &[0u8; 8]);
671 let minf = bx(
672 b"minf",
673 &concat(&[vmhd, handler(b"vide"), data_information(), stbl]),
674 );
675 let mdia = bx(
676 b"mdia",
677 &concat(&[
678 media_header(cfg.timescale, self.video.duration),
679 handler(b"vide"),
680 minf,
681 ]),
682 );
683
684 let tkhd = fullbox(b"tkhd", 0, 7, &{
685 let mut v = Vec::new();
686 v.extend_from_slice(&0u32.to_be_bytes());
687 v.extend_from_slice(&0u32.to_be_bytes());
688 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());
691 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);
697 v.extend_from_slice(&(cfg.width << 16).to_be_bytes());
698 v.extend_from_slice(&(cfg.height << 16).to_be_bytes());
699 v
700 });
701 bx(b"trak", &concat(&[tkhd, mdia]))
702 }
703
704 fn build_audio_trak(&self, cfg: &AudioConfig, movie_ticks: u32) -> Vec<u8> {
705 let mut entry = Vec::new();
709 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());
715 entry.extend_from_slice(&cfg.bits_per_sample.to_be_bytes());
716 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());
720
721 let sample_entry = match &cfg.coding {
722 AudioCoding::PcmS16le => bx(b"sowt", &entry),
726 AudioCoding::Aac { asc } => {
732 let dec_specific = descriptor(0x05, asc);
733 let dec_config = descriptor(0x04, &{
734 let mut v = Vec::new();
735 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);
741 v
742 });
743 let sl_config = descriptor(0x06, &[0x02]);
746 let es = descriptor(0x03, &{
747 let mut v = Vec::new();
748 v.extend_from_slice(&1u16.to_be_bytes()); v.push(0x00); v.extend_from_slice(&dec_config);
751 v.extend_from_slice(&sl_config);
752 v
753 });
754 entry.extend_from_slice(&fullbox(b"esds", 0, 0, &es));
755 bx(b"mp4a", &entry)
756 }
757 };
758 let stsd = fullbox(b"stsd", 0, 0, &{
759 let mut v = Vec::new();
760 v.extend_from_slice(&1u32.to_be_bytes());
761 v.extend_from_slice(&sample_entry);
762 v
763 });
764
765 let constant_size = cfg.is_pcm().then(|| cfg.bytes_per_frame() as u32);
768 let stbl = bx(
769 b"stbl",
770 &concat(&[
771 stsd,
772 self.audio.time_to_sample(),
773 self.audio.sample_to_chunk(),
774 self.audio.sample_size(constant_size),
775 self.audio.chunk_offsets(),
776 ]),
777 );
778
779 let smhd = fullbox(b"smhd", 0, 0, &[0u8; 4]); let minf = bx(
781 b"minf",
782 &concat(&[smhd, handler(b"soun"), data_information(), stbl]),
783 );
784 let mdia = bx(
785 b"mdia",
786 &concat(&[
787 media_header(cfg.sample_rate, self.audio.duration),
788 handler(b"soun"),
789 minf,
790 ]),
791 );
792
793 let edts = if cfg.encoder_delay > 0 && self.audio.duration > u64::from(cfg.encoder_delay) {
797 let media = self.audio.duration - u64::from(cfg.encoder_delay);
798 let elst = fullbox(b"elst", 0, 0, &{
799 let mut v = Vec::new();
800 v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&Self::movie_ticks(media, cfg.sample_rate).to_be_bytes());
802 v.extend_from_slice(&cfg.encoder_delay.to_be_bytes()); v.extend_from_slice(&0x0001_0000u32.to_be_bytes()); v
805 });
806 Some(bx(b"edts", &elst))
807 } else {
808 None
809 };
810
811 let tkhd = fullbox(b"tkhd", 0, 7, &{
812 let mut v = Vec::new();
813 v.extend_from_slice(&0u32.to_be_bytes());
814 v.extend_from_slice(&0u32.to_be_bytes());
815 v.extend_from_slice(&2u32.to_be_bytes()); v.extend_from_slice(&0u32.to_be_bytes());
817 v.extend_from_slice(&movie_ticks.to_be_bytes());
818 v.extend_from_slice(&[0u8; 8]);
819 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);
824 v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&0u32.to_be_bytes()); v
827 });
828 let mut parts = vec![tkhd];
829 parts.extend(edts);
830 parts.push(mdia);
831 bx(b"trak", &concat(&parts))
832 }
833}
834
835fn media_header(timescale: u32, duration: u64) -> Vec<u8> {
836 fullbox(b"mdhd", 0, 0, &{
837 let mut v = Vec::new();
838 v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(×cale.to_be_bytes());
841 v.extend_from_slice(&(duration.min(u64::from(u32::MAX)) as u32).to_be_bytes());
842 v.extend_from_slice(&0x55c4u16.to_be_bytes()); v.extend_from_slice(&0u16.to_be_bytes()); v
845 })
846}
847
848fn handler(kind: &[u8; 4]) -> Vec<u8> {
849 fullbox(b"hdlr", 0, 0, &{
850 let mut v = Vec::new();
851 v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(kind);
853 v.extend_from_slice(&[0u8; 12]); v.extend_from_slice(b"threers\0");
855 v
856 })
857}
858
859fn data_information() -> Vec<u8> {
860 let dref = fullbox(b"dref", 0, 0, &{
861 let mut v = Vec::new();
862 v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&fullbox(b"url ", 0, 1, &[])); v
865 });
866 bx(b"dinf", &dref)
867}
868
869#[cfg(test)]
870mod tests {
871 use super::*;
872 use crate::mp4_demux::demux_video;
873 use std::io::Cursor;
874
875 const SPS: &[u8] = &[
877 0x27, 0x64, 0x00, 0x33, 0xac, 0x56, 0x80, 0x47, 0x01, 0x33, 0xe6, 0x9e, 0x6e, 0x04, 0x04,
878 0x04, 0x04,
879 ];
880 const PPS: &[u8] = &[0x28, 0xee, 0x3c, 0xb0];
881
882 fn video_config() -> VideoConfig {
883 VideoConfig {
884 width: 1126,
885 height: 2436,
886 timescale: 1_000_000,
887 avcc: crate::h264::avcc::build_avcc(SPS, PPS),
888 }
889 }
890
891 fn avcc_frame(n: usize, fill: u8) -> Vec<u8> {
893 let mut v = Vec::with_capacity(4 + n);
894 v.extend_from_slice(&(n as u32).to_be_bytes());
895 v.extend(std::iter::repeat_n(fill, n));
896 v
897 }
898
899 fn contains_tag(data: &[u8], tag: &[u8; 4]) -> bool {
900 data.windows(4).any(|w| w == tag)
901 }
902
903 type Frame = (Vec<u8>, u32, bool);
904
905 fn write_video_only(frames: &[Frame]) -> Vec<u8> {
906 let mut w = Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), None).unwrap();
907 for (data, dur, sync) in frames {
908 w.write_video_sample(data, *dur, *sync).unwrap();
909 }
910 w.finish_with_sink().unwrap().1.into_inner()
911 }
912
913 #[test]
914 fn roundtrips_through_the_demuxer() {
915 let frames: Vec<Frame> = vec![
916 (avcc_frame(120, 0xa1), 16_666, true),
917 (avcc_frame(40, 0xa2), 16_666, false),
918 (avcc_frame(55, 0xa3), 33_333, false),
919 (avcc_frame(200, 0xa4), 16_666, true),
920 (avcc_frame(30, 0xa5), 16_666, false),
921 ];
922 let bytes = write_video_only(&frames);
923
924 let track = demux_video(&bytes).expect("demux");
925 assert_eq!((track.width, track.height), (1126, 2436));
926 assert_eq!(track.timescale, 1_000_000);
927 assert_eq!(track.config, crate::h264::avcc::build_avcc(SPS, PPS));
928 assert_eq!(track.samples.len(), frames.len());
929
930 for (i, (data, dur, sync)) in frames.iter().enumerate() {
931 let s = &track.samples[i];
932 assert_eq!(s.size as usize, data.len(), "sample {i} size");
933 assert_eq!(s.duration, *dur, "sample {i} duration");
934 assert_eq!(s.sync, *sync, "sample {i} sync flag");
935 let start = s.offset as usize;
936 assert_eq!(
937 &bytes[start..start + s.size as usize],
938 data.as_slice(),
939 "sample {i} bytes at its recorded offset"
940 );
941 }
942 }
943
944 #[test]
945 fn variable_durations_survive_the_round_trip() {
946 let durations = [16_666u32, 16_666, 16_666, 500_000, 16_666];
950 let frames: Vec<Frame> = durations
951 .iter()
952 .enumerate()
953 .map(|(i, d)| (avcc_frame(32 + i, 0xb0 + i as u8), *d, i == 0))
954 .collect();
955 let bytes = write_video_only(&frames);
956 let track = demux_video(&bytes).unwrap();
957 let got: Vec<u32> = track.samples.iter().map(|s| s.duration).collect();
958 assert_eq!(got, durations);
959 }
960
961 #[test]
962 fn stss_is_omitted_when_every_sample_is_a_keyframe() {
963 let frames: Vec<Frame> = (0..3u8)
964 .map(|i| (avcc_frame(16, 0xc0 + i), 16_666, true))
965 .collect();
966 let bytes = write_video_only(&frames);
967 assert!(
968 !contains_tag(&bytes, b"stss"),
969 "an all-keyframe track should omit stss; its absence already means \
970 every sample is a sync sample"
971 );
972 let track = demux_video(&bytes).unwrap();
973 assert!(track.samples.iter().all(|s| s.sync));
974 }
975
976 #[test]
977 fn stss_lists_only_real_keyframes() {
978 let sync_flags = [true, false, false, false, true, false];
981 let frames: Vec<Frame> = sync_flags
982 .iter()
983 .enumerate()
984 .map(|(i, s)| (avcc_frame(16 + i, 0xd0 + i as u8), 16_666, *s))
985 .collect();
986 let bytes = write_video_only(&frames);
987 assert!(contains_tag(&bytes, b"stss"), "a mixed track needs an stss");
988 let track = demux_video(&bytes).unwrap();
989 let got: Vec<bool> = track.samples.iter().map(|s| s.sync).collect();
990 assert_eq!(got, sync_flags);
991 }
992
993 #[test]
994 fn mdat_length_is_patched_after_the_fact() {
995 let frames: Vec<Frame> = vec![(avcc_frame(100, 0xe1), 16_666, true)];
996 let bytes = write_video_only(&frames);
997
998 let ftyp_len = u32::from_be_bytes(bytes[0..4].try_into().unwrap()) as usize;
999 assert_eq!(&bytes[ftyp_len + 4..ftyp_len + 8], b"mdat");
1000 assert_eq!(
1001 u32::from_be_bytes(bytes[ftyp_len..ftyp_len + 4].try_into().unwrap()),
1002 1,
1003 "mdat should use the 64-bit extended size form so it can be patched \
1004 without moving the payload"
1005 );
1006 let largesize = u64::from_be_bytes(bytes[ftyp_len + 8..ftyp_len + 16].try_into().unwrap());
1007 assert_eq!(largesize, 16 + 104, "mdat size must include its own header");
1008 }
1009
1010 #[test]
1011 fn audio_track_is_written_and_interleaved_with_video() {
1012 let cfg = AudioConfig::pcm_s16le(48_000, 2);
1013 assert_eq!(cfg.bytes_per_frame(), 4);
1014
1015 let mut w =
1016 Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), Some(cfg)).unwrap();
1017 for i in 0..4u8 {
1018 w.write_video_sample(&avcc_frame(64, 0xf0 + i), 16_666, i == 0)
1019 .unwrap();
1020 w.write_audio_sample(&vec![i; 480 * 4]).unwrap();
1022 }
1023 let (stats, cursor) = w.finish_with_sink().unwrap();
1024 let bytes = cursor.into_inner();
1025
1026 assert_eq!(stats.video_samples, 4);
1027 assert_eq!(stats.audio_frames, 4 * 480);
1028 assert_eq!(stats.keyframes, 1);
1029
1030 assert!(contains_tag(&bytes, b"sowt"), "missing pcm sample entry");
1031 assert!(contains_tag(&bytes, b"smhd"), "missing sound media header");
1032 assert!(contains_tag(&bytes, b"qt "), "a pcm file brands as qt");
1033
1034 let track = demux_video(&bytes).unwrap();
1037 assert_eq!(track.samples.len(), 4);
1038 for (i, s) in track.samples.iter().enumerate() {
1039 assert_eq!(s.size, 68, "sample {i} size");
1040 let start = s.offset as usize;
1041 assert_eq!(
1042 u32::from_be_bytes(bytes[start..start + 4].try_into().unwrap()),
1043 64,
1044 "sample {i} offset should point at its length prefix"
1045 );
1046 }
1047 }
1048
1049 const ASC: &[u8] = &[0x11, 0x90];
1051
1052 #[test]
1053 fn aac_writes_an_mp4a_entry_with_the_config_inside_it() {
1054 let cfg = AudioConfig::aac(48_000, 2, ASC.to_vec(), 0);
1055 let mut w =
1056 Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), Some(cfg)).unwrap();
1057 for i in 0..4u8 {
1058 w.write_video_sample(&avcc_frame(64, 0xf0 + i), 16_666, i == 0)
1059 .unwrap();
1060 w.write_audio_packet(&vec![i; 180 + i as usize], 1024)
1062 .unwrap();
1063 }
1064 let (stats, cursor) = w.finish_with_sink().unwrap();
1065 let bytes = cursor.into_inner();
1066
1067 assert_eq!(stats.audio_frames, 4);
1068 assert_eq!(stats.audio_duration_ticks, 4 * 1024);
1069
1070 assert!(
1071 contains_tag(&bytes, b"mp4a"),
1072 "missing the aac sample entry"
1073 );
1074 assert!(contains_tag(&bytes, b"esds"), "missing the decoder config");
1075 assert!(!contains_tag(&bytes, b"sowt"), "this is not a pcm track");
1076 assert!(!contains_tag(&bytes, b"qt "), "an aac file must stay isom");
1079
1080 let want = [0x05u8, ASC.len() as u8, ASC[0], ASC[1]];
1084 assert!(
1085 bytes.windows(want.len()).any(|w| w == want),
1086 "the DecoderSpecificInfo should carry the ASC as written"
1087 );
1088
1089 let track = demux_video(&bytes).unwrap();
1091 assert_eq!(track.samples.len(), 4);
1092 }
1093
1094 #[test]
1095 fn an_edit_list_hides_the_encoder_priming() {
1096 let cfg = AudioConfig::aac(48_000, 2, ASC.to_vec(), 2048);
1101 let mut w =
1102 Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), Some(cfg)).unwrap();
1103 w.write_video_sample(&avcc_frame(16, 1), 16_666, true)
1104 .unwrap();
1105 for _ in 0..8 {
1106 w.write_audio_packet(&[7u8; 128], 1024).unwrap();
1107 }
1108 let bytes = w.finish_with_sink().unwrap().1.into_inner();
1109
1110 assert!(contains_tag(&bytes, b"elst"), "no edit list");
1111 let want: Vec<u8> = {
1114 let mut v = Vec::new();
1115 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
1120 };
1121 assert!(
1122 bytes.windows(want.len()).any(|w| w == want),
1123 "the edit list should start the track at the first real sample"
1124 );
1125 }
1126
1127 #[test]
1128 fn no_priming_means_no_edit_list() {
1129 let cfg = AudioConfig::aac(48_000, 2, ASC.to_vec(), 0);
1132 let mut w =
1133 Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), Some(cfg)).unwrap();
1134 w.write_video_sample(&avcc_frame(16, 1), 16_666, true)
1135 .unwrap();
1136 w.write_audio_packet(&[7u8; 128], 1024).unwrap();
1137 let bytes = w.finish_with_sink().unwrap().1.into_inner();
1138 assert!(
1139 !contains_tag(&bytes, b"elst"),
1140 "nothing to skip, nothing to say"
1141 );
1142 }
1143
1144 #[test]
1145 fn aac_packets_keep_their_own_sizes() {
1146 let cfg = AudioConfig::aac(44_100, 1, ASC.to_vec(), 0);
1150 let mut w =
1151 Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), Some(cfg)).unwrap();
1152 w.write_video_sample(&avcc_frame(16, 1), 16_666, true)
1153 .unwrap();
1154 let packets: [&[u8]; 3] = [&[1u8; 97], &[2u8; 211], &[3u8; 64]];
1155 for p in packets {
1156 w.write_audio_packet(p, 1024).unwrap();
1157 }
1158 let (stats, cursor) = w.finish_with_sink().unwrap();
1159 let bytes = cursor.into_inner();
1160 assert_eq!(stats.audio_frames, 3);
1161
1162 let want: Vec<u8> = {
1164 let mut v = vec![0, 0, 0, 0]; v.extend_from_slice(&3u32.to_be_bytes());
1166 for p in packets {
1167 v.extend_from_slice(&(p.len() as u32).to_be_bytes());
1168 }
1169 v
1170 };
1171 assert!(
1172 bytes.windows(want.len()).any(|w| w == want),
1173 "each packet's own length must reach the sample size table"
1174 );
1175 }
1176
1177 #[test]
1178 fn the_two_codings_refuse_each_other() {
1179 let mut aac = Mp4StreamWriter::new(
1180 Cursor::new(Vec::new()),
1181 video_config(),
1182 Some(AudioConfig::aac(48_000, 2, ASC.to_vec(), 0)),
1183 )
1184 .unwrap();
1185 assert!(
1186 aac.write_audio_sample(&[0; 16]).is_err(),
1187 "pcm into an aac track"
1188 );
1189
1190 let mut pcm = Mp4StreamWriter::new(
1191 Cursor::new(Vec::new()),
1192 video_config(),
1193 Some(AudioConfig::pcm_s16le(48_000, 2)),
1194 )
1195 .unwrap();
1196 assert!(
1197 pcm.write_audio_packet(&[0; 16], 1024).is_err(),
1198 "a packet into pcm"
1199 );
1200 }
1201
1202 #[test]
1203 fn descriptor_lengths_use_the_base_128_form() {
1204 assert_eq!(
1208 descriptor(0x05, &[0xaa, 0xbb]),
1209 vec![0x05, 0x02, 0xaa, 0xbb]
1210 );
1211 let long = vec![0u8; 200];
1212 let d = descriptor(0x04, &long);
1213 assert_eq!(&d[..3], &[0x04, 0x81, 0x48], "200 is 0x81 0x48 in base 128");
1214 assert_eq!(d.len(), 3 + 200);
1215 }
1216
1217 #[test]
1218 fn partial_pcm_frames_are_carried_rather_than_dropped() {
1219 let cfg = AudioConfig::pcm_s16le(48_000, 2);
1220 let mut w =
1221 Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), Some(cfg)).unwrap();
1222 w.write_video_sample(&avcc_frame(16, 1), 16_666, true)
1223 .unwrap();
1224 w.write_audio_sample(&[1, 2, 3, 4, 5, 6]).unwrap();
1226 w.write_audio_sample(&[7, 8]).unwrap();
1228 let stats = w.finish().unwrap();
1229 assert_eq!(stats.audio_frames, 2, "the split frame must not be lost");
1230 assert_eq!(stats.audio_duration_ticks, 2);
1231 }
1232
1233 #[test]
1234 fn a_capture_with_no_samples_still_produces_a_parsable_file() {
1235 let w = Mp4StreamWriter::new(Cursor::new(Vec::new()), video_config(), None).unwrap();
1236 let bytes = w.finish_with_sink().unwrap().1.into_inner();
1237 assert!(contains_tag(&bytes, b"moov"));
1238 assert!(contains_tag(&bytes, b"avcC"));
1239 }
1240}