use std::fs;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use crate::process;
use crate::{
Adapter, Artifact, BackendStatus, Conversion, ConversionFuture, ConversionKind, Error, Format,
MediaKind, Result, StepRequest,
};
const VIDEO: &[(&str, &str)] = &[
("mp4", "MPEG-4 video"),
("mkv", "Matroska video"),
("avi", "AVI video"),
("webm", "WebM video"),
("mov", "QuickTime video"),
("mpg", "MPEG video"),
];
const AUDIO: &[&str] = &["wav", "mp3", "flac", "aac", "ogg", "m4a"];
const FRAME_IMAGES: &[&str] = &["png", "jpeg", "gif", "bmp"];
const RASTER_IMAGES: &[&str] = &[
"png", "jpeg", "gif", "webp", "tiff", "bmp", "pnm", "tga", "ico", "dds", "qoi", "hdr",
"farbfeld",
];
const OFFICE: &[(&str, &str)] = &[
("doc", "Microsoft Word document"),
("docx", "Office Open XML document"),
("odt", "OpenDocument text"),
("rtf", "Rich Text Format document"),
("xls", "Microsoft Excel workbook"),
("xlsx", "Office Open XML workbook"),
("ods", "OpenDocument spreadsheet"),
("ppt", "Microsoft PowerPoint presentation"),
("pptx", "Office Open XML presentation"),
("odp", "OpenDocument presentation"),
("html", "HTML document"),
];
const OFFICE_FAMILIES: &[&[&str]] = &[
&["doc", "docx", "odt", "rtf", "html"],
&["xls", "xlsx", "ods"],
&["ppt", "pptx", "odp"],
];
pub async fn discover() -> Vec<Arc<dyn Adapter>> {
let mut adapters: Vec<Arc<dyn Adapter>> = Vec::new();
if process::available("ffmpeg").await {
adapters.push(Arc::new(FfmpegAdapter));
}
if process::available("convert").await {
adapters.push(Arc::new(ImageMagickAdapter));
}
let pdftotext = process::available("pdftotext").await;
let pdftoppm = process::available("pdftoppm").await;
if pdftotext || pdftoppm {
adapters.push(Arc::new(PopplerAdapter {
pdftotext,
pdftoppm,
}));
}
if process::available("soffice").await {
adapters.push(Arc::new(SofficeAdapter));
}
if process::available("inkscape").await {
adapters.push(Arc::new(InkscapeAdapter));
}
adapters
}
struct FfmpegAdapter;
impl Adapter for FfmpegAdapter {
fn name(&self) -> &str {
"ffmpeg"
}
fn formats(&self) -> Vec<Format> {
let mut formats = VIDEO
.iter()
.map(|(id, name)| Format::new(id, name, MediaKind::Video).with_extensions(&[id]))
.collect::<Vec<_>>();
formats.extend(AUDIO.iter().map(|id| Format::new(id, id, MediaKind::Audio)));
formats.extend(
FRAME_IMAGES
.iter()
.map(|id| Format::new(id, id, MediaKind::Image)),
);
formats
}
fn conversions(&self) -> Vec<Conversion> {
let mut edges = Vec::new();
for from in AUDIO {
for to in AUDIO {
if from != to {
edges.push(external_edge(
from,
to,
"ffmpeg-transcode",
ConversionKind::Lossy,
30,
));
}
}
}
for (from, _) in VIDEO {
for (to, _) in VIDEO {
if from != to {
edges.push(external_edge(
from,
to,
"ffmpeg-transcode",
ConversionKind::Lossy,
35,
));
}
}
for to in AUDIO {
edges.push(external_edge(
from,
to,
"ffmpeg-audio",
ConversionKind::Lossy,
35,
));
}
for to in FRAME_IMAGES {
edges.push(external_edge(
from,
to,
"ffmpeg-frame",
ConversionKind::Lossy,
40,
));
}
}
for from in ["png", "jpeg"] {
for (to, _) in VIDEO {
edges.push(external_edge(
from,
to,
"ffmpeg-still",
ConversionKind::Bridge,
55,
));
}
}
edges
}
fn convert<'a>(&'a self, request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async move {
let input = one_input(request)?;
let output = output_path(request, &request.to);
let input_name = path_string(&input.path);
let output_name = path_string(&output);
let mut args = vec![
"-hide_banner".into(),
"-loglevel".into(),
"error".into(),
"-nostdin".into(),
"-y".into(),
];
match request.operation.as_str() {
"ffmpeg-transcode" => {
args.extend(["-i".into(), input_name]);
if request.to == "mpg" {
args.extend(["-r".into(), "25".into()]);
}
args.push(output_name);
}
"ffmpeg-audio" => {
args.extend(["-i".into(), input_name, "-vn".into(), output_name]);
}
"ffmpeg-frame" => {
args.extend([
"-i".into(),
input_name,
"-map".into(),
"0:v:0".into(),
"-frames:v".into(),
"1".into(),
output_name,
]);
}
"ffmpeg-still" => {
args.extend([
"-loop".into(),
"1".into(),
"-i".into(),
input_name,
"-t".into(),
"1".into(),
"-r".into(),
if request.to == "mpg" {
"25".into()
} else {
"1".into()
},
"-pix_fmt".into(),
"yuv420p".into(),
output_name,
]);
}
other => return Err(Error::Invalid(format!("unknown ffmpeg operation: {other}"))),
}
process::run("ffmpeg", "ffmpeg", &args, None, &request.limits).await?;
artifact_if_regular(output, &request.to, &request.limits)
})
}
}
struct ImageMagickAdapter;
impl Adapter for ImageMagickAdapter {
fn name(&self) -> &str {
"imagemagick"
}
fn formats(&self) -> Vec<Format> {
let mut formats = RASTER_IMAGES
.iter()
.map(|id| Format::new(id, id, MediaKind::Image))
.collect::<Vec<_>>();
formats.extend([
Format::new("exr", "OpenEXR image", MediaKind::Image).with_extensions(&["exr"]),
Format::new("psd", "Photoshop document", MediaKind::Image).with_extensions(&["psd"]),
]);
formats
}
fn conversions(&self) -> Vec<Conversion> {
let mut edges = Vec::new();
for source in ["exr", "psd"] {
for target in RASTER_IMAGES {
edges.push(external_edge(
source,
target,
"image-transcode",
ConversionKind::Lossy,
45,
));
}
}
for source in RASTER_IMAGES {
for target in ["exr", "psd"] {
edges.push(external_edge(
source,
target,
"image-transcode",
ConversionKind::Lossy,
45,
));
}
}
edges
}
fn convert<'a>(&'a self, request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async move {
if request.operation != "image-transcode" {
return Err(Error::Invalid(format!(
"unknown ImageMagick operation: {}",
request.operation
)));
}
let input = one_input(request)?;
let output = output_path(request, &request.to);
let args = vec![path_string(&input.path), path_string(&output)];
process::run("imagemagick", "convert", &args, None, &request.limits).await?;
artifact_if_regular(output, &request.to, &request.limits)
})
}
}
struct PopplerAdapter {
pdftotext: bool,
pdftoppm: bool,
}
impl Adapter for PopplerAdapter {
fn name(&self) -> &str {
"poppler"
}
fn formats(&self) -> Vec<Format> {
vec![
Format::new("pdf", "PDF document", MediaKind::Document),
Format::new("txt", "Plain text", MediaKind::Text),
Format::new("png", "PNG image", MediaKind::Image),
]
}
fn conversions(&self) -> Vec<Conversion> {
let mut edges = Vec::new();
if self.pdftotext {
edges.push(external_edge(
"pdf",
"txt",
"pdf-text",
ConversionKind::Bridge,
25,
));
}
if self.pdftoppm {
edges.push(external_edge(
"pdf",
"png",
"pdf-raster",
ConversionKind::Lossy,
30,
));
}
edges
}
fn status(&self) -> BackendStatus {
BackendStatus {
name: self.name().to_owned(),
available: self.pdftotext || self.pdftoppm,
detail: format!("pdftotext={}, pdftoppm={}", self.pdftotext, self.pdftoppm),
}
}
fn convert<'a>(&'a self, request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async move {
let input = one_input(request)?;
match request.operation.as_str() {
"pdf-text" if self.pdftotext => {
let output = output_path(request, "txt");
let args = vec![path_string(&input.path), path_string(&output)];
process::run("poppler", "pdftotext", &args, None, &request.limits).await?;
artifact_if_regular(output, "txt", &request.limits)
}
"pdf-raster" if self.pdftoppm => {
let output = output_path(request, "png");
let prefix = output.with_extension("");
let args = vec![
"-png".into(),
"-f".into(),
"1".into(),
"-l".into(),
"1".into(),
"-singlefile".into(),
path_string(&input.path),
path_string(&prefix),
];
process::run("poppler", "pdftoppm", &args, None, &request.limits).await?;
artifact_if_regular(output, "png", &request.limits)
}
other => Err(Error::Invalid(format!(
"unsupported or unavailable Poppler operation: {other}"
))),
}
})
}
}
struct SofficeAdapter;
impl Adapter for SofficeAdapter {
fn name(&self) -> &str {
"soffice"
}
fn formats(&self) -> Vec<Format> {
OFFICE
.iter()
.map(|(id, name)| Format::new(id, name, MediaKind::Document).with_extensions(&[id]))
.collect()
}
fn conversions(&self) -> Vec<Conversion> {
let mut edges = Vec::new();
for (source, _) in OFFICE {
edges.push(external_edge(
source,
"pdf",
"office-convert",
ConversionKind::Lossy,
70,
));
edges.push(external_edge(
source,
"txt",
"office-convert",
ConversionKind::Lossy,
95,
));
for family in OFFICE_FAMILIES {
if family.contains(source) {
for target in *family {
if source != target {
edges.push(external_edge(
source,
target,
"office-convert",
ConversionKind::Lossy,
90,
));
}
}
}
}
}
edges
}
fn convert<'a>(&'a self, request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async move {
if request.operation != "office-convert" {
return Err(Error::Invalid(format!(
"unknown LibreOffice operation: {}",
request.operation
)));
}
let input = one_input(request)?;
let profile = request.output_dir.join("soffice-profile");
let args = vec![
"--headless".into(),
profile_uri(&profile),
"--convert-to".into(),
extension_for(&request.to).into(),
"--outdir".into(),
path_string(&request.output_dir),
path_string(&input.path),
];
process::run("soffice", "soffice", &args, None, &request.limits).await?;
let output = move_office_output(request)?;
artifact_if_regular(output, &request.to, &request.limits)
})
}
}
struct InkscapeAdapter;
impl Adapter for InkscapeAdapter {
fn name(&self) -> &str {
"inkscape"
}
fn formats(&self) -> Vec<Format> {
vec![
Format::new("svg", "Scalable Vector Graphics", MediaKind::Image)
.with_extensions(&["svg"]),
Format::new("png", "PNG image", MediaKind::Image),
]
}
fn conversions(&self) -> Vec<Conversion> {
vec![external_edge(
"svg",
"png",
"svg-raster",
ConversionKind::Lossy,
35,
)]
}
fn convert<'a>(&'a self, request: &'a StepRequest) -> ConversionFuture<'a> {
Box::pin(async move {
if request.operation != "svg-raster" || request.to != "png" {
return Err(Error::Invalid(format!(
"unsupported Inkscape operation: {}",
request.operation
)));
}
let input = one_input(request)?;
let output = output_path(request, "png");
let args = vec![
path_string(&input.path),
"--export-filename".into(),
path_string(&output),
];
process::run("inkscape", "inkscape", &args, None, &request.limits).await?;
artifact_if_regular(output, "png", &request.limits)
})
}
}
fn external_edge(
from: &str,
to: &str,
operation: &str,
kind: ConversionKind,
cost: u32,
) -> Conversion {
Conversion::new(from, to, backend_for(operation), operation, kind, cost).requires_external()
}
fn backend_for(operation: &str) -> &'static str {
match operation {
"ffmpeg-transcode" | "ffmpeg-audio" | "ffmpeg-frame" | "ffmpeg-still" => "ffmpeg",
"image-transcode" => "imagemagick",
"pdf-text" | "pdf-raster" => "poppler",
"office-convert" => "soffice",
"svg-raster" => "inkscape",
_ => "external",
}
}
fn one_input(request: &StepRequest) -> Result<&Artifact> {
if request.inputs.len() != 1 {
return Err(Error::Invalid(
"external conversion requires one input".into(),
));
}
request
.inputs
.first()
.ok_or_else(|| Error::Invalid("external conversion input is missing".into()))
}
fn output_path(request: &StepRequest, format: &str) -> PathBuf {
request
.output_dir
.join(format!("external-0.{}", extension_for(format)))
}
fn extension_for(format: &str) -> &str {
match format {
"jpeg" => "jpg",
"tiff" => "tif",
"farbfeld" => "ff",
other => other,
}
}
fn path_string(path: &Path) -> String {
path.to_string_lossy().into_owned()
}
fn profile_uri(path: &Path) -> String {
let mut encoded = String::new();
for byte in path.to_string_lossy().bytes() {
if byte.is_ascii_alphanumeric() || b"-._~/".contains(&byte) {
encoded.push(char::from(byte));
} else {
encoded.push_str(&format!("%{byte:02X}"));
}
}
format!("-env:UserInstallation=file://{encoded}")
}
fn artifact_if_regular(
path: PathBuf,
format: &str,
limits: &crate::Limits,
) -> Result<Vec<Artifact>> {
let metadata = fs::symlink_metadata(&path).map_err(|error| {
Error::Conversion(format!("external tool did not produce output: {error}"))
})?;
if !metadata.file_type().is_file() {
return Err(Error::Security(
"external tool output is not a regular file".into(),
));
}
if metadata.len() > limits.max_output_bytes {
return Err(Error::Limit(
"external tool output exceeds byte budget".into(),
));
}
Ok(vec![Artifact {
path,
format: format.to_owned(),
}])
}
fn move_office_output(request: &StepRequest) -> Result<PathBuf> {
let extension = extension_for(&request.to);
let mut candidates = fs::read_dir(&request.output_dir)?
.filter_map(std::result::Result::ok)
.map(|entry| entry.path())
.filter(|path| {
fs::symlink_metadata(path).is_ok_and(|metadata| metadata.file_type().is_file())
&& path.extension().and_then(|value| value.to_str()) == Some(extension)
})
.collect::<Vec<_>>();
candidates.sort();
let source = candidates
.into_iter()
.next()
.ok_or_else(|| Error::Conversion("LibreOffice produced no expected output".into()))?;
let target = output_path(request, &request.to);
fs::rename(source, &target)?;
Ok(target)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn external_edges_are_marked_external() {
let edge = external_edge("a", "b", "image-transcode", ConversionKind::Lossy, 1);
assert!(edge.external);
assert_eq!(edge.backend, "imagemagick");
}
#[test]
fn output_extensions_match_tool_conventions() {
assert_eq!(extension_for("jpeg"), "jpg");
assert_eq!(extension_for("png"), "png");
assert_eq!(extension_for("farbfeld"), "ff");
}
}