use std::fs::{self, File, OpenOptions};
use std::io::{self, BufWriter, Cursor, Read, Seek, SeekFrom, Write};
use std::path::Path;
use std::time::Instant;
use image::{
DynamicImage, GenericImageView, ImageDecoder, ImageFormat, ImageReader, Rgb, RgbImage,
};
use rustfft::{FftPlanner, num_complex::Complex};
use symphonia::core::audio::SampleBuffer;
use symphonia::core::codecs::{
CODEC_TYPE_AAC, CODEC_TYPE_FLAC, CODEC_TYPE_MP3, CODEC_TYPE_NULL, CODEC_TYPE_OPUS,
CODEC_TYPE_VORBIS, CodecType, DecoderOptions,
};
use symphonia::core::errors::Error as AudioError;
use symphonia::core::formats::FormatOptions;
use symphonia::core::io::MediaSourceStream;
use symphonia::core::meta::{Limit as MetadataLimit, MetadataOptions};
use symphonia::core::probe::Hint;
use crate::{
Adapter, Artifact, ContentKind, ContentProfile, Conversion, ConversionFuture, ConversionKind,
Error, Format, InspectFuture, Limits, MediaKind, Result, StepRequest, Stream,
requested_quality,
};
pub struct MediaAdapter;
const IMAGES: &[(&str, &str, &[&str], ImageFormat)] = &[
("png", "PNG image", &["png"], ImageFormat::Png),
(
"jpeg",
"JPEG image",
&["jpg", "jpeg", "jpe"],
ImageFormat::Jpeg,
),
("gif", "GIF image", &["gif"], ImageFormat::Gif),
("webp", "WebP image", &["webp"], ImageFormat::WebP),
("tiff", "TIFF image", &["tif", "tiff"], ImageFormat::Tiff),
("bmp", "BMP image", &["bmp"], ImageFormat::Bmp),
("ico", "Windows icon", &["ico"], ImageFormat::Ico),
(
"pnm",
"Netpbm image",
&["pnm", "ppm", "pgm", "pbm", "pam"],
ImageFormat::Pnm,
),
("tga", "Targa image", &["tga"], ImageFormat::Tga),
(
"dds",
"DDS texture (decode only)",
&["dds"],
ImageFormat::Dds,
),
("qoi", "Quite OK image", &["qoi"], ImageFormat::Qoi),
(
"hdr",
"Radiance HDR image",
&["hdr", "rgbe"],
ImageFormat::Hdr,
),
(
"farbfeld",
"Farbfeld image",
&["ff", "farbfeld"],
ImageFormat::Farbfeld,
),
];
const AUDIO: &[(&str, &str, &[&str])] = &[
("wav", "WAVE audio", &["wav", "wave"]),
("flac", "FLAC audio", &["flac"]),
("mp3", "MPEG Layer III audio", &["mp3"]),
("mp2", "MPEG Layer II audio", &["mp2"]),
("mp1", "MPEG Layer I audio", &["mp1"]),
("aac", "AAC audio", &["aac", "adts"]),
("ogg", "Ogg audio (supported codecs only)", &["ogg", "oga"]),
("m4a", "MPEG-4 audio (AAC/ALAC)", &["m4a", "m4b"]),
("aiff", "AIFF audio", &["aiff", "aif", "aifc"]),
("caf", "Core Audio Format", &["caf"]),
("mka", "Matroska audio (supported codecs only)", &["mka"]),
];
const FFT_SIZE: usize = 1024;
const FFT_WORK_BYTES: u64 = 256 * 1024;
const CODEC_WORK_BYTES: u64 = 1024 * 1024;
const MAX_COLUMNS: usize = 2048;
const LOSSLESS_RASTER: &[&str] = &["png", "tiff", "bmp", "pnm", "tga", "qoi", "hdr", "farbfeld"];
const MIME: &[(&str, &[&str])] = &[
("png", &["image/png"]),
("jpeg", &["image/jpeg", "image/pjpeg"]),
("gif", &["image/gif"]),
("webp", &["image/webp"]),
("tiff", &["image/tiff"]),
("bmp", &["image/bmp"]),
("ico", &["image/vnd.microsoft.icon"]),
(
"pnm",
&[
"image/x-portable-bitmap",
"image/x-portable-graymap",
"image/x-portable-pixmap",
],
),
("tga", &["image/x-tga"]),
("dds", &["image/vnd-directx"]),
("qoi", &["image/qoi"]),
("hdr", &["image/vnd.radiance"]),
("farbfeld", &["application/octet-stream"]),
("txt", &["text/plain"]),
("pdf", &["application/pdf"]),
("wav", &["audio/wav", "audio/x-wav"]),
("flac", &["audio/flac"]),
("mp3", &["audio/mpeg"]),
("mp2", &["audio/mpeg"]),
("mp1", &["audio/mpeg"]),
("aac", &["audio/aac"]),
("ogg", &["audio/ogg"]),
("m4a", &["audio/mp4"]),
("aiff", &["audio/aiff", "audio/x-aiff"]),
("caf", &["audio/x-caf"]),
("mka", &["audio/x-matroska"]),
];
fn mime_for(id: &str) -> &'static [&'static str] {
MIME.iter()
.find(|(name, _)| *name == id)
.map_or(&[][..], |(_, types)| *types)
}
impl Adapter for MediaAdapter {
fn name(&self) -> &str {
"media"
}
fn param_keys(&self, operation: &str) -> Vec<String> {
if matches!(
operation,
"image-transcode" | "audio-spectrogram" | "text-bitmap"
) {
vec!["quality".to_owned()]
} else {
Vec::new()
}
}
fn accepts_input(&self, path: &std::path::Path, format: &str, limits: &Limits) -> Option<bool> {
let is_image = IMAGES.iter().any(|(id, ..)| *id == format);
let is_audio = AUDIO.iter().any(|(id, ..)| *id == format);
if !is_image && !is_audio {
return None;
}
let decoded = if is_image {
decode_image(path, format, limits).map(drop)
} else {
decode_audio(path, format, limits, Instant::now()).map(drop)
};
match decoded {
Ok(()) => Some(true),
Err(Error::Security(_) | Error::Invalid(_)) => Some(false),
Err(_) => None,
}
}
fn inspect<'a>(
&'a self,
path: &'a std::path::Path,
format: &'a str,
limits: &'a Limits,
) -> InspectFuture<'a> {
if AUDIO.iter().any(|(id, ..)| *id == format) {
let path = path.to_path_buf();
let format = format.to_owned();
let limits = limits.clone();
return Box::pin(async move {
let outcome = tokio::task::spawn_blocking(move || {
probe_audio(&path, &format, &limits).map(dedup)
})
.await;
Some(outcome.unwrap_or_else(|err| {
Err(Error::Conversion(format!("audio probe panicked: {err}")))
}))
});
}
if IMAGES.iter().any(|(id, ..)| *id == format) {
let path = path.to_path_buf();
let format = format.to_owned();
let limits = limits.clone();
return Box::pin(async move {
let outcome = tokio::task::spawn_blocking(move || {
profile_image(&path, &format, &limits).map(dedup)
})
.await;
Some(outcome.unwrap_or_else(|err| {
Err(Error::Conversion(format!("image probe panicked: {err}")))
}))
});
}
Box::pin(async { None })
}
fn formats(&self) -> Vec<Format> {
let image = ContentKind::new(MediaKind::Image);
let audio = ContentKind::new(MediaKind::Audio);
let text = ContentKind::new(MediaKind::Text);
let mut formats: Vec<_> = IMAGES
.iter()
.map(|(id, name, ext, _)| {
Format::new(id, name, MediaKind::Image)
.with_extensions(ext)
.with_mime(mime_for(id))
.with_payloads(std::slice::from_ref(&image))
})
.collect();
formats.extend(AUDIO.iter().map(|(id, name, ext)| {
Format::new(id, name, MediaKind::Audio)
.with_extensions(ext)
.with_mime(mime_for(id))
.with_payloads(std::slice::from_ref(&audio))
}));
formats.push(
Format::new("txt", "Plain text", MediaKind::Text)
.with_extensions(&["txt"])
.with_mime(mime_for("txt"))
.with_payloads(&[text]),
);
formats.push(
Format::new("pdf", "PDF document", MediaKind::Document)
.with_extensions(&["pdf"])
.with_mime(mime_for("pdf"))
.with_payloads(&[ContentKind::new(MediaKind::Document)]),
);
formats
}
fn conversions(&self) -> Vec<Conversion> {
let mut edges = Vec::new();
for &(from, _, _, _) in IMAGES {
for &(to, _, _, format) in IMAGES {
if from != to && format != ImageFormat::Dds {
edges.push(
Conversion::new(
from,
to,
"media",
"image-transcode",
ConversionKind::Lossy,
10,
)
.with_note(
"pixels are resampled and re-encoded; original encoder decisions are lost",
),
);
}
}
for target in LOSSLESS_RASTER {
if *target == from {
edges.push(
Conversion::new(
from,
from,
"media",
"image-transcode",
ConversionKind::Reencode,
8,
)
.with_note(
"pixels are decoded and re-encoded losslessly; metadata may change",
)
.with_retained(&["pixels", "alpha"]),
);
}
}
for target in ["jpeg", "gif", "webp", "ico"] {
if target == from {
edges.push(
Conversion::new(
from,
from,
"media",
"image-transcode",
ConversionKind::Reencode,
8,
)
.with_note(
"pixels are decoded and re-encoded; encoder decisions are reset",
),
);
}
}
edges.push(
Conversion::new(
from,
"txt",
"media",
"image-ascii",
ConversionKind::Bridge,
35,
)
.with_note("pixels are reduced to a text ramp; color and detail are dropped")
.creative(),
);
edges.push(
Conversion::new(
from,
"wav",
"media",
"image-synthesis",
ConversionKind::Bridge,
50,
)
.with_note("pixels are mapped to synthesized audio, not decoded from it")
.creative(),
);
edges.push(
Conversion::new(from, "pdf", "media", "image-pdf", ConversionKind::Lossy, 15)
.with_note("images are embedded and re-encoded into a PDF page"),
);
}
for &(from, _, _) in AUDIO {
if from != "wav" {
edges.push(
Conversion::new(from, "wav", "media", "audio-wav", ConversionKind::Lossy, 10)
.with_note("compressed audio is decoded to PCM; codec metadata is lost"),
);
} else {
edges.push(
Conversion::new(
"wav",
"wav",
"media",
"audio-wav",
ConversionKind::Reencode,
5,
)
.with_note("PCM is resampled and rewritten; codec metadata is reset")
.with_retained(&["samples"]),
);
}
edges.push(
Conversion::new(
from,
"png",
"media",
"audio-spectrogram",
ConversionKind::Bridge,
40,
)
.with_note("audio is rendered as a spectrogram image; playback is not recoverable")
.creative(),
);
}
edges.push(
Conversion::new(
"txt",
"png",
"media",
"text-bitmap",
ConversionKind::Bridge,
25,
)
.with_note("text is rasterized with a fixed bitmap font"),
);
edges
}
fn convert<'a>(&'a self, request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async move {
let request = request.clone();
tokio::task::spawn_blocking(move || convert_blocking(&request))
.await
.map_err(|err| Error::Security(format!("media worker failed: {err}")))?
})
}
}
fn overflow() -> Error {
Error::Limit("media size arithmetic overflow".into())
}
fn add(a: u64, b: u64) -> Result<u64> {
a.checked_add(b).ok_or_else(overflow)
}
fn mul(a: u64, b: u64) -> Result<u64> {
a.checked_mul(b).ok_or_else(overflow)
}
fn size(value: u64) -> Result<usize> {
usize::try_from(value).map_err(|_| overflow())
}
fn memory(bytes: u64, limits: &Limits) -> Result<()> {
if bytes > limits.max_memory_bytes || bytes > isize::MAX as u64 {
return Err(Error::Limit("media memory budget".into()));
}
Ok(())
}
fn pixels(width: u32, height: u32, limits: &Limits) -> Result<u64> {
if width == 0 || height == 0 {
return Err(Error::Security("zero image dimension".into()));
}
let count = mul(u64::from(width), u64::from(height))?;
if count > limits.max_pixels || width > 65_535 || height > 65_535 {
return Err(Error::Limit("image dimensions or pixel count".into()));
}
Ok(count)
}
fn deadline(start: Instant, limits: &Limits) -> Result<()> {
if start.elapsed() >= limits.timeout {
return Err(Error::Timeout {
backend: "media".into(),
});
}
Ok(())
}
fn image_format(id: &str) -> Result<ImageFormat> {
IMAGES
.iter()
.find(|entry| entry.0 == id)
.map(|entry| entry.3)
.ok_or_else(|| Error::Invalid(format!("unsupported image format: {id}")))
}
fn image_error(err: image::ImageError) -> Error {
match err {
image::ImageError::Limits(_) => Error::Limit(err.to_string()),
image::ImageError::IoError(err) if err.kind() == io::ErrorKind::UnexpectedEof => {
Error::Security(format!("truncated image: {err}"))
}
image::ImageError::IoError(err) => err.into(),
image::ImageError::Decoding(_) => Error::Security(format!("invalid image: {err}")),
_ => Error::Conversion(err.to_string()),
}
}
fn read_input(path: &Path, limits: &Limits) -> Result<Vec<u8>> {
let metadata = fs::symlink_metadata(path)?;
if !metadata.file_type().is_file() {
return Err(Error::Security(
"media input must be a staged regular file".into(),
));
}
let len = metadata.len();
if len > limits.max_input_bytes {
return Err(Error::Limit("media input bytes".into()));
}
memory(add(mul(len, 4)?, CODEC_WORK_BYTES)?, limits)?;
let mut data = Vec::new();
data.try_reserve_exact(size(len)?)
.map_err(|_| Error::Limit("input allocation".into()))?;
data.resize(size(len)?, 0);
let mut file = File::open(path)?;
file.read_exact(&mut data)?;
let mut extra = [0];
if file.read(&mut extra)? != 0 {
return Err(Error::Security("staged input changed size".into()));
}
Ok(data)
}
struct Output {
file: BufWriter<File>,
position: u64,
length: u64,
cap: u64,
start: Instant,
timeout: std::time::Duration,
limited: bool,
timed_out: bool,
}
impl Output {
fn create(path: &Path, cap: u64, start: Instant, limits: &Limits) -> Result<Self> {
Ok(Self {
file: BufWriter::new(
OpenOptions::new()
.write(true)
.read(true)
.create_new(true)
.open(path)?,
),
position: 0,
length: 0,
cap,
start,
timeout: limits.timeout,
limited: false,
timed_out: false,
})
}
fn check(&mut self, end: u64) -> io::Result<()> {
if end > self.cap {
self.limited = true;
}
if self.start.elapsed() >= self.timeout {
self.timed_out = true;
}
if self.limited || self.timed_out {
return Err(io::Error::other("media output limit or deadline"));
}
Ok(())
}
fn finish(&mut self, result: Result<()>) -> Result<()> {
if self.limited {
return Err(Error::Limit("media output bytes".into()));
}
if matches!(&result, Err(Error::Security(_) | Error::Limit(_))) {
return result;
}
if self.timed_out || self.start.elapsed() >= self.timeout {
return Err(Error::Timeout {
backend: "media".into(),
});
}
result?;
self.file.flush()?;
Ok(())
}
}
impl Write for Output {
fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
let end = match self.position.checked_add(bytes.len() as u64) {
Some(end) => end,
None => {
self.limited = true;
return Err(io::Error::other("media output size overflow"));
}
};
self.check(end)?;
let written = self.file.write(bytes)?;
self.position += written as u64; self.length = self.length.max(self.position);
Ok(written)
}
fn flush(&mut self) -> io::Result<()> {
self.check(self.position)?;
self.file.flush()
}
}
impl Seek for Output {
fn seek(&mut self, seek: SeekFrom) -> io::Result<u64> {
let destination = match seek {
SeekFrom::Start(n) => i128::from(n),
SeekFrom::Current(n) => i128::from(self.position) + i128::from(n),
SeekFrom::End(n) => i128::from(self.length) + i128::from(n),
};
let destination = u64::try_from(destination)
.map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid output seek"))?;
self.check(destination)?;
self.position = self.file.seek(SeekFrom::Start(destination))?;
Ok(self.position)
}
}
fn convert_blocking(request: &StepRequest) -> Result<Vec<Artifact>> {
let start = Instant::now();
let limits = &request.limits;
deadline(start, limits)?;
if request.inputs.is_empty() || request.inputs.len() > limits.max_artifacts {
return Err(Error::Limit("media input artifact count".into()));
}
if !fs::symlink_metadata(&request.output_dir)?
.file_type()
.is_dir()
{
return Err(Error::Security(
"media output must be a private directory".into(),
));
}
let is_image = IMAGES.iter().any(|entry| entry.0 == request.from);
let is_audio = AUDIO.iter().any(|entry| entry.0 == request.from);
let valid = match request.operation.as_str() {
"image-transcode" => is_image && image_format(&request.to)? != ImageFormat::Dds,
"image-ascii" => is_image && request.to == "txt",
"image-synthesis" => is_image && request.to == "wav",
"image-pdf" => is_image && request.to == "pdf",
"audio-wav" => is_audio && request.to == "wav",
"audio-spectrogram" => is_audio && request.to == "png",
"text-bitmap" => request.from == "txt" && request.to == "png",
_ => false,
};
if !valid
|| request
.inputs
.iter()
.any(|input| input.format != request.from)
{
return Err(Error::Invalid(
"media operation does not match its formats".into(),
));
}
let input_bytes = request.inputs.iter().try_fold(0u64, |total, input| {
let metadata = fs::symlink_metadata(&input.path)?;
if !metadata.file_type().is_file() {
return Err(Error::Security("non-regular media input".into()));
}
add(total, metadata.len())
})?;
if input_bytes > limits.max_input_bytes {
return Err(Error::Limit("aggregate media input bytes".into()));
}
let pdf = request.operation == "image-pdf";
let count = if pdf { 1 } else { request.inputs.len() };
let mut artifacts = Vec::with_capacity(count);
for index in 0..count {
deadline(start, limits)?;
let written = artifacts_written(&artifacts);
let spent = request.spent_output_bytes.saturating_add(written);
let total_headroom = if limits.max_total_output_bytes == 0 {
u64::MAX
} else {
limits
.max_total_output_bytes
.checked_sub(spent)
.ok_or_else(|| Error::Limit("media combined output bytes".into()))?
};
let budget = limits
.max_output_bytes
.saturating_sub(written)
.min(total_headroom);
if budget == 0 {
cleanup_artifacts(&artifacts);
return Err(Error::Limit("media combined output bytes".into()));
}
let path = request
.output_dir
.join(format!("media-{index}.{}", request.to));
let mut output = Output::create(&path, budget, start, limits)?;
let result = if pdf {
write_pdf(&request.inputs, &request.from, &mut output, limits, start)
} else {
convert_one(&request.inputs[index], request, &mut output, start)
};
let result = output.finish(result);
drop(output);
if let Err(err) = result {
let _ = fs::remove_file(&path);
cleanup_artifacts(&artifacts);
return Err(err);
}
artifacts.push(Artifact::new(path, request.to.clone()));
}
Ok(artifacts)
}
fn artifacts_written(artifacts: &[Artifact]) -> u64 {
artifacts
.iter()
.filter_map(|artifact| fs::metadata(&artifact.path).ok())
.map(|metadata| metadata.len())
.sum()
}
fn cleanup_artifacts(artifacts: &[Artifact]) {
for artifact in artifacts {
let _ = fs::remove_file(&artifact.path);
}
}
fn convert_one(
input: &Artifact,
request: &StepRequest,
output: &mut Output,
start: Instant,
) -> Result<()> {
let limits = &request.limits;
match request.operation.as_str() {
"image-transcode" | "image-ascii" | "image-synthesis" => {
let image = decode_image(&input.path, &request.from, limits)?;
deadline(start, limits)?;
match request.operation.as_str() {
"image-ascii" => write_ascii(&image, output, limits),
"image-synthesis" => write_wav(&synthesize(&image, limits, start)?, output, limits),
_ => encode_image(
&image,
&request.to,
output,
limits,
requested_quality(&request.params),
),
}
}
"audio-wav" | "audio-spectrogram" => {
let audio = decode_audio(&input.path, &request.from, limits, start)?;
if request.operation == "audio-wav" {
write_wav(&audio, output, limits)
} else {
let image = spectrogram(&audio, limits, start)?;
drop(audio);
encode_image(
&DynamicImage::ImageRgb8(image),
"png",
output,
limits,
requested_quality(&request.params),
)
}
}
"text-bitmap" => {
let bytes = read_input(&input.path, limits)?;
let image = render_text(&bytes, limits)?;
drop(bytes);
encode_image(
&DynamicImage::ImageRgb8(image),
"png",
output,
limits,
requested_quality(&request.params),
)
}
_ => Err(Error::Invalid("unknown media operation".into())),
}
}
fn decode_image(path: &Path, id: &str, limits: &Limits) -> Result<DynamicImage> {
let data = read_input(path, limits)?;
let format = image_format(id)?;
if format == ImageFormat::Tga {
if data.len() < 18
|| data[1] > 1
|| !matches!(data[2], 1..=3 | 9..=11)
|| !matches!(data[16], 8 | 15 | 16 | 24 | 32)
{
return Err(Error::Security("invalid TGA header".into()));
}
pixels(
u32::from(u16::from_le_bytes([data[12], data[13]])),
u32::from(u16::from_le_bytes([data[14], data[15]])),
limits,
)?;
} else if image::guess_format(&data).ok() != Some(format) {
return Err(Error::Security(
"image signature does not match declared format".into(),
));
}
let dimensions = match format {
ImageFormat::Png if data.len() >= 24 => Some((16, 20, true)),
ImageFormat::Qoi if data.len() >= 14 => Some((4, 8, true)),
ImageFormat::Farbfeld if data.len() >= 16 => Some((8, 12, true)),
ImageFormat::Dds if data.len() >= 20 => Some((16, 12, false)),
_ => None,
};
if let Some((w, h, big_endian)) = dimensions {
let value = |offset| {
let bytes = [
data[offset],
data[offset + 1],
data[offset + 2],
data[offset + 3],
];
if big_endian {
u32::from_be_bytes(bytes)
} else {
u32::from_le_bytes(bytes)
}
};
pixels(value(w), value(h), limits)?;
}
let encoded_bytes = data.len() as u64;
let mut reader = ImageReader::with_format(Cursor::new(data), format);
let mut image_limits = image::Limits::default();
image_limits.max_image_width = Some(65_535);
image_limits.max_image_height = Some(65_535);
image_limits.max_alloc = Some(limits.max_memory_bytes / 2);
reader.limits(image_limits.clone());
let mut decoder = reader.into_decoder().map_err(image_error)?;
let (width, height) = decoder.dimensions();
let count = pixels(width, height, limits)?;
memory(
add(
add(mul(count, 32)?, mul(encoded_bytes, 4)?)?,
CODEC_WORK_BYTES,
)?,
limits,
)?;
if decoder.total_bytes() > limits.max_memory_bytes / 2 {
return Err(Error::Limit("decoded image bytes".into()));
}
image_limits.max_alloc = Some(limits.max_memory_bytes / 2 - decoder.total_bytes());
decoder.set_limits(image_limits).map_err(image_error)?;
DynamicImage::from_decoder(decoder).map_err(image_error)
}
fn encode_image(
image: &DynamicImage,
id: &str,
output: &mut Output,
limits: &Limits,
quality: Option<u8>,
) -> Result<()> {
let count = pixels(image.width(), image.height(), limits)?;
memory(add(mul(count, 32)?, CODEC_WORK_BYTES)?, limits)?;
let format = image_format(id)?;
if format == ImageFormat::Dds {
return Err(Error::Invalid("DDS encoding is not supported".into()));
}
if format == ImageFormat::Ico && (image.width() > 256 || image.height() > 256) {
return Err(Error::Limit(
"ICO dimensions must not exceed 256x256".into(),
));
}
if let (Some(quality), ImageFormat::Jpeg) = (quality, format) {
let encoder = image::codecs::jpeg::JpegEncoder::new_with_quality(output, quality);
return image
.to_rgb8()
.write_with_encoder(encoder)
.map_err(image_error);
}
if let (Some(quality), ImageFormat::Png) = (quality, format) {
let compression = if quality >= 75 {
image::codecs::png::CompressionType::Fast
} else if quality >= 40 {
image::codecs::png::CompressionType::Default
} else {
image::codecs::png::CompressionType::Best
};
let encoder = image::codecs::png::PngEncoder::new_with_quality(
output,
compression,
image::codecs::png::FilterType::Adaptive,
);
return image.write_with_encoder(encoder).map_err(image_error);
}
let converted = match format {
ImageFormat::Jpeg | ImageFormat::Pnm => DynamicImage::ImageRgb8(image.to_rgb8()),
ImageFormat::Hdr => DynamicImage::ImageRgb32F(image.to_rgb32f()),
ImageFormat::Farbfeld => DynamicImage::ImageRgba16(image.to_rgba16()),
ImageFormat::Gif
| ImageFormat::WebP
| ImageFormat::Ico
| ImageFormat::Qoi
| ImageFormat::Bmp
| ImageFormat::Tga => DynamicImage::ImageRgba8(image.to_rgba8()),
_ => return image.write_to(output, format).map_err(image_error),
};
converted.write_to(output, format).map_err(image_error)
}
struct Audio {
samples: Vec<f32>,
rate: u32,
channels: usize,
}
fn audio_spec(rate: u32, channels: usize) -> Result<()> {
if !(1_000..=192_000).contains(&rate) || !(1..=8).contains(&channels) {
return Err(Error::Security(
"unsupported audio sample rate or channel count".into(),
));
}
Ok(())
}
fn audio_samples(count: u64, limits: &Limits) -> Result<()> {
if count > limits.max_audio_samples {
return Err(Error::Limit(
"decoded audio samples (including all channels)".into(),
));
}
memory(add(mul(count, 8)?, CODEC_WORK_BYTES)?, limits)
}
fn audio_error(err: AudioError) -> Error {
match err {
AudioError::LimitError(message) => Error::Limit(message.into()),
AudioError::Unsupported(message) => Error::Conversion(message.into()),
_ => Error::Security(format!("invalid audio: {err}")),
}
}
fn dedup(mut profile: ContentProfile) -> ContentProfile {
profile.deduplicate();
profile
}
fn codec_label(codec: CodecType) -> Option<&'static str> {
let label = match codec {
CODEC_TYPE_VORBIS => "vorbis",
CODEC_TYPE_MP3 => "mp3",
CODEC_TYPE_AAC => "aac",
CODEC_TYPE_OPUS => "opus",
CODEC_TYPE_FLAC => "flac",
_ => return None,
};
Some(label)
}
fn probe_audio(path: &Path, id: &str, limits: &Limits) -> Result<ContentProfile> {
decode_audio(path, id, limits, Instant::now()).map(drop)?;
let data = read_input(path, limits)?;
let source = MediaSourceStream::new(Box::new(Cursor::new(data)), Default::default());
let mut hint = Hint::new();
hint.with_extension(id);
let metadata = MetadataOptions {
limit_metadata_bytes: MetadataLimit::Maximum(size(
(limits.max_memory_bytes / 16).min(1024 * 1024),
)?),
limit_visual_bytes: MetadataLimit::Maximum(0),
};
let probe = symphonia::default::get_probe()
.format(&hint, source, &FormatOptions::default(), &metadata)
.map_err(audio_error)?;
let mut profile = ContentProfile::new(id);
for track in probe.format.tracks() {
if track.codec_params.codec == CODEC_TYPE_NULL {
continue;
}
profile.add_stream(Stream::new(
profile.stream_kinds().len(),
audio_content(track.codec_params.codec),
));
}
if profile.stream_kinds().is_empty() {
return Err(Error::Security("no audio track".into()));
}
Ok(profile)
}
fn audio_content(codec: CodecType) -> ContentKind {
match codec_label(codec) {
Some(label) => ContentKind::with_codec(MediaKind::Audio, label),
None => ContentKind::new(MediaKind::Audio),
}
}
fn profile_image(path: &Path, id: &str, limits: &Limits) -> Result<ContentProfile> {
decode_image(path, id, limits).map(drop)?;
Ok(ContentProfile::new(id).with_stream(ContentKind::new(MediaKind::Image)))
}
fn decode_audio(path: &Path, id: &str, limits: &Limits, start: Instant) -> Result<Audio> {
let data = read_input(path, limits)?;
let encoded_bytes = data.len() as u64;
if id == "wav" {
validate_wav(&data)?;
}
let source = MediaSourceStream::new(Box::new(Cursor::new(data)), Default::default());
let mut hint = Hint::new();
hint.with_extension(id);
let metadata = MetadataOptions {
limit_metadata_bytes: MetadataLimit::Maximum(size(
(limits.max_memory_bytes / 16).min(1024 * 1024),
)?),
limit_visual_bytes: MetadataLimit::Maximum(0),
};
let mut format = symphonia::default::get_probe()
.format(&hint, source, &FormatOptions::default(), &metadata)
.map_err(audio_error)?
.format;
let track = format
.default_track()
.filter(|track| track.codec_params.codec != CODEC_TYPE_NULL)
.or_else(|| {
format
.tracks()
.iter()
.find(|track| track.codec_params.codec != CODEC_TYPE_NULL)
})
.ok_or_else(|| Error::Security("no audio track".into()))?;
let track_id = track.id;
let params = &track.codec_params;
let rate = params
.sample_rate
.ok_or_else(|| Error::Security("unknown audio sample rate".into()))?;
let channels = params
.channels
.ok_or_else(|| Error::Security("unknown audio channels".into()))?
.count();
audio_spec(rate, channels)?;
let expected = match (params.n_frames, params.time_base) {
(Some(frames), Some(base)) if base.numer == 1 && base.denom == rate => Some(frames),
_ => None,
};
if let Some(frames) = expected {
audio_samples(mul(frames, channels as u64)?, limits)?;
}
for frames in [params.max_frames_per_packet, params.frames_per_block]
.into_iter()
.flatten()
{
if frames > 65_536 {
return Err(Error::Limit("audio packet frame count".into()));
}
audio_samples(mul(frames, channels as u64)?, limits)?;
}
if params
.extra_data
.as_ref()
.is_some_and(|data| data.len() > 1024 * 1024)
{
return Err(Error::Limit("audio codec header bytes".into()));
}
let mut decoder = symphonia::default::get_codecs()
.make(params, &DecoderOptions { verify: true })
.map_err(audio_error)?;
let mut samples = Vec::new();
loop {
deadline(start, limits)?;
let packet = match format.next_packet() {
Ok(packet) => packet,
Err(AudioError::IoError(err)) if err.kind() == io::ErrorKind::UnexpectedEof => break,
Err(err) => return Err(audio_error(err)),
};
while !format.metadata().is_latest() {
format.metadata().pop();
}
if packet.buf().len() as u64 > limits.max_memory_bytes / 8 {
return Err(Error::Limit("encoded audio packet bytes".into()));
}
if packet.track_id() != track_id {
continue;
}
let decoded = decoder.decode(&packet).map_err(audio_error)?;
let spec = *decoded.spec();
audio_spec(spec.rate, spec.channels.count())?;
if spec.rate != rate || spec.channels.count() != channels {
return Err(Error::Security(
"audio stream changed its sample layout".into(),
));
}
let packet_samples = mul(decoded.frames() as u64, channels as u64)?;
let total = add(samples.len() as u64, packet_samples)?;
audio_samples(total, limits)?;
let capacity = mul(decoded.capacity() as u64, channels as u64)?;
if decoded.capacity() > 65_536 {
return Err(Error::Limit("decoded audio packet capacity".into()));
}
audio_samples(capacity, limits)?;
let new_capacity = if size(total)? > samples.capacity() {
total
.max(
(samples.capacity() as u64)
.checked_mul(2)
.ok_or_else(overflow)?,
)
.min(limits.max_audio_samples)
} else {
samples.capacity() as u64
};
memory(
add(
add(mul(encoded_bytes, 4)?, mul(new_capacity, 8)?)?,
add(mul(capacity, 16)?, CODEC_WORK_BYTES)?,
)?,
limits,
)?;
if size(total)? > samples.capacity() {
samples
.try_reserve_exact(
size(new_capacity)?
.checked_sub(samples.len())
.ok_or_else(overflow)?,
)
.map_err(|_| Error::Limit("audio sample allocation".into()))?;
}
let mut buffer = SampleBuffer::<f32>::new(decoded.capacity() as u64, spec);
buffer.copy_interleaved_ref(decoded);
if buffer.samples().iter().any(|sample| !sample.is_finite()) {
return Err(Error::Security("non-finite audio sample".into()));
}
samples.extend_from_slice(buffer.samples());
}
if samples.is_empty() {
return Err(Error::Security("audio contains no decoded samples".into()));
}
if matches!(id, "wav" | "aiff" | "flac")
&& expected.is_some_and(|frames| frames != (samples.len() / channels) as u64)
{
return Err(Error::Security(
"audio ended before its declared frame count".into(),
));
}
if decoder.finalize().verify_ok == Some(false) {
return Err(Error::Security("audio checksum verification failed".into()));
}
Ok(Audio {
samples,
rate,
channels,
})
}
fn validate_wav(data: &[u8]) -> Result<()> {
if data.len() < 12 || &data[..4] != b"RIFF" || &data[8..12] != b"WAVE" {
return Err(Error::Security("invalid RIFF/WAVE header".into()));
}
let end = add(
u64::from(u32::from_le_bytes([data[4], data[5], data[6], data[7]])),
8,
)?;
if end != data.len() as u64 {
return Err(Error::Security(
"RIFF length does not match the input".into(),
));
}
let mut offset = 12usize;
let mut has_format = false;
let mut has_data = false;
let mut pcm_alignment = None;
while offset < data.len() {
let header_end = offset.checked_add(8).ok_or_else(overflow)?;
let header = data
.get(offset..header_end)
.ok_or_else(|| Error::Security("truncated WAVE chunk header".into()))?;
let len = u64::from(u32::from_le_bytes([
header[4], header[5], header[6], header[7],
]));
let next = size(add(header_end as u64, add(len, len % 2)?)?)?;
if next > data.len() {
return Err(Error::Security("truncated WAVE chunk".into()));
}
if &header[..4] == b"fmt " {
if has_format || len < 16 {
return Err(Error::Security(
"invalid or duplicate WAVE format chunk".into(),
));
}
let fmt = &data[header_end..next];
let channels = usize::from(u16::from_le_bytes([fmt[2], fmt[3]]));
let rate = u32::from_le_bytes([fmt[4], fmt[5], fmt[6], fmt[7]]);
audio_spec(rate, channels)?;
let codec = u16::from_le_bytes([fmt[0], fmt[1]]);
let align = u64::from(u16::from_le_bytes([fmt[12], fmt[13]]));
if align == 0 {
return Err(Error::Security("zero WAVE block alignment".into()));
}
if matches!(codec, 1 | 3) {
let bits = u16::from_le_bytes([fmt[14], fmt[15]]);
if !matches!(bits, 8 | 16 | 24 | 32 | 64)
|| (codec == 3 && !matches!(bits, 32 | 64))
|| align != mul(channels as u64, u64::from(bits / 8))?
{
return Err(Error::Security("invalid PCM sample layout".into()));
}
pcm_alignment = Some(align);
}
has_format = true;
}
if &header[..4] == b"data" {
if !has_format
|| has_data
|| len == 0
|| pcm_alignment.is_some_and(|align| len % align != 0)
{
return Err(Error::Security(
"invalid or incomplete WAVE data chunk".into(),
));
}
has_data = true;
}
offset = next;
}
if !has_format || !has_data {
return Err(Error::Security(
"WAVE format or sample chunk missing".into(),
));
}
Ok(())
}
fn write_wav(audio: &Audio, output: &mut Output, limits: &Limits) -> Result<()> {
audio_spec(audio.rate, audio.channels)?;
audio_samples(audio.samples.len() as u64, limits)?;
if audio.samples.is_empty() || !audio.samples.len().is_multiple_of(audio.channels) {
return Err(Error::Security("incomplete WAVE sample frames".into()));
}
let bytes = add(mul(audio.samples.len() as u64, 2)?, 68)?;
if bytes > limits.max_output_bytes || bytes > u64::from(u32::MAX) {
return Err(Error::Limit("PCM16 WAVE output bytes".into()));
}
let spec = hound::WavSpec {
channels: u16::try_from(audio.channels).map_err(|_| overflow())?,
sample_rate: audio.rate,
bits_per_sample: 16,
sample_format: hound::SampleFormat::Int,
};
let mut writer =
hound::WavWriter::new(output, spec).map_err(|err| Error::Conversion(err.to_string()))?;
for &sample in &audio.samples {
if !sample.is_finite() {
return Err(Error::Security("non-finite WAVE sample".into()));
}
writer
.write_sample((sample.clamp(-1.0, 1.0) * 32767.0).round() as i16)
.map_err(|err| Error::Conversion(err.to_string()))?;
}
writer
.finalize()
.map_err(|err| Error::Conversion(err.to_string()))
}
fn spectrogram(audio: &Audio, limits: &Limits, start: Instant) -> Result<RgbImage> {
audio_spec(audio.rate, audio.channels)?;
audio_samples(audio.samples.len() as u64, limits)?;
let frames = audio.samples.len() / audio.channels;
if frames == 0 || !audio.samples.len().is_multiple_of(audio.channels) {
return Err(Error::Security("incomplete audio frames".into()));
}
let width = frames.div_ceil(256).clamp(1, MAX_COLUMNS);
let height = FFT_SIZE / 2 + 1;
let count = pixels(width as u32, height as u32, limits)?;
memory(
add(
add(mul(audio.samples.capacity() as u64, 4)?, mul(count, 3)?)?,
FFT_WORK_BYTES,
)?,
limits,
)?;
let mut image = RgbImage::new(width as u32, height as u32);
let mut planner = FftPlanner::<f32>::new();
let fft = planner.plan_fft_forward(FFT_SIZE);
memory(
add(
mul(fft.get_inplace_scratch_len() as u64, 8)?,
FFT_WORK_BYTES,
)?,
limits,
)?;
let mut scratch = vec![Complex::new(0.0, 0.0); fft.get_inplace_scratch_len()];
let mut window = vec![Complex::new(0.0, 0.0); FFT_SIZE];
for x in 0..width {
deadline(start, limits)?;
let offset = if width == 1 {
0
} else {
x.checked_mul(frames.saturating_sub(FFT_SIZE))
.ok_or_else(overflow)?
/ (width - 1)
};
for (n, value) in window.iter_mut().enumerate() {
let frame = offset.checked_add(n).ok_or_else(overflow)?;
let sample = if frame < frames {
let begin = frame.checked_mul(audio.channels).ok_or_else(overflow)?;
audio.samples[begin..begin + audio.channels]
.iter()
.map(|value| value.clamp(-1.0, 1.0) / audio.channels as f32)
.sum()
} else {
0.0
};
let hann = 0.5 - 0.5 * (std::f32::consts::TAU * n as f32 / FFT_SIZE as f32).cos();
*value = Complex::new(sample * hann, 0.0);
}
fft.process_with_scratch(&mut window, &mut scratch);
for (bin, value) in window.iter().take(height).enumerate() {
let magnitude = (value.norm() * 4.0 / FFT_SIZE as f32).max(1e-4);
let level = ((20.0 * magnitude.log10() + 80.0) / 80.0).clamp(0.0, 1.0);
let gray = (level * 255.0).round() as u8;
image.put_pixel(x as u32, (height - 1 - bin) as u32, Rgb([gray; 3]));
}
}
Ok(image)
}
fn synthesize(image: &DynamicImage, limits: &Limits, start: Instant) -> Result<Audio> {
let count = pixels(image.width(), image.height(), limits)?;
let columns = (image.width() as usize).min(MAX_COLUMNS);
let hop = FFT_SIZE / 2;
let length = columns
.checked_sub(1)
.and_then(|n| n.checked_mul(hop))
.and_then(|n| n.checked_add(FFT_SIZE))
.ok_or_else(overflow)?;
audio_samples(length as u64, limits)?;
if add(mul(length as u64, 2)?, 68)? > limits.max_output_bytes {
return Err(Error::Limit("synthesized WAVE output bytes".into()));
}
memory(
add(
add(mul(count, 16)?, mul(length as u64, 4)?)?,
FFT_WORK_BYTES,
)?,
limits,
)?;
let mut samples = vec![0.0f32; length];
let mut planner = FftPlanner::<f32>::new();
let fft = planner.plan_fft_inverse(FFT_SIZE);
memory(
add(
mul(fft.get_inplace_scratch_len() as u64, 8)?,
FFT_WORK_BYTES,
)?,
limits,
)?;
let mut scratch = vec![Complex::new(0.0, 0.0); fft.get_inplace_scratch_len()];
let mut spectrum = vec![Complex::new(0.0, 0.0); FFT_SIZE];
for column in 0..columns {
deadline(start, limits)?;
spectrum.fill(Complex::new(0.0, 0.0));
let x = u32::try_from(mul(column as u64, u64::from(image.width()))? / columns as u64)
.map_err(|_| overflow())?;
for bin in 1..FFT_SIZE / 2 {
let y = image.height()
- 1
- u32::try_from(
mul((bin - 1) as u64, u64::from(image.height() - 1))?
/ (FFT_SIZE / 2 - 2) as u64,
)
.map_err(|_| overflow())?;
let amplitude = luminance(image.get_pixel(x, y).0) / 255.0;
let phase = std::f32::consts::TAU
* ((bin as f32 * 0.618_034).fract()
+ (column * hop % FFT_SIZE) as f32 * bin as f32 / FFT_SIZE as f32);
let value = Complex::from_polar(amplitude, phase);
spectrum[bin] = value;
spectrum[FFT_SIZE - bin] = value.conj();
}
fft.process_with_scratch(&mut spectrum, &mut scratch);
let offset = column.checked_mul(hop).ok_or_else(overflow)?;
for (n, value) in spectrum.iter().enumerate() {
let hann = 0.5 - 0.5 * (std::f32::consts::TAU * n as f32 / FFT_SIZE as f32).cos();
samples[offset + n] += value.re * hann / FFT_SIZE as f32;
}
}
let peak = samples
.iter()
.fold(0.0f32, |peak, value| peak.max(value.abs()));
if peak > 0.0 {
for sample in &mut samples {
*sample = (*sample * (0.8 / peak)).clamp(-0.8, 0.8);
}
}
Ok(Audio {
samples,
rate: 22_050,
channels: 1,
})
}
fn luminance(rgba: [u8; 4]) -> f32 {
let alpha = f32::from(rgba[3]) / 255.0;
(0.2126 * f32::from(rgba[0]) + 0.7152 * f32::from(rgba[1]) + 0.0722 * f32::from(rgba[2]))
* alpha
+ 255.0 * (1.0 - alpha)
}
fn write_ascii(image: &DynamicImage, output: &mut Output, limits: &Limits) -> Result<()> {
let width = image.width().min(120);
let height = (mul(u64::from(image.height()), u64::from(width))?
/ mul(u64::from(image.width()), 2)?)
.max(1);
let bytes = mul(add(u64::from(width), 1)?, height)?;
if bytes > limits.max_output_bytes {
return Err(Error::Limit("ASCII image output bytes".into()));
}
const RAMP: &[u8] = b"@%#*+=-:. ";
let mut row = vec![b' '; width as usize + 1];
row[width as usize] = b'\n';
for y in 0..height {
for x in 0..width {
let source_x = mul(u64::from(x), u64::from(image.width()))? / u64::from(width);
let source_y = mul(y, u64::from(image.height()))? / height;
let light = luminance(image.get_pixel(source_x as u32, source_y as u32).0);
row[x as usize] = RAMP[(light / 255.0 * (RAMP.len() - 1) as f32).round() as usize];
}
output.write_all(&row)?;
}
Ok(())
}
fn text_cells(text: &[u8], mut visit: impl FnMut(u8, u32, u32)) -> Result<(u32, u32)> {
let (mut x, mut y, mut width) = (0u32, 0u32, 1u32);
for &byte in text {
if byte == b'\r' {
continue;
}
if byte == b'\n' {
x = 0;
y = y.checked_add(1).ok_or_else(overflow)?;
continue;
}
let repeat = if byte == b'\t' { 4 - x % 4 } else { 1 };
for _ in 0..repeat {
if x == 100 {
x = 0;
y = y.checked_add(1).ok_or_else(overflow)?;
}
visit(if byte == b'\t' { b' ' } else { byte }, x, y);
x += 1;
width = width.max(x);
}
}
Ok((width, y.checked_add(1).ok_or_else(overflow)?))
}
fn render_text(text: &[u8], limits: &Limits) -> Result<RgbImage> {
if text
.iter()
.any(|byte| !matches!(byte, b'\n' | b'\r' | b'\t' | 32..=126))
{
return Err(Error::Conversion(
"bitmap text supports printable ASCII only".into(),
));
}
let (columns, rows) = text_cells(text, |_, _, _| {})?;
let width = columns
.checked_mul(6)
.and_then(|n| n.checked_add(8))
.ok_or_else(overflow)?;
let height = rows
.checked_mul(8)
.and_then(|n| n.checked_add(8))
.ok_or_else(overflow)?;
let count = pixels(width, height, limits)?;
memory(add(mul(count, 32)?, text.len() as u64)?, limits)?;
let mut image = RgbImage::from_pixel(width, height, Rgb([255; 3]));
text_cells(text, |byte, x, y| {
for (row, bits) in glyph(byte.to_ascii_uppercase()).iter().enumerate() {
for column in 0..5 {
if bits & (1 << (4 - column)) != 0 {
image.put_pixel(4 + x * 6 + column, 4 + y * 8 + row as u32, Rgb([0; 3]));
}
}
}
})?;
Ok(image)
}
fn glyph(byte: u8) -> [u8; 7] {
match byte {
b'A' => [14, 17, 17, 31, 17, 17, 17],
b'B' => [30, 17, 17, 30, 17, 17, 30],
b'C' => [14, 17, 16, 16, 16, 17, 14],
b'D' => [30, 17, 17, 17, 17, 17, 30],
b'E' => [31, 16, 16, 30, 16, 16, 31],
b'F' => [31, 16, 16, 30, 16, 16, 16],
b'G' => [14, 17, 16, 23, 17, 17, 15],
b'H' => [17, 17, 17, 31, 17, 17, 17],
b'I' => [14, 4, 4, 4, 4, 4, 14],
b'J' => [7, 2, 2, 2, 18, 18, 12],
b'K' => [17, 18, 20, 24, 20, 18, 17],
b'L' => [16, 16, 16, 16, 16, 16, 31],
b'M' => [17, 27, 21, 21, 17, 17, 17],
b'N' => [17, 25, 21, 19, 17, 17, 17],
b'O' => [14, 17, 17, 17, 17, 17, 14],
b'P' => [30, 17, 17, 30, 16, 16, 16],
b'Q' => [14, 17, 17, 17, 21, 18, 13],
b'R' => [30, 17, 17, 30, 20, 18, 17],
b'S' => [15, 16, 16, 14, 1, 1, 30],
b'T' => [31, 4, 4, 4, 4, 4, 4],
b'U' => [17, 17, 17, 17, 17, 17, 14],
b'V' => [17, 17, 17, 17, 17, 10, 4],
b'W' => [17, 17, 17, 21, 21, 21, 10],
b'X' => [17, 17, 10, 4, 10, 17, 17],
b'Y' => [17, 17, 10, 4, 4, 4, 4],
b'Z' => [31, 1, 2, 4, 8, 16, 31],
b'0' => [14, 17, 19, 21, 25, 17, 14],
b'1' => [4, 12, 4, 4, 4, 4, 14],
b'2' => [14, 17, 1, 2, 4, 8, 31],
b'3' => [30, 1, 1, 14, 1, 1, 30],
b'4' => [2, 6, 10, 18, 31, 2, 2],
b'5' => [31, 16, 16, 30, 1, 1, 30],
b'6' => [14, 16, 16, 30, 17, 17, 14],
b'7' => [31, 1, 2, 4, 8, 8, 8],
b'8' => [14, 17, 17, 14, 17, 17, 14],
b'9' => [14, 17, 17, 15, 1, 1, 14],
b' ' => [0; 7],
b'.' => [0, 0, 0, 0, 0, 6, 6],
b',' => [0, 0, 0, 0, 6, 6, 4],
b':' => [0, 6, 6, 0, 6, 6, 0],
b';' => [0, 6, 6, 0, 6, 6, 4],
b'!' => [4, 4, 4, 4, 4, 0, 4],
b'-' => [0, 0, 0, 31, 0, 0, 0],
b'_' => [0, 0, 0, 0, 0, 0, 31],
b'+' => [0, 4, 4, 31, 4, 4, 0],
b'=' => [0, 0, 31, 0, 31, 0, 0],
b'/' => [1, 2, 2, 4, 8, 8, 16],
b'\\' => [16, 8, 8, 4, 2, 2, 1],
b'(' => [2, 4, 8, 8, 8, 4, 2],
b')' => [8, 4, 2, 2, 2, 4, 8],
b'[' => [14, 8, 8, 8, 8, 8, 14],
b']' => [14, 2, 2, 2, 2, 2, 14],
b'<' => [1, 2, 4, 8, 4, 2, 1],
b'>' => [16, 8, 4, 2, 4, 8, 16],
b'\'' => [4, 4, 8, 0, 0, 0, 0],
b'"' => [10, 10, 10, 0, 0, 0, 0],
b'#' => [10, 10, 31, 10, 31, 10, 10],
b'*' => [0, 21, 14, 31, 14, 21, 0],
b'|' => [4, 4, 4, 4, 4, 4, 4],
_ => [14, 17, 1, 2, 4, 0, 4],
}
}
fn write_pdf(
inputs: &[Artifact],
from: &str,
output: &mut Output,
limits: &Limits,
start: Instant,
) -> Result<()> {
let objects = add(mul(inputs.len() as u64, 3)?, 2)?;
memory(mul(add(objects, 1)?, 8)?, limits)?;
let mut offsets = Vec::new();
offsets
.try_reserve_exact(size(objects)?)
.map_err(|_| Error::Limit("PDF object table".into()))?;
output.write_all(b"%PDF-1.4\n")?;
offsets.push(output.position);
output.write_all(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n")?;
offsets.push(output.position);
write!(
output,
"2 0 obj\n<< /Type /Pages /Count {} /Kids [",
inputs.len()
)?;
for index in 0..inputs.len() {
write!(output, "{} 0 R ", add(mul(index as u64, 3)?, 3)?)?;
}
output.write_all(b"] >>\nendobj\n")?;
for (index, input) in inputs.iter().enumerate() {
deadline(start, limits)?;
let image = decode_image(&input.path, from, limits)?;
let width = image.width();
let height = image.height();
let bytes = mul(mul(u64::from(width), u64::from(height))?, 3)?;
let page = add(mul(index as u64, 3)?, 3)?;
let content = add(page, 1)?;
let bitmap = add(page, 2)?;
let scale = (792.0 / f64::from(width.max(height))).min(1.0);
let pw = f64::from(width) * scale;
let ph = f64::from(height) * scale;
offsets.push(output.position);
write!(
output,
"{page} 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 {pw:.6} {ph:.6}] /Resources << /XObject << /Im0 {bitmap} 0 R >> >> /Contents {content} 0 R >>\nendobj\n"
)?;
let commands = format!("q\n{pw:.6} 0 0 {ph:.6} 0 0 cm\n/Im0 Do\nQ\n");
offsets.push(output.position);
write!(
output,
"{content} 0 obj\n<< /Length {} >>\nstream\n{commands}endstream\nendobj\n",
commands.len()
)?;
offsets.push(output.position);
write!(
output,
"{bitmap} 0 obj\n<< /Type /XObject /Subtype /Image /Width {width} /Height {height} /ColorSpace /DeviceRGB /BitsPerComponent 8 /Length {bytes} >>\nstream\n"
)?;
let mut row = vec![0u8; size(mul(u64::from(width), 3)?)?];
for y in 0..height {
for (x, rgb) in row.chunks_exact_mut(3).enumerate() {
let rgba = image.get_pixel(x as u32, y).0;
let alpha = u32::from(rgba[3]);
for channel in 0..3 {
rgb[channel] = ((u32::from(rgba[channel]) * alpha + 255 * (255 - alpha) + 127)
/ 255) as u8;
}
}
output.write_all(&row)?;
}
output.write_all(b"\nendstream\nendobj\n")?;
}
let xref = output.position;
if xref > 9_999_999_999 {
return Err(Error::Limit("PDF cross-reference offset".into()));
}
write!(
output,
"xref\n0 {}\n0000000000 65535 f \n",
add(objects, 1)?
)?;
for offset in offsets {
writeln!(output, "{offset:010} 00000 n ")?;
}
write!(
output,
"trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n",
add(objects, 1)?
)?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn fixture_image() -> DynamicImage {
DynamicImage::ImageRgb8(RgbImage::from_fn(16, 12, |x, y| {
Rgb([(x * 13) as u8, (y * 17) as u8, 80])
}))
}
fn save_image(image: &DynamicImage, path: &Path, id: &str) -> Result<()> {
let limits = Limits::default();
let mut output = Output::create(path, limits.max_output_bytes, Instant::now(), &limits)?;
let result = encode_image(image, id, &mut output, &limits, None);
output.finish(result)
}
fn sine_audio() -> Audio {
Audio {
samples: (0..4096)
.map(|n| 0.7 * (std::f32::consts::TAU * 512.0 * n as f32 / 8192.0).sin())
.collect(),
rate: 8192,
channels: 1,
}
}
fn save_audio(audio: &Audio, path: &Path) -> Result<()> {
let limits = Limits::default();
let mut output = Output::create(path, limits.max_output_bytes, Instant::now(), &limits)?;
let result = write_wav(audio, &mut output, &limits);
output.finish(result)
}
#[tokio::test]
async fn adapter_image_roundtrip() -> Result<()> {
let input_dir = tempfile::tempdir()?;
let output_dir = tempfile::tempdir()?;
let input = input_dir.path().join("input.png");
let original = fixture_image();
save_image(&original, &input, "png")?;
let request = StepRequest::new(
vec![Artifact::new(input, "png".to_owned())],
output_dir.path().to_path_buf(),
"png".to_owned(),
"webp".to_owned(),
"image-transcode".to_owned(),
Limits::default(),
);
let artifacts = MediaAdapter.convert(&request).await?;
assert_eq!(artifacts.len(), 1);
let decoded = decode_image(&artifacts[0].path, "webp", &request.limits)?;
assert_eq!(decoded.to_rgb8(), original.to_rgb8());
Ok(())
}
#[test]
fn advertised_image_encoders_produce_readable_files() -> Result<()> {
let dir = tempfile::tempdir()?;
for &(id, _, _, format) in IMAGES {
if format == ImageFormat::Dds {
continue;
}
let path = dir.path().join(format!("image.{id}"));
save_image(&fixture_image(), &path, id)?;
let decoded = decode_image(&path, id, &Limits::default())?;
assert_eq!(decoded.dimensions(), (16, 12), "{id}");
}
Ok(())
}
#[test]
fn wave_roundtrip_and_spectrogram_frequency() -> Result<()> {
let dir = tempfile::tempdir()?;
let path = dir.path().join("sine.wav");
let original = sine_audio();
save_audio(&original, &path)?;
let limits = Limits::default();
let decoded = decode_audio(&path, "wav", &limits, Instant::now())?;
assert_eq!(decoded.rate, original.rate);
assert_eq!(decoded.channels, 1);
assert_eq!(decoded.samples.len(), original.samples.len());
for (before, after) in original.samples.iter().zip(&decoded.samples) {
assert!((before - after).abs() < 0.0001);
}
let image = spectrogram(&decoded, &limits, Instant::now())?;
let peak = (0..image.height())
.max_by_key(|&y| image.get_pixel(3, y).0[0])
.ok_or_else(|| Error::Invalid("empty spectrogram".into()))?;
assert_eq!(image.height() - 1 - peak, 64);
assert!(image.get_pixel(3, peak).0[0] > 230);
Ok(())
}
#[test]
fn synthesis_is_finite_bounded_and_respects_sample_limits() -> Result<()> {
let image = fixture_image();
let audio = synthesize(&image, &Limits::default(), Instant::now())?;
assert_eq!(audio.rate, 22_050);
assert_eq!(audio.channels, 1);
assert_eq!(audio.samples.len(), 15 * 512 + 1024);
assert!(
audio
.samples
.iter()
.all(|sample| sample.is_finite() && sample.abs() <= 0.8)
);
assert!(audio.samples.iter().any(|sample| sample.abs() > 0.1));
let limits = Limits {
max_audio_samples: 100,
..Limits::default()
};
assert!(matches!(
synthesize(&image, &limits, Instant::now()),
Err(Error::Limit(_))
));
let black = DynamicImage::ImageRgb8(RgbImage::new(1, 1));
let silence = synthesize(&black, &Limits::default(), Instant::now())?;
assert!(silence.samples.iter().all(|&sample| sample == 0.0));
Ok(())
}
#[test]
fn huge_corrupt_dimensions_are_rejected_before_decode() -> Result<()> {
let dir = tempfile::tempdir()?;
let path = dir.path().join("huge.png");
let mut header = b"\x89PNG\r\n\x1a\n\0\0\0\rIHDR".to_vec();
header.extend_from_slice(&u32::MAX.to_be_bytes());
header.extend_from_slice(&u32::MAX.to_be_bytes());
fs::write(&path, header)?;
assert!(matches!(
decode_image(&path, "png", &Limits::default()),
Err(Error::Limit(_))
));
fs::write(&path, b"not a PNG")?;
assert!(matches!(
decode_image(&path, "png", &Limits::default()),
Err(Error::Security(_))
));
save_image(&fixture_image(), &dir.path().join("valid.png"), "png")?;
let limits = Limits {
max_pixels: 10,
..Limits::default()
};
assert!(matches!(
decode_image(&dir.path().join("valid.png"), "png", &limits),
Err(Error::Limit(_))
));
Ok(())
}
#[test]
fn malformed_audio_fails_closed() -> Result<()> {
let dir = tempfile::tempdir()?;
let path = dir.path().join("bad.wav");
fs::write(&path, b"RIFF\xff\xff\xff\xffWAVEdata")?;
assert!(matches!(
decode_audio(&path, "wav", &Limits::default(), Instant::now()),
Err(Error::Security(_))
));
let valid = dir.path().join("valid.wav");
save_audio(&sine_audio(), &valid)?;
let mut truncated = fs::read(&valid)?;
truncated.truncate(truncated.len() - 3);
fs::write(&path, truncated)?;
assert!(matches!(
decode_audio(&path, "wav", &Limits::default(), Instant::now()),
Err(Error::Security(_))
));
assert!(audio_spec(0, 2).is_err());
assert!(audio_spec(384_000, 2).is_err());
assert!(audio_spec(48_000, 0).is_err());
assert!(audio_spec(48_000, 9).is_err());
let mut invalid_rate = fs::read(&valid)?;
invalid_rate[24..28].copy_from_slice(&0u32.to_le_bytes());
fs::write(&path, invalid_rate)?;
assert!(matches!(
decode_audio(&path, "wav", &Limits::default(), Instant::now()),
Err(Error::Security(_))
));
Ok(())
}
#[test]
fn audio_sample_limit_includes_every_channel() -> Result<()> {
let dir = tempfile::tempdir()?;
let path = dir.path().join("stereo.wav");
save_audio(
&Audio {
samples: vec![0.0; 2048],
channels: 2,
rate: 44_100,
},
&path,
)?;
let limits = Limits {
max_audio_samples: 1500,
..Limits::default()
};
assert!(matches!(
decode_audio(&path, "wav", &limits, Instant::now()),
Err(Error::Limit(_))
));
Ok(())
}
#[tokio::test]
async fn output_limit_is_not_downgraded_and_partial_file_is_removed() -> Result<()> {
let input_dir = tempfile::tempdir()?;
let output_dir = tempfile::tempdir()?;
let input = input_dir.path().join("input.png");
save_image(&fixture_image(), &input, "png")?;
let request = StepRequest::new(
vec![Artifact::new(input, "png".to_owned())],
output_dir.path().to_path_buf(),
"png".to_owned(),
"bmp".to_owned(),
"image-transcode".to_owned(),
Limits {
max_output_bytes: 16,
..Limits::default()
},
);
assert!(matches!(
MediaAdapter.convert(&request).await,
Err(Error::Limit(_))
));
assert_eq!(fs::read_dir(output_dir.path())?.count(), 0);
Ok(())
}
#[test]
fn text_renderer_is_bounded_and_rejects_unsupported_text() -> Result<()> {
let image = render_text(b"Hello\n123", &Limits::default())?;
assert_eq!(image.dimensions(), (38, 24));
assert!(image.pixels().any(|pixel| pixel.0 == [0; 3]));
assert!(render_text(&[0xff], &Limits::default()).is_err());
let limits = Limits {
max_pixels: 100,
..Limits::default()
};
assert!(matches!(
render_text(b"Too many pixels", &limits),
Err(Error::Limit(_))
));
Ok(())
}
#[test]
fn table_and_arithmetic_guards_match_advertised_edges() -> Result<()> {
let adapter = MediaAdapter;
assert_eq!(adapter.name(), "media");
let formats = adapter.formats();
assert_eq!(formats.len(), IMAGES.len() + AUDIO.len() + 2);
assert!(
formats
.iter()
.any(|f| f.id == "pdf" && f.media == MediaKind::Document)
);
assert!(
formats
.iter()
.any(|f| f.id == "txt" && f.media == MediaKind::Text)
);
let edges = adapter.conversions();
assert!(
edges
.iter()
.any(|e| e.from == "png" && e.to == "jpeg" && e.operation == "image-transcode")
);
assert!(
!edges
.iter()
.any(|e| e.from == "png" && e.to == "dds" && e.operation == "image-transcode")
);
assert!(edges.iter().any(|e| e.operation == "image-ascii"));
assert!(edges.iter().any(|e| e.operation == "image-synthesis"));
assert!(edges.iter().any(|e| e.operation == "image-pdf"));
assert!(edges.iter().any(|e| e.operation == "audio-wav"));
assert!(
edges
.iter()
.any(|e| e.from == "wav" && e.to == "wav" && e.kind == ConversionKind::Reencode)
);
assert!(
!edges
.iter()
.any(|e| e.from == "wav" && e.to == "wav" && e.kind == ConversionKind::Lossy)
);
assert!(edges.iter().any(|e| e.operation == "audio-spectrogram"));
assert!(
edges
.iter()
.any(|e| e.from == "txt" && e.to == "png" && e.operation == "text-bitmap")
);
assert!(matches!(overflow(), Error::Limit(_)));
assert!(add(1, u64::MAX).is_err());
assert!(mul(1 << 40, 1 << 40).is_err());
if cfg!(target_pointer_width = "32") {
assert!(size(u64::MAX).is_err());
}
assert_eq!(
size(u64::from(u32::MAX)).ok(),
usize::try_from(u64::from(u32::MAX)).ok()
);
assert!(memory(0, &Limits::default()).is_ok());
let huge = Limits {
max_memory_bytes: 1_000,
..Limits::default()
};
assert!(matches!(memory(1_001, &huge), Err(Error::Limit(_))));
assert!(matches!(
memory(isize::MAX as u64 + 1, &Limits::default()),
Err(Error::Limit(_))
));
assert!(matches!(
pixels(0, 1, &Limits::default()),
Err(Error::Security(_))
));
assert!(matches!(
pixels(1, 0, &Limits::default()),
Err(Error::Security(_))
));
let tight = Limits {
max_pixels: 1,
..Limits::default()
};
assert!(matches!(pixels(2, 2, &tight), Err(Error::Limit(_))));
assert!(matches!(
pixels(70_000, 1, &Limits::default()),
Err(Error::Limit(_))
));
assert!(deadline(Instant::now(), &Limits::default()).is_ok());
let expired = Limits {
timeout: std::time::Duration::ZERO,
..Limits::default()
};
assert!(matches!(
deadline(Instant::now(), &expired),
Err(Error::Timeout { .. })
));
assert_eq!(image_format("png")?, ImageFormat::Png);
assert!(matches!(image_format("nope"), Err(Error::Invalid(_))));
Ok(())
}
#[test]
fn codec_error_mappers_classify_by_kind() {
let unsupported =
image::ImageError::Unsupported(image::error::UnsupportedError::from_format_and_kind(
image::error::ImageFormatHint::Unknown,
image::error::UnsupportedErrorKind::GenericFeature("nope".into()),
));
assert!(matches!(image_error(unsupported), Error::Conversion(_)));
let decoding = image::ImageError::Decoding(image::error::DecodingError::from_format_hint(
image::error::ImageFormatHint::Unknown,
));
assert!(matches!(image_error(decoding), Error::Security(_)));
let truncated =
image::ImageError::IoError(io::Error::new(io::ErrorKind::UnexpectedEof, "eof"));
assert!(matches!(image_error(truncated), Error::Security(_)));
let other_io =
image::ImageError::IoError(io::Error::new(io::ErrorKind::PermissionDenied, "denied"));
assert!(matches!(image_error(other_io), Error::Io(_)));
assert!(matches!(
audio_error(AudioError::LimitError("cap")),
Error::Limit(_)
));
assert!(matches!(
audio_error(AudioError::Unsupported("codec")),
Error::Conversion(_)
));
assert!(matches!(
audio_error(AudioError::DecodeError("broken")),
Error::Security(_)
));
}
#[test]
fn input_reader_guards_regular_files_and_sizes() -> Result<()> {
let dir = tempfile::tempdir()?;
assert!(matches!(
read_input(dir.path(), &Limits::default()),
Err(Error::Security(_))
));
let file = dir.path().join("payload.bin");
fs::write(&file, b"12345678")?;
let large = dir.path().join("large.bin");
fs::write(&large, vec![7u8; 64])?;
let tight = Limits {
max_input_bytes: 16,
..Limits::default()
};
assert!(matches!(read_input(&large, &tight), Err(Error::Limit(_))));
let small = Limits {
max_memory_bytes: 8,
..Limits::default()
};
assert!(matches!(read_input(&file, &small), Err(Error::Limit(_))));
assert_eq!(read_input(&file, &Limits::default())?, b"12345678");
#[cfg(unix)]
{
let link = dir.path().join("link.bin");
std::os::unix::fs::symlink(&file, &link)?;
assert!(matches!(
read_input(&link, &Limits::default()),
Err(Error::Security(_))
));
}
Ok(())
}
#[test]
fn output_tracker_isolates_deadline_capacity_and_seek() -> Result<()> {
let dir = tempfile::tempdir()?;
let path = dir.path().join("out.bin");
let tight = Limits {
timeout: std::time::Duration::ZERO,
..Limits::default()
};
let mut output = Output::create(&path, u64::MAX, Instant::now(), &tight)?;
assert!(output.write_all(b"x").is_err());
assert!(matches!(output.finish(Ok(())), Err(Error::Timeout { .. })));
drop(output);
fs::remove_file(&path)?;
let mut output = Output::create(&path, 3, Instant::now(), &Limits::default())?;
assert!(output.write_all(b"toolong").is_err());
assert!(matches!(
output.finish(Err(Error::Io(io::Error::other("x")))),
Err(Error::Limit(_))
));
drop(output);
fs::remove_file(&path)?;
let mut output = Output::create(&path, u64::MAX, Instant::now(), &Limits::default())?;
output.write_all(b"0123456789")?;
assert_eq!(output.seek(SeekFrom::Start(4))?, 4);
assert_eq!(output.seek(SeekFrom::Current(2))?, 6);
assert_eq!(output.seek(SeekFrom::End(-4))?, 6);
assert!(output.seek(SeekFrom::Start(u64::MAX)).is_err());
assert!(output.seek(SeekFrom::Current(-100)).is_err());
let result = output.finish(Err(Error::Security("bad".into())));
assert!(matches!(result, Err(Error::Security(_))));
drop(output);
let again = dir.path().join("twice.bin");
fs::write(&again, b"exists")?;
assert!(matches!(
Output::create(&again, u64::MAX, Instant::now(), &Limits::default()),
Err(Error::Io(_))
));
Ok(())
}
fn wav_with_chunks(after_header: &[(&str, &[u8])], riff_len: u32) -> Vec<u8> {
let mut chunks = Vec::new();
for (id, body) in after_header {
chunks.extend_from_slice(id.as_bytes());
chunks.extend_from_slice(&(body.len() as u32).to_le_bytes());
chunks.extend_from_slice(body);
if body.len() % 2 == 1 {
chunks.push(0);
}
}
let mut bytes = b"RIFF".to_vec();
bytes.extend_from_slice(&riff_len.to_le_bytes());
bytes.extend_from_slice(b"WAVE");
bytes.extend(chunks);
bytes
}
fn fmt_chunk(codec: u16, channels: u16, rate: u32, align: u16, bits: u16) -> Vec<u8> {
let mut body = Vec::new();
body.extend_from_slice(&codec.to_le_bytes());
body.extend_from_slice(&channels.to_le_bytes());
body.extend_from_slice(&rate.to_le_bytes());
body.extend_from_slice(&(rate * u32::from(channels) * u32::from(bits / 8)).to_le_bytes());
body.extend_from_slice(&align.to_le_bytes());
body.extend_from_slice(&bits.to_le_bytes());
body
}
#[test]
fn wav_validator_rejects_malformed_chunk_layouts() -> Result<()> {
assert!(matches!(validate_wav(b"short"), Err(Error::Security(_))));
assert!(matches!(
validate_wav(b"RIFF\x10\x00\x00\x00WAVE"),
Err(Error::Security(_))
));
let body = fmt_chunk(1, 1, 8_000, 2, 16);
let valid = wav_with_chunks(&[("fmt ", &body), ("data", b"\0\0\0\0")], u32::MAX);
assert!(matches!(validate_wav(&valid), Err(Error::Security(_))));
let exact = |chunks: Vec<(&str, Vec<u8>)>, _total: usize| {
let borrowed: Vec<(&str, &[u8])> = chunks
.iter()
.map(|(id, body)| (*id, body.as_slice()))
.collect();
let size: usize = chunks
.iter()
.map(|(_, body)| 8 + body.len() + (body.len() % 2))
.sum();
wav_with_chunks(&borrowed, (4 + size) as u32)
};
for (label, bytes) in [
(
"fmt too short",
exact(vec![("fmt ", vec![0u8; 8]), ("data", vec![0; 4])], 22),
),
(
"duplicate fmt",
exact(
vec![
("fmt ", body.clone()),
("fmt ", body.clone()),
("data", vec![0; 4]),
],
16 + body.len() * 2 + 4,
),
),
(
"zero block align",
exact(
vec![
("fmt ", fmt_chunk(1, 1, 8_000, 0, 16)),
("data", vec![0; 4]),
],
16 + 16 + 4,
),
),
(
"bad bit depth",
exact(
vec![("fmt ", fmt_chunk(1, 1, 8_000, 1, 7)), ("data", vec![0; 4])],
16 + 16 + 4,
),
),
(
"float with 16 bits",
exact(
vec![
("fmt ", fmt_chunk(3, 1, 8_000, 2, 16)),
("data", vec![0; 4]),
],
16 + 16 + 4,
),
),
(
"alignment mismatch",
exact(
vec![
("fmt ", fmt_chunk(1, 2, 8_000, 3, 16)),
("data", vec![0; 4]),
],
16 + 16 + 4,
),
),
("data without format", exact(vec![("data", vec![0; 4])], 4)),
(
"empty data",
exact(
vec![("fmt ", body.clone()), ("data", vec![])],
16 + body.len(),
),
),
(
"data crosses frame",
exact(
vec![("fmt ", body.clone()), ("data", vec![0u8; 5])],
16 + body.len() + 6,
),
),
(
"duplicate data",
exact(
vec![
("fmt ", body.clone()),
("data", vec![0; 4]),
("data", vec![0; 4]),
],
16 + body.len() + 8,
),
),
(
"chunk runs past eof",
exact(vec![("fmt ", body.clone())], 8_000),
),
("missing chunks", b"RIFF\x04\x00\x00\x00WAVE".to_vec()),
] {
let expected_len = bytes.len();
let bytes = if label == "chunk runs past eof" {
let mut copy = bytes.clone();
copy.truncate(copy.len() - 8);
copy
} else {
bytes
};
let mut bytes = bytes;
if label != "missing chunks" && label != "chunk runs past eof" {
let len = (bytes.len() - 8) as u32;
bytes[4..8].copy_from_slice(&len.to_le_bytes());
}
let _ = expected_len;
assert!(
matches!(validate_wav(&bytes), Err(Error::Security(_))),
"{label}"
);
}
let sound = wav_with_chunks(
&[("fmt ", &body), ("data", b"\0\0\0\0")],
(4 + (8 + body.len()) + (8 + 4)) as u32,
);
validate_wav(&sound)?;
Ok(())
}
#[test]
fn wave_writer_guards_samples_and_capacity() -> Result<()> {
let dir = tempfile::tempdir()?;
let path = dir.path().join("guard.wav");
let limits = Limits::default();
for (label, audio) in [
(
"empty",
Audio {
samples: vec![],
rate: 8_000,
channels: 1,
},
),
(
"half frame",
Audio {
samples: vec![0.1, 0.2, 0.3],
rate: 8_000,
channels: 2,
},
),
(
"non-finite",
Audio {
samples: vec![f32::NAN],
rate: 8_000,
channels: 1,
},
),
] {
let mut output = Output::create(
&dir.path().join(format!("{label}.wav")),
u64::MAX,
Instant::now(),
&limits,
)?;
assert!(
matches!(
write_wav(&audio, &mut output, &limits),
Err(Error::Security(_))
),
"{label}"
);
}
let mut output = Output::create(&path, u64::MAX, Instant::now(), &limits)?;
let audio = Audio {
samples: vec![0.5, -2.0, 3.0],
rate: 8_000,
channels: 1,
};
write_wav(&audio, &mut output, &limits)?;
output.finish(Ok(()))?;
drop(output);
let decoded = decode_audio(&path, "wav", &limits, Instant::now())?;
assert_eq!(decoded.samples.len(), 3);
assert!((decoded.samples[0] - 0.5).abs() < 1e-3);
assert!((decoded.samples[1] + 1.0).abs() < 1e-3);
assert!((decoded.samples[2] - 1.0).abs() < 1e-3);
let tiny = Limits {
max_output_bytes: 16,
..Limits::default()
};
let mut output =
Output::create(&dir.path().join("cap.wav"), u64::MAX, Instant::now(), &tiny)?;
assert!(matches!(
write_wav(&audio, &mut output, &tiny),
Err(Error::Limit(_))
));
let bad_rate = Audio {
samples: vec![0.0, 0.0],
rate: 1,
channels: 2,
};
assert!(matches!(
write_wav(
&bad_rate,
&mut Output::create(
&dir.path().join("rate.wav"),
u64::MAX,
Instant::now(),
&limits
)?,
&limits
),
Err(Error::Security(_))
));
assert_eq!(fs::read(&path)?.len(), 3 * 2 + 44);
Ok(())
}
#[test]
fn spectrogram_clamps_columns_and_rejects_frames_mismatch() -> Result<()> {
let limits = Limits::default();
let short_speech = Audio {
samples: (0..600).map(|n| (n as f32 / 40.0).sin()).collect(),
rate: 8_192,
channels: 1,
};
let image = spectrogram(&short_speech, &limits, Instant::now())?;
assert_eq!(image.width(), 3);
assert_eq!(image.height(), (FFT_SIZE / 2 + 1) as u32);
let wide = Audio {
samples: vec![0.0; 256 * (MAX_COLUMNS + 5) + 1024],
rate: 8_192,
channels: 1,
};
let image = spectrogram(&wide, &limits, Instant::now())?;
assert_eq!(image.width() as usize, MAX_COLUMNS);
assert!(matches!(
spectrogram(
&Audio {
samples: vec![0.0; 3],
rate: 8_000,
channels: 2
},
&limits,
Instant::now()
),
Err(Error::Security(_))
));
assert!(matches!(
spectrogram(
&Audio {
samples: vec![],
rate: 8_000,
channels: 1
},
&limits,
Instant::now()
),
Err(Error::Security(_))
));
Ok(())
}
#[test]
fn ascii_and_bitmap_bridges_render_every_glyph_and_wrap() -> Result<()> {
let printable: Vec<u8> = (32u8..=126).collect();
let bitmap = render_text(&printable, &Limits::default())?;
assert!(bitmap.width() > 6 * 95);
let tabbed = render_text(b"a\tb\rc\r\nd", &Limits::default())?;
assert!(tabbed.width() > 0);
let wrap = render_text(&vec![b'A'; 250], &Limits::default())?;
assert!(wrap.height() >= 3 * 8);
let (cells, rows) = text_cells(b"x\n\tyz\r", |_, _, _| {})?;
assert_eq!((cells, rows), (6, 2));
assert_eq!(text_cells(b"", |_, _, _| {})?, (1, 1));
let dir = tempfile::tempdir()?;
let png = dir.path().join("ascii.png");
save_image(&fixture_image(), &png, "png")?;
let step = StepRequest::new(
vec![Artifact::new(png.clone(), "png".to_owned())],
dir.path().join("out").clone(),
"png".to_owned(),
"txt".to_owned(),
"image-ascii".to_owned(),
Limits::default(),
);
fs::create_dir_all(&step.output_dir)?;
let artifacts = convert_blocking(&step)?;
let ascii = fs::read(&artifacts[0].path)?;
assert!(ascii.contains(&b'@'));
assert!(
ascii
.iter()
.any(|byte| matches!(byte, b'#' | b'*' | b'+' | b'='))
);
let narrow = Limits {
max_output_bytes: 4,
..Limits::default()
};
let mut output = Output::create(
&dir.path().join("tiny.txt"),
u64::MAX,
Instant::now(),
&narrow,
)?;
assert!(matches!(
write_ascii(&fixture_image(), &mut output, &narrow),
Err(Error::Limit(_))
));
Ok(())
}
#[test]
fn pdf_has_multiple_pages_and_correct_xref_offsets() -> Result<()> {
let dir = tempfile::tempdir()?;
let input = dir.path().join("input.png");
save_image(&fixture_image(), &input, "png")?;
let inputs = vec![Artifact::new(input, "png".to_owned()); 2];
let path = dir.path().join("pages.pdf");
let limits = Limits::default();
let mut output = Output::create(&path, limits.max_output_bytes, Instant::now(), &limits)?;
let result = write_pdf(&inputs, "png", &mut output, &limits, Instant::now());
output.finish(result)?;
drop(output);
let bytes = fs::read(path)?;
assert!(bytes.starts_with(b"%PDF-1.4\n"));
assert!(bytes.windows(8).any(|window| window == b"/Count 2"));
let startxref = bytes
.windows(10)
.rposition(|window| window == b"startxref\n")
.ok_or_else(|| Error::Invalid("missing startxref".into()))?;
let suffix = std::str::from_utf8(&bytes[startxref + 10..])
.map_err(|err| Error::Invalid(err.to_string()))?;
let offset: usize = suffix
.lines()
.next()
.ok_or_else(|| Error::Invalid("missing offset".into()))?
.parse()
.map_err(|err: std::num::ParseIntError| Error::Invalid(err.to_string()))?;
let xref =
std::str::from_utf8(&bytes[offset..]).map_err(|err| Error::Invalid(err.to_string()))?;
assert!(xref.starts_with("xref\n0 9\n"));
for (index, line) in xref.lines().skip(3).take(8).enumerate() {
let object_offset: usize = line[..10]
.parse()
.map_err(|err: std::num::ParseIntError| Error::Invalid(err.to_string()))?;
assert!(
bytes[object_offset..].starts_with(format!("{} 0 obj\n", index + 1).as_bytes())
);
}
Ok(())
}
}