1use crate::captions::CaptionTrack;
19
20pub(crate) fn bx(type_: &[u8; 4], payload: &[u8]) -> Vec<u8> {
25 let total = 8u64 + payload.len() as u64;
26 if total > u32::MAX as u64 {
27 let largesize = 16u64 + payload.len() as u64;
28 let mut v = Vec::with_capacity(largesize as usize);
29 v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(type_);
31 v.extend_from_slice(&largesize.to_be_bytes());
32 v.extend_from_slice(payload);
33 v
34 } else {
35 let mut v = Vec::with_capacity(total as usize);
36 v.extend_from_slice(&(total as u32).to_be_bytes());
37 v.extend_from_slice(type_);
38 v.extend_from_slice(payload);
39 v
40 }
41}
42
43#[cfg(test)]
46fn box_header_len(box_bytes: &[u8]) -> usize {
47 if box_bytes.len() >= 8 && u32::from_be_bytes(box_bytes[0..4].try_into().unwrap()) == 1 {
48 16
49 } else {
50 8
51 }
52}
53
54pub(crate) fn fullbox(type_: &[u8; 4], version: u8, flags: u32, payload: &[u8]) -> Vec<u8> {
56 let mut p = Vec::with_capacity(4 + payload.len());
57 p.push(version);
58 p.extend_from_slice(&flags.to_be_bytes()[1..]);
59 p.extend_from_slice(payload);
60 bx(type_, &p)
61}
62
63pub(crate) fn concat(parts: &[Vec<u8>]) -> Vec<u8> {
64 let mut v = Vec::new();
65 for p in parts {
66 v.extend_from_slice(p);
67 }
68 v
69}
70
71struct CommonMp4Params<'a> {
73 pub width: u32,
74 pub height: u32,
75 pub timescale: u32,
76 pub frame_duration: u32,
77 pub samples: &'a [Vec<u8>],
78}
79
80pub struct Mp4Params<'a> {
82 pub width: u32,
84 pub height: u32,
86 pub timescale: u32,
88 pub frame_duration: u32,
90 pub hvcc_payload: &'a [u8],
93 pub almo_payload: Option<&'a [u8]>,
96 pub samples: &'a [Vec<u8>],
99}
100
101pub struct H264Mp4Params<'a> {
103 pub width: u32,
105 pub height: u32,
107 pub timescale: u32,
109 pub frame_duration: u32,
111 pub avcc_payload: &'a [u8],
114 pub samples: &'a [Vec<u8>],
117}
118
119impl<'a> From<&Mp4Params<'a>> for CommonMp4Params<'a> {
120 fn from(p: &Mp4Params<'a>) -> Self {
121 Self {
122 width: p.width,
123 height: p.height,
124 timescale: p.timescale,
125 frame_duration: p.frame_duration,
126 samples: p.samples,
127 }
128 }
129}
130
131impl<'a> From<&H264Mp4Params<'a>> for CommonMp4Params<'a> {
132 fn from(p: &H264Mp4Params<'a>) -> Self {
133 Self {
134 width: p.width,
135 height: p.height,
136 timescale: p.timescale,
137 frame_duration: p.frame_duration,
138 samples: p.samples,
139 }
140 }
141}
142
143pub fn mux_hevc(p: &Mp4Params) -> Vec<u8> {
145 mux_hevc_internal(p, None)
146}
147
148pub fn mux_hevc_with_captions(p: &Mp4Params, captions: &CaptionTrack) -> Vec<u8> {
170 mux_hevc_internal(p, Some(captions))
171}
172
173pub fn mux_h264(p: &H264Mp4Params) -> Vec<u8> {
175 mux_h264_internal(p, None)
176}
177
178pub fn write_h264<W: std::io::Write>(
181 out: &mut W,
182 p: &H264Mp4Params,
183 captions: Option<&CaptionTrack>,
184) -> std::io::Result<()> {
185 let common = CommonMp4Params::from(p);
186 let stsd = build_h264_stsd(p);
187 mux_common_to(
188 out,
189 &common,
190 &[b"isom", b"iso2", b"avc1", b"mp41"],
191 stsd,
192 captions,
193 )
194}
195
196pub fn write_hevc<W: std::io::Write>(
198 out: &mut W,
199 p: &Mp4Params,
200 captions: Option<&CaptionTrack>,
201) -> std::io::Result<()> {
202 let common = CommonMp4Params::from(p);
203 let stsd = build_hevc_stsd(p);
204 mux_common_to(
205 out,
206 &common,
207 &[b"isom", b"iso2", b"mp41", b"hvc1"],
208 stsd,
209 captions,
210 )
211}
212
213pub fn mux_h264_with_captions(p: &H264Mp4Params, captions: &CaptionTrack) -> Vec<u8> {
216 mux_h264_internal(p, Some(captions))
217}
218
219fn mux_hevc_internal(p: &Mp4Params, captions: Option<&CaptionTrack>) -> Vec<u8> {
220 let common = CommonMp4Params::from(p);
221 let stsd = build_hevc_stsd(p);
222 mux_common(
223 &common,
224 &[b"isom", b"iso2", b"mp41", b"hvc1"],
225 stsd,
226 captions,
227 )
228}
229
230fn mux_h264_internal(p: &H264Mp4Params, captions: Option<&CaptionTrack>) -> Vec<u8> {
231 let common = CommonMp4Params::from(p);
232 let stsd = build_h264_stsd(p);
233 mux_common(
234 &common,
235 &[b"isom", b"iso2", b"mp41", b"avc1"],
236 stsd,
237 captions,
238 )
239}
240
241fn colr_box(stream: Option<StreamColour>) -> Vec<u8> {
262 let c = stream.unwrap_or(StreamColour {
263 primaries: 1,
264 transfer: 1,
265 matrix: 1,
266 full_range: false,
267 });
268 let mut v = Vec::with_capacity(19);
269 v.extend_from_slice(b"nclx");
270 v.extend_from_slice(&c.primaries.to_be_bytes()); v.extend_from_slice(&c.transfer.to_be_bytes()); v.extend_from_slice(&c.matrix.to_be_bytes()); v.push((c.full_range as u8) << 7); bx(b"colr", &v)
275}
276
277#[derive(Debug, Clone, Copy, PartialEq, Eq)]
279struct StreamColour {
280 primaries: u16,
281 transfer: u16,
282 matrix: u16,
283 full_range: bool,
284}
285
286impl StreamColour {
287 fn from_vui(
289 primaries: Option<u32>,
290 transfer: Option<u32>,
291 matrix: Option<u32>,
292 full_range: bool,
293 ) -> Option<Self> {
294 Some(StreamColour {
295 matrix: matrix? as u16,
296 primaries: primaries.unwrap_or(2) as u16,
297 transfer: transfer.unwrap_or(2) as u16,
298 full_range,
299 })
300 }
301
302 fn of_avcc(avcc: &[u8]) -> Option<Self> {
304 let count = *avcc.get(5)? & 31;
305 if count == 0 {
306 return None;
307 }
308 let len = u16::from_be_bytes([*avcc.get(6)?, *avcc.get(7)?]) as usize;
309 let nal = avcc.get(8..8 + len)?;
310 let sps =
311 crate::decode::h264::params::Sps::parse(&crate::decode::bits::unescape(nal.get(1..)?))
312 .ok()?;
313 Self::from_vui(
314 sps.colour_primaries,
315 sps.transfer_characteristics,
316 sps.matrix_coefficients,
317 sps.full_range,
318 )
319 }
320
321 fn of_hvcc(hvcc: &[u8]) -> Option<Self> {
323 let arrays = *hvcc.get(22)? as usize;
324 let mut at = 23;
325 for _ in 0..arrays {
326 let kind = *hvcc.get(at)? & 0x3f;
327 let count = u16::from_be_bytes([*hvcc.get(at + 1)?, *hvcc.get(at + 2)?]) as usize;
328 at += 3;
329 for _ in 0..count {
330 let len = u16::from_be_bytes([*hvcc.get(at)?, *hvcc.get(at + 1)?]) as usize;
331 let nal = hvcc.get(at + 2..at + 2 + len)?;
332 at += 2 + len;
333 let layer = ((nal.first()? & 1) << 5) | (nal.get(1)? >> 3);
334 if kind == 33 && layer == 0 {
335 let rbsp = crate::decode::bits::unescape(nal.get(2..)?);
336 let sps = crate::decode::hevc::params::Sps::parse(&rbsp).ok()?;
337 return Self::from_vui(
338 sps.colour_primaries,
339 sps.transfer_characteristics,
340 sps.matrix_coefficients,
341 sps.full_range,
342 );
343 }
344 }
345 }
346 None
347 }
348}
349
350fn build_hevc_stsd(p: &Mp4Params) -> Vec<u8> {
351 let hvcc = bx(b"hvcC", p.hvcc_payload);
352 let mut sample_entry = Vec::new();
353 sample_entry.extend_from_slice(&[0u8; 6]); sample_entry.extend_from_slice(&1u16.to_be_bytes()); sample_entry.extend_from_slice(&[0u8; 16]); sample_entry.extend_from_slice(&(p.width as u16).to_be_bytes());
357 sample_entry.extend_from_slice(&(p.height as u16).to_be_bytes());
358 sample_entry.extend_from_slice(&0x0048_0000u32.to_be_bytes()); sample_entry.extend_from_slice(&0x0048_0000u32.to_be_bytes()); sample_entry.extend_from_slice(&0u32.to_be_bytes()); sample_entry.extend_from_slice(&1u16.to_be_bytes()); sample_entry.extend_from_slice(&[0u8; 32]); sample_entry.extend_from_slice(&0x0018u16.to_be_bytes()); sample_entry.extend_from_slice(&0xFFFFu16.to_be_bytes()); sample_entry.extend_from_slice(&hvcc);
366 sample_entry.extend_from_slice(&colr_box(StreamColour::of_hvcc(p.hvcc_payload)));
367 if let Some(almo) = p.almo_payload {
368 sample_entry.extend_from_slice(&bx(b"almo", almo));
369 }
370 let hvc1 = bx(b"hvc1", &sample_entry);
371 let mut payload = Vec::new();
372 payload.extend_from_slice(&1u32.to_be_bytes()); payload.extend_from_slice(&hvc1);
374 fullbox(b"stsd", 0, 0, &payload)
375}
376
377fn build_h264_stsd(p: &H264Mp4Params) -> Vec<u8> {
378 let avcc = bx(b"avcC", p.avcc_payload);
379 let mut sample_entry = Vec::new();
380 sample_entry.extend_from_slice(&[0u8; 6]); sample_entry.extend_from_slice(&1u16.to_be_bytes()); sample_entry.extend_from_slice(&[0u8; 16]); sample_entry.extend_from_slice(&(p.width as u16).to_be_bytes());
384 sample_entry.extend_from_slice(&(p.height as u16).to_be_bytes());
385 sample_entry.extend_from_slice(&0x0048_0000u32.to_be_bytes()); sample_entry.extend_from_slice(&0x0048_0000u32.to_be_bytes()); sample_entry.extend_from_slice(&0u32.to_be_bytes()); sample_entry.extend_from_slice(&1u16.to_be_bytes()); sample_entry.extend_from_slice(&[0u8; 32]); sample_entry.extend_from_slice(&0x0018u16.to_be_bytes()); sample_entry.extend_from_slice(&0xFFFFu16.to_be_bytes()); sample_entry.extend_from_slice(&avcc);
393 sample_entry.extend_from_slice(&colr_box(StreamColour::of_avcc(p.avcc_payload)));
394 let avc1 = bx(b"avc1", &sample_entry);
395 let mut payload = Vec::new();
396 payload.extend_from_slice(&1u32.to_be_bytes()); payload.extend_from_slice(&avc1);
398 fullbox(b"stsd", 0, 0, &payload)
399}
400
401fn mux_common(
402 p: &CommonMp4Params,
403 brands: &[&[u8; 4]],
404 stsd: Vec<u8>,
405 captions: Option<&CaptionTrack>,
406) -> Vec<u8> {
407 let mut out = Vec::new();
408 mux_common_to(&mut out, p, brands, stsd, captions).expect("writing to a Vec cannot fail");
410 out
411}
412
413fn mux_common_to<W: std::io::Write>(
419 out: &mut W,
420 p: &CommonMp4Params,
421 brands: &[&[u8; 4]],
422 stsd: Vec<u8>,
423 captions: Option<&CaptionTrack>,
424) -> std::io::Result<()> {
425 let num_samples = p.samples.len().max(1) as u32;
426 let total_duration = p.frame_duration * num_samples;
427
428 let ftyp = bx(b"ftyp", &{
430 let mut v = Vec::new();
431 v.extend_from_slice(b"isom"); v.extend_from_slice(&0u32.to_be_bytes()); for brand in brands {
434 v.extend_from_slice(*brand);
435 }
436 v
437 });
438
439 let text_samples = captions
442 .map(|t| build_text_samples(t, p.timescale, total_duration))
443 .unwrap_or_default();
444
445 let video_bytes: u64 = p.samples.iter().map(|s| s.len() as u64).sum();
452 let text_bytes: u64 = text_samples.iter().map(|s| s.data.len() as u64).sum();
453 let mdat_payload_len = video_bytes + text_bytes;
454 let mdat_hdr = if 8 + mdat_payload_len > u32::MAX as u64 {
456 16
457 } else {
458 8
459 };
460 let mdat_data_offset = ftyp.len() as u64 + mdat_hdr as u64;
461 let text_data_offset = mdat_data_offset + video_bytes;
462
463 let stts = fullbox(b"stts", 0, 0, &{
465 let mut v = Vec::new();
466 v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&num_samples.to_be_bytes()); v.extend_from_slice(&p.frame_duration.to_be_bytes()); v
470 });
471
472 let stss = fullbox(b"stss", 0, 0, &{
474 let mut v = Vec::new();
475 v.extend_from_slice(&num_samples.to_be_bytes());
476 for i in 1..=num_samples {
477 v.extend_from_slice(&i.to_be_bytes());
478 }
479 v
480 });
481
482 let stsc = fullbox(b"stsc", 0, 0, &{
483 let mut v = Vec::new();
484 v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&num_samples.to_be_bytes()); v.extend_from_slice(&1u32.to_be_bytes()); v
489 });
490
491 let stsz = fullbox(b"stsz", 0, 0, &{
492 let mut v = Vec::new();
493 v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&num_samples.to_be_bytes()); for s in p.samples {
496 v.extend_from_slice(&(s.len() as u32).to_be_bytes());
497 }
498 v
499 });
500
501 let stco = if mdat_data_offset > u32::MAX as u64 {
506 fullbox(b"co64", 0, 0, &{
507 let mut v = Vec::new();
508 v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&mdat_data_offset.to_be_bytes());
510 v
511 })
512 } else {
513 fullbox(b"stco", 0, 0, &{
514 let mut v = Vec::new();
515 v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&(mdat_data_offset as u32).to_be_bytes());
517 v
518 })
519 };
520
521 let stbl = bx(b"stbl", &concat(&[stsd, stts, stss, stsc, stsz, stco]));
522
523 let vmhd = fullbox(b"vmhd", 0, 1, &[0u8; 8]); let dref = fullbox(b"dref", 0, 0, &{
526 let mut v = Vec::new();
527 v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&fullbox(b"url ", 0, 1, &[])); v
530 });
531 let dinf = bx(b"dinf", &dref);
532 let vid_hdlr = fullbox(b"hdlr", 0, 0, &{
533 let mut v = Vec::new();
534 v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(b"vide"); v.extend_from_slice(&[0u8; 12]); v.extend_from_slice(b"threers\0"); v
539 });
540 let minf = bx(b"minf", &concat(&[vmhd, vid_hdlr, dinf, stbl]));
541
542 let mdhd = fullbox(b"mdhd", 0, 0, &{
544 let mut v = Vec::new();
545 v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&p.timescale.to_be_bytes());
548 v.extend_from_slice(&total_duration.to_be_bytes());
549 v.extend_from_slice(&0x55c4u16.to_be_bytes()); v.extend_from_slice(&0u16.to_be_bytes()); v
552 });
553 let mdia_hdlr = fullbox(b"hdlr", 0, 0, &{
554 let mut v = Vec::new();
555 v.extend_from_slice(&0u32.to_be_bytes());
556 v.extend_from_slice(b"vide");
557 v.extend_from_slice(&[0u8; 12]);
558 v.extend_from_slice(b"threers\0");
559 v
560 });
561 let mdia = bx(b"mdia", &concat(&[mdhd, mdia_hdlr, minf]));
562
563 let tkhd = fullbox(b"tkhd", 0, 7 , &{
565 let mut v = Vec::new();
566 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(&total_duration.to_be_bytes());
571 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);
577 v.extend_from_slice(&(p.width << 16).to_be_bytes()); v.extend_from_slice(&(p.height << 16).to_be_bytes()); v
580 });
581 let trak = bx(b"trak", &concat(&[tkhd, mdia]));
582
583 let text_trak = (!text_samples.is_empty()).then(|| {
584 text_track(
585 p.width,
586 p.height,
587 captions.map(|c| c.language.as_str()).unwrap_or(""),
588 &text_samples,
589 p.timescale,
590 total_duration,
591 text_data_offset,
592 )
593 });
594 let next_track_id = if text_trak.is_some() { 3u32 } else { 2 };
595
596 let mvhd = fullbox(b"mvhd", 0, 0, &{
598 let mut v = Vec::new();
599 v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&p.timescale.to_be_bytes());
602 v.extend_from_slice(&total_duration.to_be_bytes());
603 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);
608 v.extend_from_slice(&[0u8; 24]); v.extend_from_slice(&next_track_id.to_be_bytes());
610 v
611 });
612 let mut moov_children = vec![mvhd, trak];
613 moov_children.extend(text_trak);
614 let moov = bx(b"moov", &concat(&moov_children));
615
616 out.write_all(&ftyp)?;
618 if mdat_hdr == 16 {
619 out.write_all(&1u32.to_be_bytes())?; out.write_all(b"mdat")?;
621 out.write_all(&(16 + mdat_payload_len).to_be_bytes())?;
622 } else {
623 out.write_all(&((8 + mdat_payload_len) as u32).to_be_bytes())?;
624 out.write_all(b"mdat")?;
625 }
626 for s in p.samples {
627 out.write_all(s)?;
628 }
629 for s in &text_samples {
630 out.write_all(&s.data)?;
631 }
632 out.write_all(&moov)?;
633 Ok(())
634}
635
636struct TextSample {
638 duration: u32,
639 data: Vec<u8>,
640}
641
642fn build_text_samples(
648 track: &CaptionTrack,
649 timescale: u32,
650 total_duration: u32,
651) -> Vec<TextSample> {
652 let ticks = |seconds: f64| -> u32 {
653 (seconds.max(0.0) * timescale as f64)
654 .round()
655 .min(u32::MAX as f64) as u32
656 };
657 let mut samples: Vec<TextSample> = Vec::new();
658 let mut cursor = 0u32;
659
660 for cue in &track.cues {
661 let text = cue.plain_text();
662 if text.trim().is_empty() {
663 continue;
664 }
665 let start = ticks(cue.start).max(cursor);
667 let end = ticks(cue.end).max(start);
668 if end == start {
669 continue;
670 }
671 if start > cursor {
672 samples.push(TextSample {
673 duration: start - cursor,
674 data: encode_text_sample(""),
675 });
676 }
677 samples.push(TextSample {
678 duration: end - start,
679 data: encode_text_sample(&text),
680 });
681 cursor = end;
682 }
683
684 if samples.is_empty() {
685 return samples;
686 }
687 if cursor < total_duration {
689 samples.push(TextSample {
690 duration: total_duration - cursor,
691 data: encode_text_sample(""),
692 });
693 }
694 samples
695}
696
697fn encode_text_sample(text: &str) -> Vec<u8> {
699 let text = text.replace("\r\n", "\n").replace('\r', "\n");
701 let bytes = text.as_bytes();
702 let len = bytes.len().min(u16::MAX as usize);
703 let mut v = Vec::with_capacity(2 + len);
704 v.extend_from_slice(&(len as u16).to_be_bytes());
705 v.extend_from_slice(&bytes[..len]);
706 v
707}
708
709fn text_track(
711 width: u32,
712 height: u32,
713 language: &str,
714 samples: &[TextSample],
715 timescale: u32,
716 total_duration: u32,
717 data_offset: u64,
718) -> Vec<u8> {
719 let count = samples.len() as u32;
720
721 let stsd = {
723 let mut entry = Vec::new();
724 entry.extend_from_slice(&[0u8; 6]); entry.extend_from_slice(&1u16.to_be_bytes()); entry.extend_from_slice(&0u32.to_be_bytes()); entry.push(1); entry.push(0xFF); entry.extend_from_slice(&[0, 0, 0, 0]); entry.extend_from_slice(&0i16.to_be_bytes()); entry.extend_from_slice(&0i16.to_be_bytes()); entry.extend_from_slice(&(height.min(i16::MAX as u32) as i16).to_be_bytes()); entry.extend_from_slice(&(width.min(i16::MAX as u32) as i16).to_be_bytes()); entry.extend_from_slice(&0u16.to_be_bytes()); entry.extend_from_slice(&0u16.to_be_bytes()); entry.extend_from_slice(&1u16.to_be_bytes()); entry.push(0); entry.push(((height / 16).clamp(12, 255)) as u8); entry.extend_from_slice(&[0xFF, 0xFF, 0xFF, 0xFF]); let ftab = bx(b"ftab", &{
744 let name = b"Sans-Serif";
745 let mut v = Vec::new();
746 v.extend_from_slice(&1u16.to_be_bytes()); v.extend_from_slice(&1u16.to_be_bytes()); v.push(name.len() as u8);
749 v.extend_from_slice(name);
750 v
751 });
752 entry.extend_from_slice(&ftab);
753
754 let mut payload = Vec::new();
755 payload.extend_from_slice(&1u32.to_be_bytes()); payload.extend_from_slice(&bx(b"tx3g", &entry));
757 fullbox(b"stsd", 0, 0, &payload)
758 };
759
760 let stts = {
762 let mut runs: Vec<(u32, u32)> = Vec::new(); for s in samples {
764 match runs.last_mut() {
765 Some((n, delta)) if *delta == s.duration => *n += 1,
766 _ => runs.push((1, s.duration)),
767 }
768 }
769 let mut v = Vec::new();
770 v.extend_from_slice(&(runs.len() as u32).to_be_bytes());
771 for (n, delta) in runs {
772 v.extend_from_slice(&n.to_be_bytes());
773 v.extend_from_slice(&delta.to_be_bytes());
774 }
775 fullbox(b"stts", 0, 0, &v)
776 };
777
778 let stsc = fullbox(b"stsc", 0, 0, &{
779 let mut v = Vec::new();
780 v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&count.to_be_bytes()); v.extend_from_slice(&1u32.to_be_bytes()); v
785 });
786
787 let stsz = fullbox(b"stsz", 0, 0, &{
788 let mut v = Vec::new();
789 v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&count.to_be_bytes());
791 for s in samples {
792 v.extend_from_slice(&(s.data.len() as u32).to_be_bytes());
793 }
794 v
795 });
796
797 let stco = if data_offset > u32::MAX as u64 {
798 fullbox(b"co64", 0, 0, &{
799 let mut v = Vec::new();
800 v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&data_offset.to_be_bytes());
802 v
803 })
804 } else {
805 fullbox(b"stco", 0, 0, &{
806 let mut v = Vec::new();
807 v.extend_from_slice(&1u32.to_be_bytes()); v.extend_from_slice(&(data_offset as u32).to_be_bytes());
809 v
810 })
811 };
812
813 let stbl = bx(b"stbl", &concat(&[stsd, stts, stsc, stsz, stco]));
814
815 let nmhd = fullbox(b"nmhd", 0, 0, &[]);
817 let dref = fullbox(b"dref", 0, 0, &{
818 let mut v = Vec::new();
819 v.extend_from_slice(&1u32.to_be_bytes());
820 v.extend_from_slice(&fullbox(b"url ", 0, 1, &[]));
821 v
822 });
823 let dinf = bx(b"dinf", &dref);
824 let minf = bx(b"minf", &concat(&[nmhd, dinf, stbl]));
825
826 let mdhd = fullbox(b"mdhd", 0, 0, &{
828 let mut v = Vec::new();
829 v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(×cale.to_be_bytes());
832 v.extend_from_slice(&total_duration.to_be_bytes());
833 v.extend_from_slice(&pack_language(language).to_be_bytes());
834 v.extend_from_slice(&0u16.to_be_bytes()); v
836 });
837 let hdlr = fullbox(b"hdlr", 0, 0, &{
838 let mut v = Vec::new();
839 v.extend_from_slice(&0u32.to_be_bytes()); v.extend_from_slice(b"sbtl"); v.extend_from_slice(&[0u8; 12]); v.extend_from_slice(b"threers captions\0");
843 v
844 });
845 let mdia = bx(b"mdia", &concat(&[mdhd, hdlr, minf]));
846
847 let tkhd = fullbox(b"tkhd", 0, 3 , &{
849 let mut v = Vec::new();
850 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(&total_duration.to_be_bytes());
855 v.extend_from_slice(&[0u8; 8]); v.extend_from_slice(&(-1i16).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);
861 v.extend_from_slice(&(width << 16).to_be_bytes());
862 v.extend_from_slice(&(height << 16).to_be_bytes());
863 v
864 });
865
866 bx(b"trak", &concat(&[tkhd, mdia]))
867}
868
869fn pack_language(language: &str) -> u16 {
872 let code = crate::captions::iso639_2(language);
873 let bits = |b: u8| ((b - 0x60) & 0x1F) as u16;
874 (bits(code[0]) << 10) | (bits(code[1]) << 5) | bits(code[2])
875}
876
877pub(crate) const UNITY_MATRIX: [u8; 36] = [
879 0x00, 0x01, 0x00, 0x00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x00, 0x01, 0x00, 0x00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x40, 0x00, 0x00, 0x00,
882];
883
884#[cfg(test)]
885mod tests {
886 use super::*;
887
888 #[test]
889 fn colr_follows_the_stream_and_survives_garbage() {
890 let enc = crate::h264::CompressedEncoder::new(32, 16, 30);
892 let c =
893 StreamColour::of_avcc(&enc.avcc()).expect("the encoder writes a colour description");
894 assert_eq!((c.matrix, c.full_range), (6, false));
895 let mut seed = 0x2545_f491_4f6c_dd1du64;
897 for i in 0..3000usize {
898 let len = i % 400;
899 let bytes: Vec<u8> = (0..len)
900 .map(|_| {
901 seed ^= seed << 13;
902 seed ^= seed >> 7;
903 seed ^= seed << 17;
904 seed as u8
905 })
906 .collect();
907 for header in [&[1u8, 100, 0, 40, 0xff, 0xe1][..], &[]] {
908 let mut avcc = header.to_vec();
909 if !header.is_empty() {
910 avcc.extend_from_slice(&(len as u16).to_be_bytes());
911 }
912 avcc.extend_from_slice(&bytes);
913 let _ = StreamColour::of_avcc(&avcc);
914 }
915 let mut hvcc = vec![0u8; 22];
916 hvcc.extend_from_slice(&[1, 33, 0, 1]);
917 hvcc.extend_from_slice(&((len + 2) as u16).to_be_bytes());
918 hvcc.extend_from_slice(&[0x42, 0x01]);
919 hvcc.extend_from_slice(&bytes);
920 let _ = StreamColour::of_hvcc(&hvcc);
921 }
922 }
923
924 fn walk_top_level(out: &[u8]) -> Vec<String> {
925 let mut o = 0usize;
926 let mut tags = Vec::new();
927 while o + 8 <= out.len() {
928 let size32 = u32::from_be_bytes([out[o], out[o + 1], out[o + 2], out[o + 3]]);
929 let (hdr, size) = if size32 == 1 {
930 assert!(o + 16 <= out.len());
931 let large = u64::from_be_bytes(out[o + 8..o + 16].try_into().unwrap());
932 (16usize, large as usize)
933 } else {
934 (8usize, size32 as usize)
935 };
936 tags.push(String::from_utf8_lossy(&out[o + 4..o + 8]).to_string());
937 assert!(size >= hdr && o + size <= out.len(), "box {size} at {o}");
938 o += size;
939 }
940 assert_eq!(o, out.len(), "top-level boxes tile the file");
941 tags
942 }
943
944 #[test]
945 fn boxes_are_well_formed() {
946 let sample = vec![0u8; 40];
947 let out = mux_hevc(&Mp4Params {
948 width: 64,
949 height: 64,
950 timescale: 600,
951 frame_duration: 20,
952 hvcc_payload: &[0u8; 30],
953 almo_payload: Some(&[0, 0, 1, 2]),
954 samples: &[sample],
955 });
956 assert_eq!(&out[4..8], b"ftyp");
957 assert_eq!(walk_top_level(&out), vec!["ftyp", "mdat", "moov"]);
958 }
959
960 #[test]
961 fn h264_boxes_are_well_formed() {
962 let sample = vec![0u8; 40];
963 let out = mux_h264(&H264Mp4Params {
964 width: 64,
965 height: 64,
966 timescale: 600,
967 frame_duration: 20,
968 avcc_payload: &[0u8; 20],
969 samples: &[sample],
970 });
971 assert_eq!(&out[4..8], b"ftyp");
972 assert_eq!(walk_top_level(&out), vec!["ftyp", "mdat", "moov"]);
973 assert!(out.windows(4).any(|w| w == b"avc1"));
974 }
975
976 #[test]
977 fn extended_size_header_layout() {
978 let payload_len = (u32::MAX as u64) - 6; let largesize = 16 + payload_len;
982 assert!(largesize > u32::MAX as u64);
983 let mut hdr = Vec::new();
984 hdr.extend_from_slice(&1u32.to_be_bytes());
985 hdr.extend_from_slice(b"mdat");
986 hdr.extend_from_slice(&largesize.to_be_bytes());
987 assert_eq!(box_header_len(&hdr), 16);
988 assert_eq!(box_header_len(&bx(b"mdat", &[0u8; 64])), 8);
989 }
990}