Files
effectcraft/crates/export/src/uncompressed.rs
T
Dylan M. Taylor 79c42749a8 Export, Media: codecs and containers from craft-libs; remove hevcenc, av1enc, vp9enc (#3522)
* Export, Media: H.264, ProRes, HEVC, VP9, AV1, AAC, MP4 and Matroska come from craft-libs

crates/export and crates/media use craft-video, craft-audio and craft-media
(one craft-libs rev) instead of filmcraft-h264enc, -prores, -aac, -isobmff,
-matroska and -opus. The av1enc, hevcenc and vp9enc crates are removed:
craft-video carries the same encoders, with the later changes merged in
storytold/craft-libs#829. Their round-trip tests move to crates/export/tests
and run against craft-video.

opusenc stays (craft-libs has no Opus encoder yet), as do filmcraft-mpegts
and the filmcraft-vp9, -hevc and -av1 decoders the tests use as oracles.

* Pin craft-libs at the main commit that has the encoder colour description (e7c3dda7)
2026-11-11 18:46:50 -05:00

133 lines
5.1 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Uncompressed QuickTime video (`raw `): 8-bit RGB ("Millions of Colors", depth 24) or ARGB
//! ("Millions of Colors+", depth 32), one frame per sample, muxed by FilmCraft's QuickTime writer
//! next to PCM audio like ProRes.
//!
//! Layout from the QuickTime File Format specification (Apple, "Video Sample Description" and
//! "Uncompressed RGB" formats): pixels are stored top to bottom, components big-endian in
//! A R G B / R G B order, and each row is padded to an even number of bytes (only depth 24 at odd
//! widths needs it).
use craft_media::isobmff::{CodecConfig, FourCc, SampleEntry, VideoParams};
use crate::encode::{Packet, VideoEncoder};
use crate::{ExportError, Result};
pub(crate) struct Raw {
w: u32,
h: u32,
alpha: bool,
}
impl Raw {
/// `alpha`: write ARGB (depth 32); otherwise RGB (depth 24).
pub(crate) fn new(w: u32, h: u32, alpha: bool) -> Result<Raw> {
if w == 0 || h == 0 || w > u16::MAX as u32 || h > u16::MAX as u32 {
return Err(ExportError::Unsupported(format!("uncompressed QuickTime frames must be 1–65535 px, not {w}×{h}")));
}
Ok(Raw { w, h, alpha })
}
fn depth(&self) -> u16 {
if self.alpha { 32 } else { 24 }
}
/// Bytes per stored row (even).
fn row_bytes(&self) -> usize {
let n = self.w as usize * if self.alpha { 4 } else { 3 };
n + (n & 1)
}
/// The `raw ` video sample description payload (after the 8-byte box header).
fn description(&self) -> Vec<u8> {
let mut b = Vec::with_capacity(78);
b.extend_from_slice(&[0; 6]); // reserved
b.extend_from_slice(&1u16.to_be_bytes()); // data reference index
b.extend_from_slice(&[0; 4]); // version, revision level
b.extend_from_slice(&[0; 4]); // vendor
b.extend_from_slice(&0u32.to_be_bytes()); // temporal quality
b.extend_from_slice(&1024u32.to_be_bytes()); // spatial quality: codecLosslessQuality
b.extend_from_slice(&(self.w as u16).to_be_bytes());
b.extend_from_slice(&(self.h as u16).to_be_bytes());
b.extend_from_slice(&0x0048_0000u32.to_be_bytes()); // 72 dpi
b.extend_from_slice(&0x0048_0000u32.to_be_bytes());
b.extend_from_slice(&0u32.to_be_bytes()); // data size
b.extend_from_slice(&1u16.to_be_bytes()); // frames per sample
let name = b"None";
let mut nb = [0u8; 32];
nb[0] = name.len() as u8;
nb[1..=name.len()].copy_from_slice(name);
b.extend_from_slice(&nb);
b.extend_from_slice(&self.depth().to_be_bytes());
b.extend_from_slice(&(-1i16).to_be_bytes()); // no colour table
b
}
}
impl VideoEncoder for Raw {
fn sample_entry(&self) -> SampleEntry {
let fourcc = FourCc(*b"raw ");
SampleEntry {
format: fourcc,
data_reference_index: 1,
// Written verbatim; `video` makes the track a video track with the right size.
codec: CodecConfig::Unknown { fourcc, raw: self.description() },
video: Some(VideoParams { width: self.w as u16, height: self.h as u16, depth: self.depth(), ..Default::default() }),
audio: None,
bitrate: None,
}
}
fn encode(&mut self, rgba: &[u8], _index: u64) -> Result<Vec<Packet>> {
let (w, h) = (self.w as usize, self.h as usize);
let row = self.row_bytes();
let size = row.checked_mul(h).ok_or_else(|| ExportError::Encode("frame too large".into()))?;
let mut data = vec![0u8; size];
for (y, out) in data.chunks_exact_mut(row).enumerate() {
let src = rgba.get(y * w * 4..(y + 1) * w * 4).ok_or_else(|| ExportError::Encode("short frame".into()))?;
for (p, o) in src.as_chunks::<4>().0.iter().zip(out.chunks_exact_mut(if self.alpha { 4 } else { 3 })) {
if self.alpha {
o.copy_from_slice(&[p[3], p[0], p[1], p[2]]);
} else {
o.copy_from_slice(&p[..3]);
}
}
}
Ok(vec![Packet { data, key: true, cto: 0 }])
}
fn flush(&mut self) -> Result<Vec<Packet>> {
Ok(vec![])
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rgb_rows_are_padded_to_even_bytes() {
let mut r = Raw::new(3, 2, false).unwrap();
let rgba: Vec<u8> = (0..24).collect();
let p = r.encode(&rgba, 0).unwrap();
assert_eq!(p[0].data, [0, 1, 2, 4, 5, 6, 8, 9, 10, 0, 12, 13, 14, 16, 17, 18, 20, 21, 22, 0]);
assert_eq!(r.sample_entry().video.unwrap().depth, 24);
}
#[test]
fn argb_moves_alpha_first() {
let mut r = Raw::new(1, 1, true).unwrap();
assert_eq!(r.encode(&[10, 20, 30, 40], 0).unwrap()[0].data, [40, 10, 20, 30]);
let e = r.sample_entry();
let CodecConfig::Unknown { raw, .. } = e.codec else { panic!("raw entry") };
assert_eq!(raw.len(), 78);
assert_eq!(&raw[74..76], &32u16.to_be_bytes());
}
#[test]
fn hostile_sizes_are_errors() {
assert!(Raw::new(0, 1, false).is_err());
assert!(Raw::new(70_000, 1, true).is_err());
assert!(Raw::new(2, 2, true).unwrap().encode(&[0; 4], 0).is_err());
}
}