2705 lines
95 KiB
Rust
2705 lines
95 KiB
Rust
use std::{
|
|
ffi::OsStr,
|
|
fs::{self, File},
|
|
io::{BufReader, Cursor, Write},
|
|
path::{Path, PathBuf},
|
|
process::Command,
|
|
sync::OnceLock,
|
|
time::UNIX_EPOCH,
|
|
};
|
|
|
|
use base64::{engine::general_purpose::STANDARD, Engine as _};
|
|
use image::{
|
|
codecs::{gif::GifDecoder, jpeg::JpegEncoder},
|
|
AnimationDecoder, Delay, DynamicImage, Frame, GenericImageView, ImageDecoder, ImageFormat,
|
|
RgbImage, RgbaImage,
|
|
};
|
|
use tauri::{AppHandle, Emitter, Manager};
|
|
|
|
use crate::{
|
|
models::{ActionOutcome, ActionResultEvent, FileActionProgress, FileInfo},
|
|
office, pdf, settings,
|
|
};
|
|
|
|
const IMAGE_EXTENSIONS: &[&str] = &[
|
|
"png", "jpg", "jpeg", "webp", "tiff", "tif", "bmp", "gif", "heic", "heif", "avif",
|
|
];
|
|
const VIDEO_EXTENSIONS: &[&str] = &["mp4", "mov", "m4v", "avi", "mkv", "webm"];
|
|
const AUDIO_EXTENSIONS: &[&str] = &["mp3", "wav", "m4a", "aiff", "aif", "caf", "flac", "ogg"];
|
|
const DOCUMENT_EXTENSIONS: &[&str] = &[
|
|
"docx", "doc", "rtf", "odt", "txt", "md", "html", "htm", "pages",
|
|
];
|
|
const PRESENTATION_EXTENSIONS: &[&str] = &["pptx", "ppt", "key"];
|
|
const SPREADSHEET_EXTENSIONS: &[&str] = &["xlsx", "xls", "xlsb", "ods", "csv", "tsv", "numbers"];
|
|
|
|
fn extension_of(path: &Path) -> String {
|
|
path.extension()
|
|
.and_then(|value| value.to_str())
|
|
.unwrap_or_default()
|
|
.to_ascii_lowercase()
|
|
}
|
|
|
|
fn image_mime(ext: &str) -> &'static str {
|
|
match ext {
|
|
"png" => "image/png",
|
|
"jpg" | "jpeg" => "image/jpeg",
|
|
"webp" => "image/webp",
|
|
"tiff" | "tif" => "image/tiff",
|
|
"bmp" => "image/bmp",
|
|
"gif" => "image/gif",
|
|
"heic" | "heif" => "image/heic",
|
|
"avif" => "image/avif",
|
|
_ => "application/octet-stream",
|
|
}
|
|
}
|
|
|
|
fn kind_of(ext: &str) -> &'static str {
|
|
if IMAGE_EXTENSIONS.contains(&ext) {
|
|
"image"
|
|
} else if VIDEO_EXTENSIONS.contains(&ext) {
|
|
"video"
|
|
} else if AUDIO_EXTENSIONS.contains(&ext) {
|
|
"audio"
|
|
} else if ext == "pdf" {
|
|
"pdf"
|
|
} else if DOCUMENT_EXTENSIONS.contains(&ext) {
|
|
"document"
|
|
} else if PRESENTATION_EXTENSIONS.contains(&ext) {
|
|
"presentation"
|
|
} else if SPREADSHEET_EXTENSIONS.contains(&ext) {
|
|
"spreadsheet"
|
|
} else {
|
|
"other"
|
|
}
|
|
}
|
|
|
|
fn preview_for(path: &Path, ext: &str) -> Option<(String, Option<u32>, Option<u32>)> {
|
|
if !IMAGE_EXTENSIONS.contains(&ext) {
|
|
return None;
|
|
}
|
|
let image = image::open(path).ok()?;
|
|
let (width, height) = image.dimensions();
|
|
let preview = image.thumbnail(520, 520);
|
|
let mut png = Vec::new();
|
|
preview
|
|
.write_to(&mut Cursor::new(&mut png), ImageFormat::Png)
|
|
.ok()?;
|
|
Some((
|
|
format!("data:image/png;base64,{}", STANDARD.encode(png)),
|
|
Some(width),
|
|
Some(height),
|
|
))
|
|
}
|
|
|
|
pub fn inspect_paths(paths: &[String]) -> Result<Vec<FileInfo>, String> {
|
|
let mut files = Vec::new();
|
|
for raw_path in paths {
|
|
let path = PathBuf::from(raw_path);
|
|
if !path.is_file() {
|
|
continue;
|
|
}
|
|
let metadata = fs::metadata(&path).map_err(|error| error.to_string())?;
|
|
let ext = extension_of(&path);
|
|
let preview = preview_for(&path, &ext);
|
|
files.push(FileInfo {
|
|
path: path.to_string_lossy().to_string(),
|
|
name: path
|
|
.file_name()
|
|
.and_then(|value| value.to_str())
|
|
.unwrap_or_default()
|
|
.to_string(),
|
|
extension: ext.clone(),
|
|
kind: kind_of(&ext).to_string(),
|
|
size: metadata.len(),
|
|
modified: metadata
|
|
.modified()
|
|
.ok()
|
|
.and_then(|value| value.duration_since(UNIX_EPOCH).ok())
|
|
.map(|value| value.as_secs() as i64),
|
|
preview: preview.as_ref().map(|value| value.0.clone()),
|
|
width: preview.as_ref().and_then(|value| value.1),
|
|
height: preview.as_ref().and_then(|value| value.2),
|
|
});
|
|
}
|
|
Ok(files)
|
|
}
|
|
|
|
pub(crate) fn unique_output(input: &Path, suffix: &str, ext: &str) -> PathBuf {
|
|
let parent = input.parent().unwrap_or_else(|| Path::new("."));
|
|
let stem = input
|
|
.file_stem()
|
|
.and_then(|value| value.to_str())
|
|
.unwrap_or("output");
|
|
let base = format!("{stem}{suffix}");
|
|
let mut candidate = parent.join(format!("{base}.{ext}"));
|
|
let mut index = 2;
|
|
while candidate.exists() {
|
|
candidate = parent.join(format!("{base} {index}.{ext}"));
|
|
index += 1;
|
|
}
|
|
candidate
|
|
}
|
|
|
|
pub(crate) fn unique_output_in(
|
|
input: &Path,
|
|
output_dir: Option<&Path>,
|
|
suffix: &str,
|
|
ext: &str,
|
|
) -> Result<PathBuf, String> {
|
|
let Some(directory) = output_dir else {
|
|
return Ok(unique_output(input, suffix, ext));
|
|
};
|
|
fs::create_dir_all(directory).map_err(|error| {
|
|
format!(
|
|
"Could not create {}. Choose another output folder in Settings. {error}",
|
|
directory.display()
|
|
)
|
|
})?;
|
|
let stem = input
|
|
.file_stem()
|
|
.and_then(|value| value.to_str())
|
|
.unwrap_or("output");
|
|
let base = format!("{stem}{suffix}");
|
|
let mut candidate = directory.join(format!("{base}.{ext}"));
|
|
let mut index = 2;
|
|
while candidate.exists() {
|
|
candidate = directory.join(format!("{base} {index}.{ext}"));
|
|
index += 1;
|
|
}
|
|
Ok(candidate)
|
|
}
|
|
|
|
fn normalized_target(target: &str) -> (&'static str, ImageFormat) {
|
|
match target.to_ascii_lowercase().as_str() {
|
|
"jpg" | "jpeg" => ("jpg", ImageFormat::Jpeg),
|
|
"png" => ("png", ImageFormat::Png),
|
|
"webp" => ("webp", ImageFormat::WebP),
|
|
"tiff" | "tif" => ("tiff", ImageFormat::Tiff),
|
|
"bmp" => ("bmp", ImageFormat::Bmp),
|
|
"gif" => ("gif", ImageFormat::Gif),
|
|
_ => ("png", ImageFormat::Png),
|
|
}
|
|
}
|
|
|
|
fn save_image(
|
|
image: &DynamicImage,
|
|
output: &Path,
|
|
format: ImageFormat,
|
|
quality: u8,
|
|
) -> Result<(), String> {
|
|
match format {
|
|
ImageFormat::Jpeg => {
|
|
let rgb = flatten_to_rgb(image);
|
|
let mut file =
|
|
File::create(output).map_err(|error| describe_write_error(output, error))?;
|
|
JpegEncoder::new_with_quality(&mut file, quality.clamp(30, 95))
|
|
.encode_image(&DynamicImage::ImageRgb8(rgb))
|
|
.map_err(|error| format!("Could not write {}: {error}", output.display()))
|
|
}
|
|
_ => image
|
|
.save_with_format(output, format)
|
|
.map_err(|error| format!("Could not write {}: {error}", output.display())),
|
|
}
|
|
}
|
|
|
|
fn describe_write_error(output: &Path, error: std::io::Error) -> String {
|
|
if error.kind() == std::io::ErrorKind::PermissionDenied {
|
|
return format!(
|
|
"Shift cannot write to {}. Allow access in System Settings > Privacy & Security > Files and Folders, or choose another output folder in Settings.",
|
|
output
|
|
.parent()
|
|
.unwrap_or(output)
|
|
.display()
|
|
);
|
|
}
|
|
format!("Could not write {}: {error}", output.display())
|
|
}
|
|
|
|
fn flatten_to_rgb(image: &DynamicImage) -> RgbImage {
|
|
let rgba = image.to_rgba8();
|
|
let mut rgb = RgbImage::new(rgba.width(), rgba.height());
|
|
for (x, y, pixel) in rgba.enumerate_pixels() {
|
|
let alpha = pixel[3] as f32 / 255.0;
|
|
let blend = |channel: u8| -> u8 {
|
|
(channel as f32 * alpha + 255.0 * (1.0 - alpha))
|
|
.round()
|
|
.clamp(0.0, 255.0) as u8
|
|
};
|
|
rgb.put_pixel(
|
|
x,
|
|
y,
|
|
image::Rgb([blend(pixel[0]), blend(pixel[1]), blend(pixel[2])]),
|
|
);
|
|
}
|
|
rgb
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
fn macos_convert(input: &Path, output: &Path, target: &str) -> Result<(), String> {
|
|
let format = match target {
|
|
"jpg" | "jpeg" => "jpeg",
|
|
"heic" | "heif" => "heic",
|
|
"avif" => "avif",
|
|
"tif" => "tiff",
|
|
"pdf" => "pdf",
|
|
other => other,
|
|
};
|
|
let status = crate::process::command("/usr/bin/sips")
|
|
.args([
|
|
"-s",
|
|
"format",
|
|
format,
|
|
input.to_string_lossy().as_ref(),
|
|
"--out",
|
|
output.to_string_lossy().as_ref(),
|
|
])
|
|
.status()
|
|
.map_err(|error| format!("System converter unavailable: {error}"))?;
|
|
if status.success() && output.exists() {
|
|
Ok(())
|
|
} else {
|
|
Err(format!(
|
|
"This Mac cannot write {} files. Try PNG or JPG.",
|
|
target.to_ascii_uppercase()
|
|
))
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
pub(crate) fn system_convert(input: &Path, output: &Path, target: &str) -> Result<(), String> {
|
|
macos_convert(input, output, target)
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
pub(crate) fn system_convert(input: &Path, output: &Path, target: &str) -> Result<(), String> {
|
|
let Some(magick) = resolve_tool("magick") else {
|
|
return Err("HEIC/AVIF export on Windows requires ImageMagick (magick).".into());
|
|
};
|
|
let status = crate::process::command(magick)
|
|
.arg(input)
|
|
.arg(output)
|
|
.status()
|
|
.map_err(|error| error.to_string())?;
|
|
if status.success() && output.exists() {
|
|
Ok(())
|
|
} else {
|
|
Err(format!(
|
|
"Could not write {} with ImageMagick.",
|
|
target.to_ascii_uppercase()
|
|
))
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "linux")]
|
|
pub(crate) fn system_convert(input: &Path, output: &Path, target: &str) -> Result<(), String> {
|
|
let Some(magick) = resolve_tool("magick") else {
|
|
return Err("HEIC/AVIF export on Linux requires ImageMagick (magick).".into());
|
|
};
|
|
let status = crate::process::command(magick)
|
|
.arg(input)
|
|
.arg(output)
|
|
.status()
|
|
.map_err(|error| error.to_string())?;
|
|
if status.success() && output.exists() {
|
|
Ok(())
|
|
} else {
|
|
Err(format!(
|
|
"Could not write {} with ImageMagick.",
|
|
target.to_ascii_uppercase()
|
|
))
|
|
}
|
|
}
|
|
|
|
fn convert_file(input: &Path, target: &str, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let (ext, format) = normalized_target(target);
|
|
let output = unique_output_in(input, output_dir, "", ext)?;
|
|
let direct_formats = ["png", "jpg", "webp", "tiff", "bmp", "gif"];
|
|
|
|
if direct_formats.contains(&ext) {
|
|
if let Ok(image) = image::open(input) {
|
|
if ext == "gif" {
|
|
save_gif_capped(input, &output, GIF_MAX_BYTES)?;
|
|
} else {
|
|
save_image(&image, &output, format, 92)?;
|
|
}
|
|
return Ok(output);
|
|
}
|
|
if ext == "webp" {
|
|
// HEIC/HEIF/AVIF are readable only through the system codec, while
|
|
// macOS sips cannot encode WEBP. Decode to PNG, then use the native
|
|
// WEBP encoder.
|
|
let intermediate =
|
|
std::env::temp_dir().join(format!("shift-image-{}.png", uuid::Uuid::new_v4()));
|
|
if system_convert(input, &intermediate, "png").is_ok() {
|
|
let converted = image::open(&intermediate).ok();
|
|
let _ = fs::remove_file(intermediate);
|
|
if let Some(image) = converted {
|
|
save_image(&image, &output, format, 92)?;
|
|
return Ok(output);
|
|
}
|
|
} else {
|
|
let _ = fs::remove_file(intermediate);
|
|
}
|
|
}
|
|
}
|
|
system_convert(input, &output, ext)?;
|
|
Ok(output)
|
|
}
|
|
|
|
pub(crate) fn resolve_tool(name: &str) -> Option<PathBuf> {
|
|
if let Ok(path) = which::which(name) {
|
|
if path.is_file() {
|
|
return Some(path);
|
|
}
|
|
}
|
|
#[cfg(target_os = "macos")]
|
|
{
|
|
let directories = [
|
|
"/opt/homebrew/bin",
|
|
"/usr/local/bin",
|
|
"/opt/local/bin",
|
|
"/usr/bin",
|
|
"/bin",
|
|
"/usr/sbin",
|
|
"/sbin",
|
|
];
|
|
directories
|
|
.into_iter()
|
|
.map(|directory| Path::new(directory).join(name))
|
|
.find(|candidate| candidate.is_file())
|
|
}
|
|
#[cfg(target_os = "windows")]
|
|
{
|
|
find_windows_tool(name)
|
|
}
|
|
#[cfg(target_os = "linux")]
|
|
{
|
|
let directories = ["/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"];
|
|
directories
|
|
.into_iter()
|
|
.map(|directory| Path::new(directory).join(name))
|
|
.find(|candidate| candidate.is_file())
|
|
}
|
|
}
|
|
|
|
pub(crate) fn document_pdf_engine() -> Option<PathBuf> {
|
|
[
|
|
"xelatex",
|
|
"lualatex",
|
|
"pdflatex",
|
|
"tectonic",
|
|
"typst",
|
|
"weasyprint",
|
|
"wkhtmltopdf",
|
|
]
|
|
.into_iter()
|
|
.find_map(resolve_tool)
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
fn windows_tool_file_names(name: &str) -> Vec<String> {
|
|
let mut names = vec![name.to_string()];
|
|
if Path::new(name).extension().is_none() {
|
|
names.push(format!("{name}.exe"));
|
|
}
|
|
names
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
fn push_windows_environment_directory(
|
|
directories: &mut Vec<PathBuf>,
|
|
variable: &str,
|
|
suffix: &str,
|
|
) {
|
|
if let Some(root) = std::env::var_os(variable) {
|
|
directories.push(PathBuf::from(root).join(suffix));
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
fn windows_tool_directories() -> Vec<PathBuf> {
|
|
let mut directories = Vec::new();
|
|
for (variable, suffix) in [
|
|
("LOCALAPPDATA", r"Microsoft\WinGet\Links"),
|
|
("LOCALAPPDATA", r"Microsoft\WindowsApps"),
|
|
("LOCALAPPDATA", "Pandoc"),
|
|
("LOCALAPPDATA", r"Programs\Pandoc"),
|
|
("ProgramFiles", "Pandoc"),
|
|
("ProgramW6432", "Pandoc"),
|
|
("ProgramFiles", r"ffmpeg\bin"),
|
|
("ProgramW6432", r"ffmpeg\bin"),
|
|
("ProgramFiles", r"Gyan\FFmpeg\bin"),
|
|
("ProgramW6432", r"Gyan\FFmpeg\bin"),
|
|
("ProgramFiles", r"FFmpeg\bin"),
|
|
("ProgramW6432", r"FFmpeg\bin"),
|
|
("ProgramData", r"chocolatey\bin"),
|
|
("USERPROFILE", r"scoop\shims"),
|
|
] {
|
|
push_windows_environment_directory(&mut directories, variable, suffix);
|
|
}
|
|
|
|
// ImageMagick installs into a versioned folder under Program Files.
|
|
for variable in ["ProgramFiles", "ProgramW6432"] {
|
|
let Some(root) = std::env::var_os(variable) else {
|
|
continue;
|
|
};
|
|
let Ok(entries) = fs::read_dir(root) else {
|
|
continue;
|
|
};
|
|
for entry in entries.flatten() {
|
|
let path = entry.path();
|
|
if path.is_dir()
|
|
&& entry
|
|
.file_name()
|
|
.to_string_lossy()
|
|
.to_ascii_lowercase()
|
|
.starts_with("imagemagick-")
|
|
{
|
|
directories.push(path);
|
|
}
|
|
}
|
|
}
|
|
directories
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
fn windows_winget_prefixes(name: &str) -> &'static [&'static str] {
|
|
match name {
|
|
"pandoc" => &["johnmacfarlane.pandoc", "chocolatey.pandoc"],
|
|
"ffmpeg" => &["gyan.ffmpeg"],
|
|
"pdftoppm" | "pdfimages" | "pdfinfo" => &["oschwartz10612.poppler"],
|
|
"magick" => &["imagemagick.imagemagick"],
|
|
"typst" => &["typst.typst"],
|
|
"winget" => &[],
|
|
_ => &[],
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
fn find_file_below(
|
|
directory: &Path,
|
|
file_names: &[String],
|
|
remaining_depth: usize,
|
|
) -> Option<PathBuf> {
|
|
if remaining_depth == 0 {
|
|
return None;
|
|
}
|
|
let entries = fs::read_dir(directory).ok()?;
|
|
let mut directories = Vec::new();
|
|
for entry in entries.flatten() {
|
|
let path = entry.path();
|
|
if path.is_dir() {
|
|
directories.push(path);
|
|
continue;
|
|
}
|
|
let file_name = entry.file_name().to_string_lossy().into_owned();
|
|
if file_names
|
|
.iter()
|
|
.any(|candidate| file_name.eq_ignore_ascii_case(candidate))
|
|
{
|
|
return Some(path);
|
|
}
|
|
}
|
|
directories.into_iter().find_map(|directory| {
|
|
find_file_below(&directory, file_names, remaining_depth.saturating_sub(1))
|
|
})
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
fn find_winget_package_tool(name: &str, file_names: &[String]) -> Option<PathBuf> {
|
|
let prefixes = windows_winget_prefixes(name);
|
|
if prefixes.is_empty() {
|
|
return None;
|
|
}
|
|
let packages =
|
|
PathBuf::from(std::env::var_os("LOCALAPPDATA")?).join(r"Microsoft\WinGet\Packages");
|
|
let entries = fs::read_dir(packages).ok()?;
|
|
for entry in entries.flatten() {
|
|
let package_name = entry.file_name().to_string_lossy().to_ascii_lowercase();
|
|
if !entry.path().is_dir()
|
|
|| !prefixes
|
|
.iter()
|
|
.any(|prefix| package_name.starts_with(prefix))
|
|
{
|
|
continue;
|
|
}
|
|
if let Some(found) = find_file_below(&entry.path(), file_names, 6) {
|
|
return Some(found);
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
fn find_windows_tool(name: &str) -> Option<PathBuf> {
|
|
static FOUND: OnceLock<std::sync::Mutex<std::collections::HashMap<String, PathBuf>>> =
|
|
OnceLock::new();
|
|
let cache = FOUND.get_or_init(|| std::sync::Mutex::new(std::collections::HashMap::new()));
|
|
if let Some(path) = cache.lock().ok().and_then(|tools| tools.get(name).cloned()) {
|
|
return Some(path);
|
|
}
|
|
let found = find_windows_tool_uncached(name);
|
|
if let Some(path) = found.as_ref() {
|
|
if let Ok(mut tools) = cache.lock() {
|
|
tools.insert(name.to_string(), path.clone());
|
|
}
|
|
}
|
|
found
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
fn find_windows_tool_uncached(name: &str) -> Option<PathBuf> {
|
|
let file_names = windows_tool_file_names(name);
|
|
for directory in windows_tool_directories() {
|
|
for file_name in &file_names {
|
|
let candidate = directory.join(file_name);
|
|
if candidate.is_file() {
|
|
return Some(candidate);
|
|
}
|
|
}
|
|
}
|
|
find_winget_package_tool(name, &file_names)
|
|
}
|
|
|
|
/// Runs long media and document work below the UI's scheduling priority on
|
|
/// macOS, so a CPU-heavy encoder cannot starve the always-on-top radial window.
|
|
pub(crate) fn background_command(program: impl AsRef<OsStr>) -> Command {
|
|
#[cfg(target_os = "macos")]
|
|
{
|
|
let mut command = crate::process::command("/usr/bin/nice");
|
|
command.args(["-n", "10"]).arg(program);
|
|
command
|
|
}
|
|
#[cfg(target_os = "windows")]
|
|
{
|
|
let mut command = crate::process::command(program);
|
|
crate::process::background(&mut command);
|
|
command
|
|
}
|
|
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
|
|
{
|
|
crate::process::command(program)
|
|
}
|
|
}
|
|
|
|
fn ffmpeg_path() -> Result<PathBuf, String> {
|
|
resolve_tool("ffmpeg").ok_or_else(|| {
|
|
"This conversion needs ffmpeg. Install it from Settings > Runtime Components or add it to your PATH."
|
|
.to_string()
|
|
})
|
|
}
|
|
|
|
fn ffmpeg_has_encoder(name: &str) -> bool {
|
|
let Ok(ffmpeg) = ffmpeg_path() else {
|
|
return false;
|
|
};
|
|
let Ok(output) = crate::process::output(ffmpeg, &["-hide_banner", "-encoders"]) else {
|
|
return false;
|
|
};
|
|
String::from_utf8_lossy(&output.stdout).contains(name)
|
|
}
|
|
|
|
fn video_encoder() -> &'static str {
|
|
static ENCODER: OnceLock<&'static str> = OnceLock::new();
|
|
ENCODER.get_or_init(|| {
|
|
if ffmpeg_has_encoder("libx264") {
|
|
"libx264"
|
|
} else if ffmpeg_has_encoder("h264_videotoolbox") {
|
|
"h264_videotoolbox"
|
|
} else {
|
|
"mpeg4"
|
|
}
|
|
})
|
|
}
|
|
|
|
pub(crate) fn video_encoder_name() -> &'static str {
|
|
video_encoder()
|
|
}
|
|
|
|
fn video_encode_args(crf: &'static str, bitrate: &'static str) -> Vec<&'static str> {
|
|
match video_encoder() {
|
|
"libx264" => vec![
|
|
"-c:v", "libx264", "-preset", "medium", "-crf", crf, "-pix_fmt", "yuv420p",
|
|
],
|
|
"h264_videotoolbox" => vec![
|
|
"-c:v",
|
|
"h264_videotoolbox",
|
|
"-b:v",
|
|
bitrate,
|
|
"-pix_fmt",
|
|
"yuv420p",
|
|
],
|
|
_ => vec!["-c:v", "mpeg4", "-q:v", "5", "-pix_fmt", "yuv420p"],
|
|
}
|
|
}
|
|
|
|
/// Video -> GIF stays small and predictable: first 15 seconds, 12 fps, 480 px wide.
|
|
const GIF_MAX_SECONDS: &str = "15";
|
|
const GIF_FILTER: &str = "fps=12,scale=480:-1:flags=lanczos";
|
|
/// Hard ceiling on the byte size of any GIF Shift writes.
|
|
const GIF_MAX_BYTES: u64 = 8 * 1024 * 1024;
|
|
/// The same ceiling for the ffmpeg path, passed as `-fs`.
|
|
const GIF_MAX_BYTES_FFMPEG: &str = "8388608";
|
|
/// Longest animation kept when re-encoding an existing animated GIF.
|
|
const GIF_MAX_MILLIS: u32 = 15_000;
|
|
/// Most frames kept when re-encoding an existing animated GIF.
|
|
const GIF_MAX_FRAMES: usize = 180;
|
|
/// Widest dimension kept when re-encoding an existing animated GIF.
|
|
const GIF_MAX_SIDE: u32 = 480;
|
|
|
|
/// Writes a GIF that respects the size ceiling. An animated source keeps its
|
|
/// frames; the running duration, the frame count and the resulting byte size
|
|
/// are all capped so a long recording cannot become a huge file.
|
|
fn save_gif_capped(input: &Path, output: &Path, max_bytes: u64) -> Result<(), String> {
|
|
let (width, height, frames) = match gif_frames(input) {
|
|
Ok(frames) => frames,
|
|
// Not an animated GIF: a still image becomes a single-frame GIF.
|
|
Err(_) => {
|
|
let image =
|
|
image::open(input).map_err(|error| format!("Could not read image: {error}"))?;
|
|
let rgba = image.to_rgba8();
|
|
let (width, height) = scaled_size(rgba.width(), rgba.height());
|
|
(
|
|
width,
|
|
height,
|
|
vec![Frame::from_parts(
|
|
rgba,
|
|
0,
|
|
0,
|
|
Delay::from_numer_denom_ms(0, 1),
|
|
)],
|
|
)
|
|
}
|
|
};
|
|
let buffer = encode_gif_frames(&frames, width, height, max_bytes)?;
|
|
let mut file = File::create(output).map_err(|error| describe_write_error(output, error))?;
|
|
file.write_all(&buffer)
|
|
.map_err(|error| describe_write_error(output, error))?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Encodes as many frames as fit into the byte ceiling. Frame count is found
|
|
/// by bisection because a frame's compressed size is only known once written.
|
|
fn encode_gif_frames(
|
|
frames: &[Frame],
|
|
width: u32,
|
|
height: u32,
|
|
max_bytes: u64,
|
|
) -> Result<Vec<u8>, String> {
|
|
let encode = |count: usize| -> Result<Vec<u8>, String> {
|
|
let mut buffer: Vec<u8> = Vec::new();
|
|
{
|
|
let mut encoder = image::codecs::gif::GifEncoder::new(&mut buffer);
|
|
for frame in frames.iter().take(count) {
|
|
let resized = resize_rgba(frame.buffer(), width, height);
|
|
encoder
|
|
.encode_frame(Frame::from_parts(resized, 0, 0, frame.delay()))
|
|
.map_err(|error| format!("Could not write the GIF: {error}"))?;
|
|
}
|
|
}
|
|
Ok(buffer)
|
|
};
|
|
|
|
let full = encode(frames.len())?;
|
|
if full.len() as u64 <= max_bytes {
|
|
return Ok(full);
|
|
}
|
|
let (mut low, mut high) = (1_usize, frames.len() - 1);
|
|
let mut best = encode(1)?;
|
|
while low <= high {
|
|
let middle = (low + high) / 2;
|
|
let candidate = encode(middle)?;
|
|
if candidate.len() as u64 <= max_bytes {
|
|
best = candidate;
|
|
low = middle + 1;
|
|
} else {
|
|
high = middle.saturating_sub(1);
|
|
}
|
|
}
|
|
Ok(best)
|
|
}
|
|
|
|
/// Decodes a GIF into frames, capped by duration and frame count. The size of
|
|
/// the source decides the output size: still images keep their dimensions,
|
|
/// animations are scaled down to the GIF width ceiling.
|
|
fn gif_frames(input: &Path) -> Result<(u32, u32, Vec<Frame>), String> {
|
|
let file = File::open(input).map_err(|error| format!("Could not read image: {error}"))?;
|
|
let decoder = GifDecoder::new(BufReader::new(file))
|
|
.map_err(|error| format!("Could not read image: {error}"))?;
|
|
let (width, height) = decoder.dimensions();
|
|
let mut frames = Vec::new();
|
|
let mut elapsed = 0_u32;
|
|
for frame in decoder.into_frames() {
|
|
let frame = frame.map_err(|error| format!("Could not read image: {error}"))?;
|
|
let delay = frame.delay().numer_denom_ms().0.min(GIF_MAX_MILLIS);
|
|
elapsed = elapsed.saturating_add(delay);
|
|
if elapsed > GIF_MAX_MILLIS || frames.len() >= GIF_MAX_FRAMES {
|
|
break;
|
|
}
|
|
frames.push(Frame::from_parts(
|
|
frame.into_buffer(),
|
|
0,
|
|
0,
|
|
Delay::from_numer_denom_ms(delay, 1),
|
|
));
|
|
}
|
|
if frames.is_empty() {
|
|
return Err("Could not read the image frames.".into());
|
|
}
|
|
let (width, height) = scaled_size(width, height);
|
|
Ok((width, height, frames))
|
|
}
|
|
|
|
/// Scales a frame pair down to the GIF width ceiling.
|
|
fn scaled_size(width: u32, height: u32) -> (u32, u32) {
|
|
if width <= GIF_MAX_SIDE {
|
|
return (width.max(1), height.max(1));
|
|
}
|
|
let height = (height as f64 * GIF_MAX_SIDE as f64 / width as f64)
|
|
.round()
|
|
.max(1.0) as u32;
|
|
(GIF_MAX_SIDE, height)
|
|
}
|
|
|
|
/// Resizes a frame to the given size with a smooth filter.
|
|
fn resize_rgba(image: &RgbaImage, width: u32, height: u32) -> RgbaImage {
|
|
if image.width() == width && image.height() == height {
|
|
return image.clone();
|
|
}
|
|
image::imageops::resize(image, width, height, image::imageops::FilterType::Lanczos3)
|
|
}
|
|
|
|
fn convert_media(input: &Path, target: &str, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let ffmpeg = ffmpeg_path()?;
|
|
let (ext, target) = match target.to_ascii_lowercase().as_str() {
|
|
"mp4" => ("mp4", "mp4"),
|
|
"mov" => ("mov", "mov"),
|
|
"gif" => ("gif", "gif"),
|
|
"m4a" => ("m4a", "m4a"),
|
|
"wav" => ("wav", "wav"),
|
|
"mp3" => ("mp3", "mp3"),
|
|
other => return Err(format!("Unsupported media format: {other}")),
|
|
};
|
|
let output = unique_output_in(input, output_dir, "", ext)?;
|
|
let mut command = background_command(&ffmpeg);
|
|
command.args(["-y", "-i", input.to_string_lossy().as_ref()]);
|
|
match target {
|
|
"gif" => {
|
|
// Cap duration and width: without these a minute of screen recording
|
|
// turns into a hundreds-of-megabytes animated file.
|
|
command.args(["-t", GIF_MAX_SECONDS]);
|
|
command.args(["-vf", GIF_FILTER, "-loop", "0"]);
|
|
// Cap the byte size too: ffmpeg stops writing once the file is
|
|
// this big, so a busy screen cannot produce a runaway GIF.
|
|
command.args(["-fs", GIF_MAX_BYTES_FFMPEG]);
|
|
}
|
|
"m4a" => {
|
|
command.args(["-vn", "-c:a", "aac", "-b:a", "192k"]);
|
|
}
|
|
"wav" => {
|
|
command.args(["-vn", "-c:a", "pcm_s16le"]);
|
|
}
|
|
"mp3" => {
|
|
if ffmpeg_has_encoder("libmp3lame") {
|
|
command.args(["-vn", "-c:a", "libmp3lame", "-b:a", "192k"]);
|
|
} else {
|
|
return convert_mp3_with_lame(input, &output);
|
|
}
|
|
}
|
|
"mp4" | "mov" => {
|
|
command.args(video_encode_args("20", "6M"));
|
|
command.args(["-c:a", "aac", "-b:a", "160k", "-movflags", "+faststart"]);
|
|
}
|
|
_ => {}
|
|
}
|
|
let status = command
|
|
.arg(output.to_string_lossy().as_ref())
|
|
.status()
|
|
.map_err(|error| format!("Could not run ffmpeg: {error}"))?;
|
|
if !status.success() || !output.exists() {
|
|
return Err("Media conversion failed.".into());
|
|
}
|
|
Ok(output)
|
|
}
|
|
|
|
fn convert_mp3_with_lame(input: &Path, output: &Path) -> Result<PathBuf, String> {
|
|
let lame = resolve_tool("lame").ok_or_else(|| {
|
|
"MP3 export needs an FFmpeg build with libmp3lame, or LAME on your PATH.".to_string()
|
|
})?;
|
|
let ffmpeg = ffmpeg_path()?;
|
|
let wav = std::env::temp_dir().join(format!("shift-{}.wav", uuid::Uuid::new_v4()));
|
|
let status = background_command(&ffmpeg)
|
|
.args(["-y", "-i"])
|
|
.arg(input)
|
|
.args(["-vn", "-ac", "2", "-ar", "44100"])
|
|
.arg(&wav)
|
|
.status()
|
|
.map_err(|error| format!("Could not extract audio: {error}"))?;
|
|
if !status.success() || !wav.exists() {
|
|
let _ = fs::remove_file(&wav);
|
|
return Err("Could not extract audio for MP3 export.".into());
|
|
}
|
|
let status = background_command(&lame)
|
|
.args(["--silent", "-b", "192"])
|
|
.arg(&wav)
|
|
.arg(output)
|
|
.status()
|
|
.map_err(|error| format!("Could not run LAME: {error}"))?;
|
|
let _ = fs::remove_file(&wav);
|
|
if !status.success() || !output.exists() {
|
|
return Err("MP3 export failed.".into());
|
|
}
|
|
Ok(output.to_path_buf())
|
|
}
|
|
|
|
fn compress_media(input: &Path, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let ffmpeg = ffmpeg_path()?;
|
|
let ext = extension_of(input);
|
|
let (extension, audio_only) = if AUDIO_EXTENSIONS.contains(&ext.as_str()) {
|
|
("m4a", true)
|
|
} else {
|
|
("mp4", false)
|
|
};
|
|
let output = unique_output_in(input, output_dir, " (compressed)", extension)?;
|
|
let mut command = background_command(&ffmpeg);
|
|
command.args(["-y", "-i", input.to_string_lossy().as_ref()]);
|
|
if audio_only {
|
|
command.args(["-vn", "-c:a", "aac", "-b:a", "128k"]);
|
|
} else {
|
|
command.args(video_encode_args("28", "2M"));
|
|
command.args(["-c:a", "aac", "-b:a", "96k", "-movflags", "+faststart"]);
|
|
}
|
|
let status = command
|
|
.arg(output.to_string_lossy().as_ref())
|
|
.status()
|
|
.map_err(|error| format!("Could not run ffmpeg: {error}"))?;
|
|
if !status.success() || !output.exists() {
|
|
return Err("Media compression failed.".into());
|
|
}
|
|
Ok(output)
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
pub(crate) fn doc_render_bridge() -> Option<PathBuf> {
|
|
let triple = match std::env::consts::ARCH {
|
|
"aarch64" => "aarch64-apple-darwin",
|
|
"x86_64" => "x86_64-apple-darwin",
|
|
_ => return None,
|
|
};
|
|
let dev = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
|
.join("binaries")
|
|
.join(format!("doc-render-{triple}"));
|
|
if dev.exists() {
|
|
return Some(dev);
|
|
}
|
|
if let Ok(executable) = std::env::current_exe() {
|
|
if let Some(parent) = executable.parent() {
|
|
let sidecar = parent.join("doc-render");
|
|
if sidecar.exists() {
|
|
return Some(sidecar);
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
fn native_document_pdf(
|
|
input: &Path,
|
|
output_dir: Option<&Path>,
|
|
on_progress: Option<&(dyn Fn(u32, u32, bool) + Sync)>,
|
|
) -> Result<Option<PathBuf>, String> {
|
|
if extension_of(input) == "docx" {
|
|
let work = std::env::temp_dir().join(format!("shift-docx-pdf-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&work).map_err(|error| error.to_string())?;
|
|
let target_dir = output_dir
|
|
.map(Path::to_path_buf)
|
|
.unwrap_or_else(|| directory_of(input));
|
|
let result = (|| {
|
|
let Some(images) = office::document_page_images(input, &work)? else {
|
|
return Ok(None);
|
|
};
|
|
let generated =
|
|
pdf::images_to_pdf_with_progress(&images, Some(&work), |done, total| {
|
|
if let Some(report) = on_progress {
|
|
report(done, total, false);
|
|
}
|
|
})?;
|
|
rename_office_output(generated, input, &target_dir).map(Some)
|
|
})();
|
|
let _ = fs::remove_dir_all(work);
|
|
if let Some(output) = result? {
|
|
return Ok(Some(output));
|
|
}
|
|
}
|
|
let Some(renderer) = doc_render_bridge() else {
|
|
return Ok(None);
|
|
};
|
|
let extension = extension_of(input);
|
|
let mut source = input.to_path_buf();
|
|
let mut temporary = None;
|
|
let mut base_dir = input
|
|
.parent()
|
|
.unwrap_or_else(|| Path::new("."))
|
|
.to_path_buf();
|
|
if matches!(extension.as_str(), "md" | "markdown") {
|
|
// Markdown must never reach the renderer as plain text: without that
|
|
// step the PDF is a printout of the markup. Pandoc is nicer when it is
|
|
// installed, and the built-in writer covers every other machine.
|
|
let path = std::env::temp_dir().join(format!("shift-doc-{}.html", uuid::Uuid::new_v4()));
|
|
let pandoc_rendered = resolve_tool("pandoc").is_some_and(|pandoc| {
|
|
background_command(&pandoc)
|
|
.arg(input)
|
|
.args(["-s", "-t", "html", "-o"])
|
|
.arg(&path)
|
|
.status()
|
|
.map(|status| status.success() && path.exists())
|
|
.unwrap_or(false)
|
|
});
|
|
let rendered = pandoc_rendered
|
|
|| match fs::read_to_string(input) {
|
|
Ok(text) => fs::write(&path, crate::markdown::to_html(&text)).is_ok(),
|
|
Err(_) => false,
|
|
};
|
|
if !rendered {
|
|
let _ = fs::remove_file(&path);
|
|
return Err(format!(
|
|
"Could not render {} as HTML before creating the PDF.",
|
|
input.display()
|
|
));
|
|
}
|
|
source = path.clone();
|
|
temporary = Some(path);
|
|
// Keep the original folder as the HTML base URL so relative images
|
|
// resolve even though the generated HTML lives in a temp directory.
|
|
base_dir = input
|
|
.parent()
|
|
.unwrap_or_else(|| Path::new("."))
|
|
.to_path_buf();
|
|
}
|
|
let output = unique_output_in(input, output_dir, "", "pdf")?;
|
|
let status = background_command(&renderer)
|
|
.arg(&source)
|
|
.arg(&output)
|
|
.arg(&base_dir)
|
|
.status()
|
|
.map_err(|error| format!("Could not start the document renderer: {error}"))?;
|
|
if let Some(path) = temporary {
|
|
let _ = fs::remove_file(path);
|
|
}
|
|
if !status.success() || !output.exists() {
|
|
let _ = fs::remove_file(&output);
|
|
return Err("Could not render this document to PDF.".into());
|
|
}
|
|
Ok(Some(output))
|
|
}
|
|
|
|
/// Converts through the built-in macOS text converter.
|
|
///
|
|
/// Pandoc is an optional tool, and machines without it used to fail every
|
|
/// Word/RTF request. `textutil` ships with macOS and writes the same
|
|
/// formats, so Markdown is rendered to HTML first and handed over.
|
|
#[cfg(target_os = "macos")]
|
|
fn textutil_convert(
|
|
input: &Path,
|
|
target: &str,
|
|
output_dir: Option<&Path>,
|
|
) -> Result<Option<PathBuf>, String> {
|
|
let writer = match target.to_ascii_lowercase().as_str() {
|
|
"docx" => "docx",
|
|
"rtf" => "rtf",
|
|
"html" | "htm" => "html",
|
|
"txt" => "txt",
|
|
_ => return Ok(None),
|
|
};
|
|
let extension = extension_of(input);
|
|
let mut source = input.to_path_buf();
|
|
let mut temporary = None;
|
|
// textutil reads Markdown as plain text, so give it rendered HTML instead.
|
|
if matches!(extension.as_str(), "md" | "markdown") {
|
|
let path = std::env::temp_dir().join(format!("shift-doc-{}.html", uuid::Uuid::new_v4()));
|
|
let text = fs::read_to_string(input)
|
|
.map_err(|error| format!("Could not read {}: {error}", input.display()))?;
|
|
fs::write(&path, crate::markdown::to_html(&text))
|
|
.map_err(|error| format!("Could not render Markdown: {error}"))?;
|
|
source = path.clone();
|
|
temporary = Some(path);
|
|
}
|
|
let output = unique_output_in(input, output_dir, "", writer)?;
|
|
let status = background_command("/usr/bin/textutil")
|
|
.args(["-convert", writer])
|
|
.arg("-output")
|
|
.arg(output.to_string_lossy().as_ref())
|
|
.arg(source.to_string_lossy().as_ref())
|
|
.status();
|
|
if let Some(path) = temporary {
|
|
let _ = fs::remove_file(path);
|
|
}
|
|
match status {
|
|
Ok(status) if status.success() && output.exists() => Ok(Some(output)),
|
|
Ok(_) => {
|
|
let _ = fs::remove_file(&output);
|
|
Ok(None)
|
|
}
|
|
Err(error) => Err(format!("Could not run the macOS text converter: {error}")),
|
|
}
|
|
}
|
|
|
|
/// Renames a generated file from a throwaway intermediate name to one derived
|
|
/// from the original input, keeping whatever extension the writer produced.
|
|
fn rename_office_output(
|
|
generated: PathBuf,
|
|
input: &Path,
|
|
target_dir: &Path,
|
|
) -> Result<PathBuf, String> {
|
|
let extension = generated
|
|
.extension()
|
|
.and_then(|value| value.to_str())
|
|
.unwrap_or("pdf")
|
|
.to_ascii_lowercase();
|
|
let desired = unique_output_in(input, Some(target_dir), "", &extension)?;
|
|
if generated != desired {
|
|
fs::rename(&generated, &desired)
|
|
.map_err(|error| format!("Could not name the output file: {error}"))?;
|
|
}
|
|
Ok(desired)
|
|
}
|
|
|
|
fn convert_document(
|
|
input: &Path,
|
|
target: &str,
|
|
output_dir: Option<&Path>,
|
|
on_progress: Option<&(dyn Fn(u32, u32, bool) + Sync)>,
|
|
) -> Result<PathBuf, String> {
|
|
let extension = extension_of(input);
|
|
if extension == "pages" {
|
|
return Err("Pages files are not supported directly. Export as DOCX first.".into());
|
|
}
|
|
if target.eq_ignore_ascii_case("pdf") {
|
|
#[cfg(target_os = "macos")]
|
|
if let Some(output) = native_document_pdf(input, output_dir, on_progress)? {
|
|
return Ok(output);
|
|
}
|
|
}
|
|
// Image-bearing PDFs go straight to page rendering. A text-only PDF keeps
|
|
// the text-layer path so its Word output stays editable.
|
|
if extension == "pdf" && target.eq_ignore_ascii_case("docx") {
|
|
if !pdf::has_embedded_images(input)? {
|
|
let text = pdf::text_of(input)?;
|
|
let temporary =
|
|
std::env::temp_dir().join(format!("shift-pdf-{}.md", uuid::Uuid::new_v4()));
|
|
fs::write(&temporary, text).map_err(|error| error.to_string())?;
|
|
let target_dir = output_dir
|
|
.map(Path::to_path_buf)
|
|
.unwrap_or_else(|| directory_of(input));
|
|
let result = convert_document(&temporary, "docx", Some(&target_dir), None)
|
|
.and_then(|generated| rename_office_output(generated, input, &target_dir));
|
|
let _ = fs::remove_file(&temporary);
|
|
return result;
|
|
}
|
|
if pdf::renderer_path().is_none() {
|
|
return Err(
|
|
"PDF to Word needs Poppler (pdftoppm). Install it from Settings > Runtime Components."
|
|
.into(),
|
|
);
|
|
}
|
|
let output = unique_output_in(input, output_dir, "", "docx")?;
|
|
match on_progress {
|
|
Some(report) => {
|
|
pdf::to_docx_with_progress(input, &output, |done, total, packaging| {
|
|
report(done, total, packaging)
|
|
})?
|
|
}
|
|
None => pdf::to_docx(input, &output)?,
|
|
}
|
|
return Ok(output);
|
|
}
|
|
let target = target.to_ascii_lowercase();
|
|
let pdf_engine = (target == "pdf").then(document_pdf_engine).flatten();
|
|
if target == "pdf" && pdf_engine.is_none() {
|
|
return Err(
|
|
"PDF output needs a Pandoc PDF engine. Install Typst from Settings > Runtime Components or add a supported engine to your PATH."
|
|
.into(),
|
|
);
|
|
}
|
|
let (extension, writer) = match target.as_str() {
|
|
"md" | "markdown" => ("md", Some("gfm")),
|
|
"html" => ("html", Some("html")),
|
|
"txt" => ("txt", Some("plain")),
|
|
"docx" => ("docx", None),
|
|
"rtf" => ("rtf", None),
|
|
"pdf" => ("pdf", None),
|
|
other => return Err(format!("Unsupported document format: {other}")),
|
|
};
|
|
let pandoc = match resolve_tool("pandoc") {
|
|
Some(pandoc) => pandoc,
|
|
None => {
|
|
#[cfg(target_os = "macos")]
|
|
if let Some(output) = textutil_convert(input, extension, output_dir)? {
|
|
return Ok(output);
|
|
}
|
|
return Err(
|
|
"Document conversion needs pandoc. Install it from Settings > Runtime Components or add it to your PATH."
|
|
.into(),
|
|
);
|
|
}
|
|
};
|
|
let output = unique_output_in(input, output_dir, "", extension)?;
|
|
let mut command = background_command(&pandoc);
|
|
command.arg(input);
|
|
if let Some(writer) = writer {
|
|
command.args(["-t", writer]);
|
|
}
|
|
if matches!(target.as_str(), "html" | "rtf") {
|
|
command.arg("--standalone");
|
|
}
|
|
if target == "html" {
|
|
// DOCX images otherwise become references to a media folder that
|
|
// Pandoc never writes. Inline them so the single HTML file is portable.
|
|
command.arg("--self-contained");
|
|
}
|
|
if let Some(engine) = pdf_engine {
|
|
command.arg("--pdf-engine").arg(engine);
|
|
}
|
|
let status = command
|
|
.args(["-o", output.to_string_lossy().as_ref()])
|
|
.status()
|
|
.map_err(|error| format!("Could not run pandoc: {error}"))?;
|
|
if !status.success() || !output.exists() {
|
|
let _ = fs::remove_file(&output);
|
|
#[cfg(target_os = "macos")]
|
|
if let Some(output) = textutil_convert(input, extension, output_dir)? {
|
|
return Ok(output);
|
|
}
|
|
return Err(format!(
|
|
"Could not convert {} to {}. The source may be damaged or contain unsupported content.",
|
|
input.display(),
|
|
extension.to_ascii_uppercase()
|
|
));
|
|
}
|
|
Ok(output)
|
|
}
|
|
|
|
fn compress_file(input: &Path, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let image = image::open(input).map_err(|error| format!("Could not read image: {error}"))?;
|
|
let has_alpha = image.color().has_alpha();
|
|
let (ext, format) = if has_alpha {
|
|
("png", ImageFormat::Png)
|
|
} else {
|
|
("jpg", ImageFormat::Jpeg)
|
|
};
|
|
let output = unique_output_in(input, output_dir, " (compressed)", ext)?;
|
|
save_image(&image, &output, format, 68)?;
|
|
Ok(output)
|
|
}
|
|
|
|
fn strip_metadata(input: &Path, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let image = image::open(input).map_err(|error| format!("Could not read image: {error}"))?;
|
|
let ext = extension_of(input);
|
|
let (ext, format) = normalized_target(&ext);
|
|
let output = unique_output_in(input, output_dir, " (clean)", ext)?;
|
|
save_image(&image, &output, format, 92)?;
|
|
Ok(output)
|
|
}
|
|
|
|
fn resize_file(input: &Path, scale: f64, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let image = image::open(input).map_err(|error| format!("Could not read image: {error}"))?;
|
|
let (width, height) = image.dimensions();
|
|
let target_width = ((width as f64 * scale).round() as u32).max(1);
|
|
let target_height = ((height as f64 * scale).round() as u32).max(1);
|
|
let resized = image.resize_exact(
|
|
target_width,
|
|
target_height,
|
|
image::imageops::FilterType::Lanczos3,
|
|
);
|
|
let ext = extension_of(input);
|
|
let (ext, format) = normalized_target(&ext);
|
|
let output = unique_output_in(
|
|
input,
|
|
output_dir,
|
|
&format!(" ({}%)", (scale * 100.0).round() as u32),
|
|
ext,
|
|
)?;
|
|
save_image(&resized, &output, format, 92)?;
|
|
Ok(output)
|
|
}
|
|
|
|
fn rotate_file(input: &Path, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let image = image::open(input).map_err(|error| format!("Could not read image: {error}"))?;
|
|
let rotated = image.rotate90();
|
|
let ext = extension_of(input);
|
|
let (ext, format) = normalized_target(&ext);
|
|
let output = unique_output_in(input, output_dir, " (rotated)", ext)?;
|
|
save_image(&rotated, &output, format, 92)?;
|
|
Ok(output)
|
|
}
|
|
|
|
fn flip_file(input: &Path, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let image = image::open(input).map_err(|error| format!("Could not read image: {error}"))?;
|
|
let flipped = image.fliph();
|
|
let ext = extension_of(input);
|
|
let (ext, format) = normalized_target(&ext);
|
|
let output = unique_output_in(input, output_dir, " (flipped)", ext)?;
|
|
save_image(&flipped, &output, format, 92)?;
|
|
Ok(output)
|
|
}
|
|
|
|
fn grayscale_file(input: &Path, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let image = image::open(input).map_err(|error| format!("Could not read image: {error}"))?;
|
|
let grayscale = image.grayscale();
|
|
let ext = extension_of(input);
|
|
let (ext, format) = normalized_target(&ext);
|
|
let output = unique_output_in(input, output_dir, " (bw)", ext)?;
|
|
save_image(&grayscale, &output, format, 92)?;
|
|
Ok(output)
|
|
}
|
|
|
|
fn mute_video(input: &Path, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let ffmpeg = ffmpeg_path()?;
|
|
let ext = extension_of(input);
|
|
let output = unique_output_in(input, output_dir, " (muted)", &ext)?;
|
|
let status = background_command(&ffmpeg)
|
|
.args(["-y", "-i"])
|
|
.arg(input)
|
|
.args(["-c:v", "copy", "-an"])
|
|
.arg(&output)
|
|
.status()
|
|
.map_err(|error| format!("Could not run ffmpeg: {error}"))?;
|
|
if !status.success() || !output.exists() {
|
|
return Err("Could not mute this video.".into());
|
|
}
|
|
Ok(output)
|
|
}
|
|
|
|
fn resize_video_720(input: &Path, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let ffmpeg = ffmpeg_path()?;
|
|
let output = unique_output_in(input, output_dir, " (720p)", "mp4")?;
|
|
let status = background_command(&ffmpeg)
|
|
.args(["-y", "-i"])
|
|
.arg(input)
|
|
.args(["-vf", "scale=-2:720"])
|
|
.args(video_encode_args("26", "3M"))
|
|
.args(["-c:a", "aac", "-b:a", "128k", "-movflags", "+faststart"])
|
|
.arg(&output)
|
|
.status()
|
|
.map_err(|error| format!("Could not run ffmpeg: {error}"))?;
|
|
if !status.success() || !output.exists() {
|
|
return Err("Could not resize this video.".into());
|
|
}
|
|
Ok(output)
|
|
}
|
|
|
|
fn frame_video(input: &Path, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let ffmpeg = ffmpeg_path()?;
|
|
let output = unique_output_in(input, output_dir, " (frame)", "png")?;
|
|
let status = background_command(&ffmpeg)
|
|
.args(["-y", "-ss", "0", "-i"])
|
|
.arg(input)
|
|
.args(["-frames:v", "1"])
|
|
.arg(&output)
|
|
.status()
|
|
.map_err(|error| format!("Could not run ffmpeg: {error}"))?;
|
|
if !status.success() || !output.exists() {
|
|
return Err("Could not extract a frame from this video.".into());
|
|
}
|
|
Ok(output)
|
|
}
|
|
|
|
fn mono_audio(input: &Path, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let ffmpeg = ffmpeg_path()?;
|
|
let output = unique_output_in(input, output_dir, " (mono)", "m4a")?;
|
|
let status = background_command(&ffmpeg)
|
|
.args(["-y", "-i"])
|
|
.arg(input)
|
|
.args(["-vn", "-ac", "1", "-c:a", "aac", "-b:a", "128k"])
|
|
.arg(&output)
|
|
.status()
|
|
.map_err(|error| format!("Could not run ffmpeg: {error}"))?;
|
|
if !status.success() || !output.exists() {
|
|
return Err("Could not convert this audio to mono.".into());
|
|
}
|
|
Ok(output)
|
|
}
|
|
|
|
fn directory_of(input: &Path) -> PathBuf {
|
|
input
|
|
.parent()
|
|
.unwrap_or_else(|| Path::new("."))
|
|
.to_path_buf()
|
|
}
|
|
|
|
fn crop_file(
|
|
input: &Path,
|
|
rect: &crate::models::NormalizedRect,
|
|
output_dir: Option<&Path>,
|
|
) -> Result<PathBuf, String> {
|
|
let image = image::open(input).map_err(|error| format!("Could not read image: {error}"))?;
|
|
let (width, height) = image.dimensions();
|
|
let x = (rect.x.clamp(0.0, 1.0) * width as f64).round() as u32;
|
|
let y = (rect.y.clamp(0.0, 1.0) * height as f64).round() as u32;
|
|
let crop_width = (rect.width.clamp(0.0, 1.0) * width as f64).round() as u32;
|
|
let crop_height = (rect.height.clamp(0.0, 1.0) * height as f64).round() as u32;
|
|
if crop_width < 1 || crop_height < 1 {
|
|
return Err("The selected area is too small.".into());
|
|
}
|
|
let cropped = image.crop_imm(x, y, crop_width.min(width - x), crop_height.min(height - y));
|
|
let output = unique_output_in(input, output_dir, " (cropped)", "png")?;
|
|
cropped
|
|
.save_with_format(&output, ImageFormat::Png)
|
|
.map_err(|error| error.to_string())?;
|
|
Ok(output)
|
|
}
|
|
|
|
pub fn open_path(path: &Path) -> Result<(), String> {
|
|
#[cfg(target_os = "macos")]
|
|
let mut command = {
|
|
let mut command = crate::process::command("/usr/bin/open");
|
|
command.arg(path);
|
|
command
|
|
};
|
|
#[cfg(target_os = "linux")]
|
|
let mut command = {
|
|
let mut command = crate::process::command("xdg-open");
|
|
command.arg(path);
|
|
command
|
|
};
|
|
#[cfg(target_os = "windows")]
|
|
return windows_open(path);
|
|
|
|
#[cfg(not(target_os = "windows"))]
|
|
{
|
|
command.status().map_err(|error| error.to_string())?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "windows")]
|
|
fn windows_open(path: &Path) -> Result<(), String> {
|
|
use std::os::windows::ffi::OsStrExt;
|
|
use windows_sys::Win32::UI::Shell::ShellExecuteW;
|
|
use windows_sys::Win32::UI::WindowsAndMessaging::SW_SHOWNORMAL;
|
|
|
|
let file: Vec<u16> = path
|
|
.as_os_str()
|
|
.encode_wide()
|
|
.chain(std::iter::once(0))
|
|
.collect();
|
|
let result = unsafe {
|
|
ShellExecuteW(
|
|
std::ptr::null_mut(),
|
|
std::ptr::null(),
|
|
file.as_ptr(),
|
|
std::ptr::null(),
|
|
std::ptr::null(),
|
|
SW_SHOWNORMAL,
|
|
)
|
|
} as isize;
|
|
if result <= 32 {
|
|
Err(format!(
|
|
"Windows could not open {}. The default application may be missing.",
|
|
path.display()
|
|
))
|
|
} else {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub fn reveal_path(path: &Path) -> Result<(), String> {
|
|
#[cfg(target_os = "macos")]
|
|
return crate::process::command("/usr/bin/open")
|
|
.args(["-R", path.to_string_lossy().as_ref()])
|
|
.status()
|
|
.map(|_| ())
|
|
.map_err(|error| error.to_string());
|
|
|
|
#[cfg(target_os = "windows")]
|
|
return windows_reveal(path);
|
|
|
|
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
|
|
return crate::process::command("xdg-open")
|
|
.arg(path.parent().unwrap_or(path))
|
|
.status()
|
|
.map(|_| ())
|
|
.map_err(|error| error.to_string());
|
|
}
|
|
|
|
/// Selects a file in Explorer the way `open -R` does in Finder: a window already
|
|
/// showing that folder is reused and brought forward. `explorer /select,…` cannot
|
|
/// do this, it spawns a fresh window for every conversion that finishes.
|
|
#[cfg(target_os = "windows")]
|
|
fn windows_reveal(path: &Path) -> Result<(), String> {
|
|
use std::os::windows::ffi::OsStrExt;
|
|
use windows_sys::Win32::System::Com::{
|
|
CoInitializeEx, CoUninitialize, COINIT_APARTMENTTHREADED,
|
|
};
|
|
use windows_sys::Win32::UI::Shell::{
|
|
ILFindLastID, ILFree, ILRemoveLastID, SHOpenFolderAndSelectItems, SHParseDisplayName,
|
|
};
|
|
|
|
// The shell namespace APIs need COM on this thread. A thread that already
|
|
// picked another apartment model returns RPC_E_CHANGED_MODE and keeps it, so
|
|
// only uninitialise an apartment this call actually created.
|
|
const RPC_E_CHANGED_MODE: i32 = -2_147_418_113; // 0x80010105
|
|
let initialised = unsafe { CoInitializeEx(std::ptr::null(), COINIT_APARTMENTTHREADED as u32) };
|
|
|
|
let wide: Vec<u16> = path
|
|
.as_os_str()
|
|
.encode_wide()
|
|
.chain(std::iter::once(0))
|
|
.collect();
|
|
let mut item = std::ptr::null_mut();
|
|
let parsed = unsafe {
|
|
SHParseDisplayName(
|
|
wide.as_ptr(),
|
|
std::ptr::null_mut(),
|
|
&mut item,
|
|
0,
|
|
std::ptr::null_mut(),
|
|
)
|
|
};
|
|
let result = if parsed < 0 || item.is_null() {
|
|
Err(format!(
|
|
"Windows could not find {} in the shell namespace.",
|
|
path.display()
|
|
))
|
|
} else {
|
|
// Read the target's own identifier before truncating the list: removing
|
|
// the last entry first would leave the parent folder's identifier.
|
|
let child = unsafe { ILFindLastID(item) };
|
|
if child.is_null() || unsafe { ILRemoveLastID(item) } == 0 {
|
|
Err(format!("Windows could not open {}.", path.display()))
|
|
} else {
|
|
let children = [child as *const _];
|
|
let opened = unsafe { SHOpenFolderAndSelectItems(item, 1, children.as_ptr(), 0) };
|
|
if opened < 0 {
|
|
Err(format!("Explorer refused to reveal {}.", path.display()))
|
|
} else {
|
|
Ok(())
|
|
}
|
|
}
|
|
};
|
|
|
|
unsafe { ILFree(item) };
|
|
if initialised != RPC_E_CHANGED_MODE {
|
|
unsafe { CoUninitialize() };
|
|
}
|
|
result
|
|
}
|
|
|
|
pub fn perform_action(
|
|
action: &str,
|
|
paths: &[String],
|
|
target: Option<&str>,
|
|
output_dir: Option<&Path>,
|
|
on_progress: Option<&(dyn Fn(u32, u32, bool) + Sync)>,
|
|
) -> Result<ActionOutcome, String> {
|
|
if paths.is_empty() {
|
|
return Err("No files selected.".into());
|
|
}
|
|
if action == "reveal" {
|
|
reveal_path(Path::new(&paths[0]))?;
|
|
return Ok(ActionOutcome {
|
|
outputs: vec![],
|
|
message: "Revealed in file manager.".into(),
|
|
});
|
|
}
|
|
if action == "open" {
|
|
open_path(Path::new(&paths[0]))?;
|
|
return Ok(ActionOutcome {
|
|
outputs: vec![],
|
|
message: "Opened.".into(),
|
|
});
|
|
}
|
|
|
|
let pdf_paths: Vec<PathBuf> = paths
|
|
.iter()
|
|
.map(PathBuf::from)
|
|
.filter(|path| extension_of(path) == "pdf")
|
|
.collect();
|
|
if action == "merge" {
|
|
if pdf_paths.len() == paths.len() && pdf_paths.len() > 1 {
|
|
let output = pdf::merge(&pdf_paths, output_dir)?;
|
|
return Ok(ActionOutcome {
|
|
outputs: vec![output.to_string_lossy().to_string()],
|
|
message: "Merged PDFs.".into(),
|
|
});
|
|
}
|
|
let image_paths: Vec<PathBuf> = paths
|
|
.iter()
|
|
.map(PathBuf::from)
|
|
.filter(|path| IMAGE_EXTENSIONS.contains(&extension_of(path).as_str()))
|
|
.collect();
|
|
if image_paths.len() == paths.len() && image_paths.len() > 1 {
|
|
let output = pdf::images_to_pdf(&image_paths, output_dir)?;
|
|
return Ok(ActionOutcome {
|
|
outputs: vec![output.to_string_lossy().to_string()],
|
|
message: "Combined images into a PDF.".into(),
|
|
});
|
|
}
|
|
return Err("Merge works with multiple PDFs or multiple images.".into());
|
|
}
|
|
if action == "split" {
|
|
if pdf_paths.is_empty() {
|
|
return Err("Split works with PDF files.".into());
|
|
}
|
|
let mut outputs = Vec::new();
|
|
for path in &pdf_paths {
|
|
outputs.extend(pdf::split(path, output_dir)?);
|
|
}
|
|
return Ok(ActionOutcome {
|
|
message: format!("Saved {} PDF pages.", outputs.len()),
|
|
outputs: outputs
|
|
.into_iter()
|
|
.map(|path| path.to_string_lossy().to_string())
|
|
.collect(),
|
|
});
|
|
}
|
|
if action == "text" {
|
|
if pdf_paths.is_empty() {
|
|
return Err("Text extraction currently works with PDF files.".into());
|
|
}
|
|
let mut outputs = Vec::new();
|
|
for path in &pdf_paths {
|
|
outputs.push(pdf::extract_text(path, output_dir)?);
|
|
}
|
|
return Ok(ActionOutcome {
|
|
message: "Extracted PDF text.".into(),
|
|
outputs: outputs
|
|
.into_iter()
|
|
.map(|path| path.to_string_lossy().to_string())
|
|
.collect(),
|
|
});
|
|
}
|
|
if action == "convert"
|
|
&& target
|
|
.map(|value| {
|
|
matches!(
|
|
value.to_ascii_lowercase().as_str(),
|
|
"png" | "jpg" | "jpeg" | "tif" | "tiff" | "heic" | "heif"
|
|
)
|
|
})
|
|
.unwrap_or(false)
|
|
&& !pdf_paths.is_empty()
|
|
{
|
|
let extension = target.unwrap_or("png");
|
|
let mut outputs = Vec::new();
|
|
for path in &pdf_paths {
|
|
outputs.extend(pdf::to_images(path, extension, output_dir)?);
|
|
}
|
|
return Ok(ActionOutcome {
|
|
message: format!("Saved {} PDF pages.", outputs.len()),
|
|
outputs: outputs
|
|
.into_iter()
|
|
.map(|path| path.to_string_lossy().to_string())
|
|
.collect(),
|
|
});
|
|
}
|
|
|
|
let mut outputs = Vec::new();
|
|
for raw_path in paths {
|
|
let input = Path::new(raw_path);
|
|
if !input.is_file() {
|
|
continue;
|
|
}
|
|
let ext = extension_of(input);
|
|
let media =
|
|
VIDEO_EXTENSIONS.contains(&ext.as_str()) || AUDIO_EXTENSIONS.contains(&ext.as_str());
|
|
let is_pdf = ext == "pdf";
|
|
let is_image = IMAGE_EXTENSIONS.contains(&ext.as_str());
|
|
let is_video = VIDEO_EXTENSIONS.contains(&ext.as_str());
|
|
let is_audio = AUDIO_EXTENSIONS.contains(&ext.as_str());
|
|
let is_document = DOCUMENT_EXTENSIONS.contains(&ext.as_str());
|
|
let is_presentation = PRESENTATION_EXTENSIONS.contains(&ext.as_str());
|
|
let is_spreadsheet = SPREADSHEET_EXTENSIONS.contains(&ext.as_str());
|
|
let output = match action {
|
|
"convert" if is_pdf && matches!(target, Some("txt" | "md")) => {
|
|
pdf::extract_text_to(input, target.unwrap_or("txt"), output_dir)?
|
|
}
|
|
"convert"
|
|
if is_pdf && target.is_some_and(|value| value.eq_ignore_ascii_case("docx")) =>
|
|
{
|
|
let target_dir = output_dir
|
|
.map(Path::to_path_buf)
|
|
.unwrap_or_else(|| directory_of(input));
|
|
convert_document(input, "docx", Some(&target_dir), on_progress)?
|
|
}
|
|
"convert" if is_pdf && matches!(target, Some("rtf")) => {
|
|
// The text layer becomes a Markdown intermediate, then the same
|
|
// document writer produces the requested container.
|
|
let text = pdf::text_of(input)?;
|
|
let temporary =
|
|
std::env::temp_dir().join(format!("shift-pdf-{}.md", uuid::Uuid::new_v4()));
|
|
fs::write(&temporary, text).map_err(|error| error.to_string())?;
|
|
let target = target.unwrap_or("docx");
|
|
// Write straight into the resolved output folder, then rename away
|
|
// from the throwaway intermediate name.
|
|
let target_dir = output_dir
|
|
.map(Path::to_path_buf)
|
|
.unwrap_or_else(|| directory_of(input));
|
|
let result = convert_document(&temporary, target, Some(&target_dir), None)
|
|
.and_then(|generated| rename_office_output(generated, input, &target_dir));
|
|
let _ = fs::remove_file(&temporary);
|
|
result?
|
|
}
|
|
"convert" if is_pdf => {
|
|
return Err(
|
|
"Pick a supported target for this PDF: an image format, TXT, MD, DOCX or RTF."
|
|
.into(),
|
|
)
|
|
}
|
|
"convert"
|
|
if is_image
|
|
&& target
|
|
.map(|value| value.eq_ignore_ascii_case("pdf"))
|
|
.unwrap_or(false) =>
|
|
{
|
|
pdf::images_to_pdf(&[input.to_path_buf()], output_dir)?
|
|
}
|
|
"convert" if is_document => {
|
|
convert_document(input, target.unwrap_or("md"), output_dir, on_progress)?
|
|
}
|
|
"convert" if is_presentation => match target.unwrap_or("md") {
|
|
"md" => office::presentation_to_markdown(input, output_dir)?,
|
|
"pdf" => {
|
|
let temporary = std::env::temp_dir()
|
|
.join(format!("shift-presentation-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&temporary).map_err(|error| error.to_string())?;
|
|
let markdown = office::presentation_to_markdown(input, Some(&temporary))?;
|
|
let target_dir = output_dir.map(Path::to_path_buf).unwrap_or_else(|| {
|
|
input
|
|
.parent()
|
|
.unwrap_or_else(|| Path::new("."))
|
|
.to_path_buf()
|
|
});
|
|
let result = convert_document(&markdown, "pdf", Some(&target_dir), None)
|
|
.and_then(|generated| rename_office_output(generated, input, &target_dir));
|
|
let _ = fs::remove_dir_all(&temporary);
|
|
result?
|
|
}
|
|
other => {
|
|
return Err(format!(
|
|
"Presentations convert to Markdown or PDF, not {other}."
|
|
))
|
|
}
|
|
},
|
|
"convert" if is_spreadsheet => match target.unwrap_or("md") {
|
|
"md" => office::spreadsheet_to_markdown(input, output_dir)?,
|
|
"pdf" => {
|
|
let temporary = std::env::temp_dir()
|
|
.join(format!("shift-spreadsheet-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&temporary).map_err(|error| error.to_string())?;
|
|
let markdown = office::spreadsheet_to_markdown(input, Some(&temporary))?;
|
|
let target_dir = output_dir.map(Path::to_path_buf).unwrap_or_else(|| {
|
|
input
|
|
.parent()
|
|
.unwrap_or_else(|| Path::new("."))
|
|
.to_path_buf()
|
|
});
|
|
let result = convert_document(&markdown, "pdf", Some(&target_dir), None)
|
|
.and_then(|generated| rename_office_output(generated, input, &target_dir));
|
|
let _ = fs::remove_dir_all(&temporary);
|
|
result?
|
|
}
|
|
other => {
|
|
return Err(format!(
|
|
"Spreadsheets convert to Markdown or PDF, not {other}."
|
|
))
|
|
}
|
|
},
|
|
"convert" if media => convert_media(
|
|
input,
|
|
target.ok_or_else(|| "No target format selected.".to_string())?,
|
|
output_dir,
|
|
)?,
|
|
"convert" => convert_file(
|
|
input,
|
|
target.ok_or_else(|| "No target format selected.".to_string())?,
|
|
output_dir,
|
|
)?,
|
|
"compress" if media => compress_media(input, output_dir)?,
|
|
"compress" if is_pdf => pdf::compress(input, output_dir)?,
|
|
"compress" => compress_file(input, output_dir)?,
|
|
"stripMetadata" if is_pdf => pdf::strip_metadata(input, output_dir)?,
|
|
"stripMetadata" => strip_metadata(input, output_dir)?,
|
|
"resizeHalf" => resize_file(input, 0.5, output_dir)?,
|
|
"rotate" if is_pdf => pdf::rotate(input, 90, output_dir)?,
|
|
"rotate" => rotate_file(input, output_dir)?,
|
|
"flip" => flip_file(input, output_dir)?,
|
|
"grayscale" => grayscale_file(input, output_dir)?,
|
|
"mute" if is_video => mute_video(input, output_dir)?,
|
|
"resize720" if is_video => resize_video_720(input, output_dir)?,
|
|
"frame" if is_video => frame_video(input, output_dir)?,
|
|
"mono" if is_audio => mono_audio(input, output_dir)?,
|
|
"crop" => {
|
|
let rect = crate::models::NormalizedRect {
|
|
x: 0.08,
|
|
y: 0.08,
|
|
width: 0.84,
|
|
height: 0.84,
|
|
};
|
|
crop_file(input, &rect, output_dir)?
|
|
}
|
|
other => return Err(format!("Unsupported action: {other}")),
|
|
};
|
|
outputs.push(output.to_string_lossy().to_string());
|
|
}
|
|
Ok(ActionOutcome {
|
|
message: if outputs.len() == 1 {
|
|
"Saved 1 file.".into()
|
|
} else {
|
|
format!("Saved {} files.", outputs.len())
|
|
},
|
|
outputs,
|
|
})
|
|
}
|
|
|
|
pub fn editor_kind(path: &Path) -> &'static str {
|
|
let ext = extension_of(path);
|
|
if IMAGE_EXTENSIONS.contains(&ext.as_str()) {
|
|
"image"
|
|
} else if VIDEO_EXTENSIONS.contains(&ext.as_str()) {
|
|
"video"
|
|
} else if matches!(ext.as_str(), "txt" | "md" | "csv" | "tsv" | "html" | "htm") {
|
|
"text"
|
|
} else {
|
|
"file"
|
|
}
|
|
}
|
|
|
|
/// Every command in this file reads, decodes or spawns, so each one runs on a
|
|
/// blocking thread: the webview stays responsive while previews are decoded and
|
|
/// while a conversion writes its output.
|
|
#[tauri::command]
|
|
pub async fn inspect_files(paths: Vec<String>) -> Result<Vec<FileInfo>, String> {
|
|
tauri::async_runtime::spawn_blocking(move || inspect_paths(&paths))
|
|
.await
|
|
.map_err(|error| error.to_string())?
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn perform_file_action(
|
|
app: AppHandle,
|
|
job_id: String,
|
|
action: String,
|
|
paths: Vec<String>,
|
|
target: Option<String>,
|
|
) -> Result<(), String> {
|
|
// Return immediately and report through events. The webview never waits on
|
|
// a slow encoder or document renderer before it can paint the busy state.
|
|
let worker = app.clone();
|
|
std::thread::Builder::new()
|
|
.name("shift-file-action".into())
|
|
.spawn(move || {
|
|
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(
|
|
|| -> Result<ActionOutcome, String> {
|
|
let output_dir = settings::files_output_dir(&worker)?;
|
|
let auto_reveal = settings::auto_reveal(&worker);
|
|
let progress_worker = worker.clone();
|
|
let progress_job = job_id.clone();
|
|
let outcome = perform_action(
|
|
&action,
|
|
&paths,
|
|
target.as_deref(),
|
|
output_dir.as_deref(),
|
|
Some(&|done, total, packaging| {
|
|
let _ = progress_worker.emit(
|
|
"app://file-action-progress",
|
|
FileActionProgress {
|
|
job_id: progress_job.clone(),
|
|
done,
|
|
total,
|
|
packaging,
|
|
},
|
|
);
|
|
}),
|
|
)?;
|
|
if auto_reveal {
|
|
if let Some(first) = outcome.outputs.first() {
|
|
let path = Path::new(first);
|
|
if path.exists() {
|
|
let _ = reveal_path(path);
|
|
}
|
|
}
|
|
}
|
|
Ok(outcome)
|
|
},
|
|
))
|
|
.unwrap_or_else(|_| Err("File action stopped unexpectedly.".into()));
|
|
|
|
match result {
|
|
Ok(outcome) => {
|
|
let _ = worker.emit("app://file-result", outcome.clone());
|
|
let _ = worker.emit(
|
|
"app://file-action-finished",
|
|
ActionResultEvent {
|
|
job_id,
|
|
outcome: Some(outcome),
|
|
error: None,
|
|
},
|
|
);
|
|
}
|
|
Err(error) => {
|
|
let _ = worker.emit(
|
|
"app://file-action-finished",
|
|
ActionResultEvent {
|
|
job_id,
|
|
outcome: None,
|
|
error: Some(error),
|
|
},
|
|
);
|
|
}
|
|
}
|
|
})
|
|
.map_err(|error| format!("Could not start the file action: {error}"))?;
|
|
Ok(())
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn reveal_file(path: String) -> Result<(), String> {
|
|
tauri::async_runtime::spawn_blocking(move || reveal_path(Path::new(&path)))
|
|
.await
|
|
.map_err(|error| error.to_string())?
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn existing_files(paths: Vec<String>) -> Vec<String> {
|
|
tauri::async_runtime::spawn_blocking(move || {
|
|
paths
|
|
.into_iter()
|
|
.filter(|path| Path::new(path).is_file())
|
|
.collect()
|
|
})
|
|
.await
|
|
.unwrap_or_default()
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn open_file(path: String) -> Result<(), String> {
|
|
tauri::async_runtime::spawn_blocking(move || open_path(Path::new(&path)))
|
|
.await
|
|
.map_err(|error| error.to_string())?
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn read_text_file(path: String) -> Result<String, String> {
|
|
tauri::async_runtime::spawn_blocking(move || {
|
|
fs::read_to_string(path).map_err(|error| error.to_string())
|
|
})
|
|
.await
|
|
.map_err(|error| error.to_string())?
|
|
}
|
|
|
|
/// Return image bytes as a data URL. The editor draws this into a canvas and
|
|
/// exports it later; loading through `asset://` would taint the canvas in
|
|
/// WKWebView and make `toDataURL` fail with SecurityError.
|
|
#[tauri::command]
|
|
pub async fn read_image_data(path: String) -> Result<String, String> {
|
|
tauri::async_runtime::spawn_blocking(move || image_data_url(Path::new(&path)))
|
|
.await
|
|
.map_err(|error| error.to_string())?
|
|
}
|
|
|
|
fn image_data_url(path: &Path) -> Result<String, String> {
|
|
let ext = extension_of(path);
|
|
if !IMAGE_EXTENSIONS.contains(&ext.as_str()) {
|
|
return Err("This file is not a supported image.".to_string());
|
|
}
|
|
let bytes = fs::read(path).map_err(|error| error.to_string())?;
|
|
Ok(format!(
|
|
"data:{};base64,{}",
|
|
image_mime(&ext),
|
|
STANDARD.encode(bytes)
|
|
))
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn save_image_data(
|
|
app: AppHandle,
|
|
source: String,
|
|
data_url: String,
|
|
suffix: Option<String>,
|
|
) -> Result<String, String> {
|
|
tauri::async_runtime::spawn_blocking(move || {
|
|
let output_dir = settings::files_output_dir(&app)?;
|
|
save_image_data_in(&source, &data_url, suffix.as_deref(), output_dir.as_deref())
|
|
})
|
|
.await
|
|
.map_err(|error| error.to_string())?
|
|
}
|
|
|
|
fn save_image_data_in(
|
|
source: &str,
|
|
data_url: &str,
|
|
suffix: Option<&str>,
|
|
output_dir: Option<&Path>,
|
|
) -> Result<String, String> {
|
|
let encoded = data_url
|
|
.split_once(',')
|
|
.map(|(_, value)| value)
|
|
.ok_or_else(|| "Invalid image data.".to_string())?;
|
|
let bytes = STANDARD
|
|
.decode(encoded)
|
|
.map_err(|error| format!("Invalid image data: {error}"))?;
|
|
let image = image::load_from_memory(&bytes)
|
|
.map_err(|error| format!("Could not decode edited image: {error}"))?;
|
|
let input = Path::new(source);
|
|
let output = unique_output_in(input, output_dir, suffix.unwrap_or(" (annotated)"), "png")?;
|
|
image
|
|
.save_with_format(&output, ImageFormat::Png)
|
|
.map_err(|error| format!("Could not write {}: {error}", output.display()))?;
|
|
Ok(output.to_string_lossy().to_string())
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn render_pdf_pages(app: AppHandle, path: String) -> Result<Vec<String>, String> {
|
|
tauri::async_runtime::spawn_blocking(move || {
|
|
let folder = app_cache_dir(&app)?.join(format!(
|
|
"ocr-{}",
|
|
chrono::Local::now().format("%Y%m%d-%H%M%S-%3f")
|
|
));
|
|
pdf::to_images_in(Path::new(&path), "png", &folder).map(|pages| {
|
|
pages
|
|
.into_iter()
|
|
.map(|page| page.to_string_lossy().to_string())
|
|
.collect()
|
|
})
|
|
})
|
|
.await
|
|
.map_err(|error| error.to_string())?
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn cleanup_pdf_pages(app: AppHandle, paths: Vec<String>) -> Result<(), String> {
|
|
tauri::async_runtime::spawn_blocking(move || {
|
|
let cache = app_cache_dir(&app)?;
|
|
let canonical_cache = fs::canonicalize(&cache).map_err(|error| error.to_string())?;
|
|
for path in paths {
|
|
let path = PathBuf::from(path);
|
|
if let Some(parent) = path.parent() {
|
|
let is_pdf_page_dir = parent
|
|
.file_name()
|
|
.and_then(|name| name.to_str())
|
|
.is_some_and(|name| name.starts_with("ocr-"))
|
|
&& fs::canonicalize(parent)
|
|
.ok()
|
|
.and_then(|directory| directory.parent().map(Path::to_path_buf))
|
|
.is_some_and(|directory| directory == canonical_cache);
|
|
if is_pdf_page_dir {
|
|
let _ = fs::remove_dir_all(parent);
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
})
|
|
.await
|
|
.map_err(|error| error.to_string())?
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn save_text_near(
|
|
app: AppHandle,
|
|
source: String,
|
|
text: String,
|
|
suffix: Option<String>,
|
|
) -> Result<String, String> {
|
|
tauri::async_runtime::spawn_blocking(move || {
|
|
let output_dir = settings::files_output_dir(&app)?;
|
|
save_text_near_in(&source, &text, suffix.as_deref(), output_dir.as_deref())
|
|
})
|
|
.await
|
|
.map_err(|error| error.to_string())?
|
|
}
|
|
|
|
fn save_text_near_in(
|
|
source: &str,
|
|
text: &str,
|
|
suffix: Option<&str>,
|
|
output_dir: Option<&Path>,
|
|
) -> Result<String, String> {
|
|
let input = Path::new(source);
|
|
let output = unique_output_in(input, output_dir, suffix.unwrap_or(" (OCR)"), "txt")?;
|
|
fs::write(&output, text).map_err(|error| describe_write_error(&output, error))?;
|
|
Ok(output.to_string_lossy().to_string())
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
pub fn app_cache_dir(app: &AppHandle) -> Result<PathBuf, String> {
|
|
let dir = app
|
|
.path()
|
|
.app_cache_dir()
|
|
.map_err(|error| error.to_string())?
|
|
.join("captures");
|
|
fs::create_dir_all(&dir).map_err(|error| error.to_string())?;
|
|
Ok(dir)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use image::{Rgba, RgbaImage};
|
|
|
|
fn scratch_dir() -> PathBuf {
|
|
let path = std::env::temp_dir().join(format!("shift-test-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&path).unwrap();
|
|
path
|
|
}
|
|
|
|
fn sample_image(path: &Path) {
|
|
let image = RgbaImage::from_pixel(32, 20, Rgba([240, 100, 40, 255]));
|
|
image.save_with_format(path, ImageFormat::Png).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn converts_and_avoids_overwriting() {
|
|
let dir = scratch_dir();
|
|
let input = dir.join("sample.png");
|
|
sample_image(&input);
|
|
|
|
let first = convert_file(&input, "jpg", None).unwrap();
|
|
let second = convert_file(&input, "jpg", None).unwrap();
|
|
assert!(first.exists());
|
|
assert!(second.exists());
|
|
assert_ne!(first, second);
|
|
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
#[test]
|
|
fn converts_system_only_image_formats_to_native_webp() {
|
|
let dir = scratch_dir();
|
|
let input = dir.join("sample.png");
|
|
sample_image(&input);
|
|
let heic = dir.join("sample.heic");
|
|
if system_convert(&input, &heic, "heic").is_err() {
|
|
fs::remove_dir_all(dir).unwrap();
|
|
return;
|
|
}
|
|
|
|
let output = convert_file(&heic, "webp", None).unwrap();
|
|
assert_eq!(
|
|
output.extension().and_then(|value| value.to_str()),
|
|
Some("webp")
|
|
);
|
|
assert!(image::open(&output).is_ok());
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn custom_output_directory_collects_results() {
|
|
let dir = scratch_dir();
|
|
let output_dir = dir.join("Shift");
|
|
let input = dir.join("sample.png");
|
|
sample_image(&input);
|
|
|
|
let outcome = perform_action(
|
|
"convert",
|
|
&[input.to_string_lossy().to_string()],
|
|
Some("jpg"),
|
|
Some(&output_dir),
|
|
None,
|
|
)
|
|
.unwrap();
|
|
|
|
assert_eq!(outcome.outputs.len(), 1);
|
|
assert!(Path::new(&outcome.outputs[0]).exists());
|
|
assert_eq!(
|
|
Path::new(&outcome.outputs[0]).parent(),
|
|
Some(output_dir.as_path())
|
|
);
|
|
assert!(input.exists());
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn text_results_follow_the_custom_directory() {
|
|
let dir = scratch_dir();
|
|
let output_dir = dir.join("Shift");
|
|
let input = dir.join("sample.png");
|
|
sample_image(&input);
|
|
|
|
let output = save_text_near_in(
|
|
input.to_string_lossy().as_ref(),
|
|
"hello",
|
|
Some(" (OCR)"),
|
|
Some(&output_dir),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(fs::read_to_string(&output).unwrap(), "hello");
|
|
assert_eq!(Path::new(&output).parent(), Some(output_dir.as_path()));
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn saves_edited_image_data() {
|
|
let dir = scratch_dir();
|
|
let input = dir.join("shot.png");
|
|
sample_image(&input);
|
|
let data_url = image_data_url(&input).unwrap();
|
|
assert!(data_url.starts_with("data:image/png;base64,"));
|
|
let data = fs::read(&input).unwrap();
|
|
assert_eq!(
|
|
data_url,
|
|
format!("data:image/png;base64,{}", STANDARD.encode(data))
|
|
);
|
|
let output = save_image_data_in(
|
|
input.to_string_lossy().as_ref(),
|
|
&data_url,
|
|
Some(" (annotated)"),
|
|
None,
|
|
)
|
|
.unwrap();
|
|
assert!(Path::new(&output).exists());
|
|
assert!(output.contains("(annotated)"));
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn edits_keep_the_source_untouched() {
|
|
let dir = scratch_dir();
|
|
let input = dir.join("sample.png");
|
|
sample_image(&input);
|
|
let original = fs::read(&input).unwrap();
|
|
|
|
let compressed = compress_file(&input, None).unwrap();
|
|
let resized = resize_file(&input, 0.5, None).unwrap();
|
|
let rotated = rotate_file(&input, None).unwrap();
|
|
let flipped = flip_file(&input, None).unwrap();
|
|
let grayscale = grayscale_file(&input, None).unwrap();
|
|
let cropped = crop_file(
|
|
&input,
|
|
&crate::models::NormalizedRect {
|
|
x: 0.25,
|
|
y: 0.25,
|
|
width: 0.5,
|
|
height: 0.5,
|
|
},
|
|
None,
|
|
)
|
|
.unwrap();
|
|
|
|
assert!(compressed.exists());
|
|
assert_eq!(image::image_dimensions(resized).unwrap(), (16, 10));
|
|
assert_eq!(image::image_dimensions(rotated).unwrap(), (20, 32));
|
|
assert!(flipped.exists());
|
|
assert!(grayscale.exists());
|
|
assert_eq!(image::image_dimensions(cropped).unwrap(), (16, 10));
|
|
assert_eq!(fs::read(&input).unwrap(), original);
|
|
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn converts_media_when_ffmpeg_is_available() {
|
|
if which::which("ffmpeg").is_err() {
|
|
return;
|
|
}
|
|
let dir = scratch_dir();
|
|
let input = dir.join("sample.mp4");
|
|
let status = Command::new("ffmpeg")
|
|
.args([
|
|
"-y",
|
|
"-f",
|
|
"lavfi",
|
|
"-i",
|
|
"testsrc=size=320x240:rate=10",
|
|
"-t",
|
|
"1",
|
|
"-pix_fmt",
|
|
"yuv420p",
|
|
input.to_string_lossy().as_ref(),
|
|
])
|
|
.status()
|
|
.unwrap();
|
|
assert!(status.success());
|
|
|
|
let gif = convert_media(&input, "gif", None).unwrap();
|
|
let compressed = compress_media(&input, None).unwrap();
|
|
let muted = mute_video(&input, None).unwrap();
|
|
let hd = resize_video_720(&input, None).unwrap();
|
|
let frame = frame_video(&input, None).unwrap();
|
|
assert!(gif.exists());
|
|
assert!(compressed.exists());
|
|
assert!(muted.exists());
|
|
assert!(hd.exists());
|
|
assert!(frame.exists());
|
|
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn converts_audio_to_mp3_when_an_encoder_is_available() {
|
|
if which::which("ffmpeg").is_err() {
|
|
return;
|
|
}
|
|
if !ffmpeg_has_encoder("libmp3lame") && which::which("lame").is_err() {
|
|
return;
|
|
}
|
|
let dir = scratch_dir();
|
|
let input = dir.join("sample.m4a");
|
|
let status = Command::new("ffmpeg")
|
|
.args([
|
|
"-y",
|
|
"-f",
|
|
"lavfi",
|
|
"-i",
|
|
"sine=frequency=440:duration=1",
|
|
"-c:a",
|
|
"aac",
|
|
input.to_string_lossy().as_ref(),
|
|
])
|
|
.status()
|
|
.unwrap();
|
|
assert!(status.success());
|
|
|
|
let output = convert_media(&input, "mp3", None).unwrap();
|
|
let mono = mono_audio(&input, None).unwrap();
|
|
assert!(output.exists());
|
|
assert!(mono.exists());
|
|
assert_eq!(
|
|
output.extension().and_then(|value| value.to_str()),
|
|
Some("mp3")
|
|
);
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn converts_documents_when_pandoc_is_available() {
|
|
if which::which("pandoc").is_err() {
|
|
return;
|
|
}
|
|
let dir = scratch_dir();
|
|
let input = dir.join("sample.html");
|
|
fs::write(
|
|
&input,
|
|
"<h1>Shift</h1><p>Local <strong>documents</strong>.</p>",
|
|
)
|
|
.unwrap();
|
|
let output = convert_document(&input, "md", None, None).unwrap();
|
|
let text = fs::read_to_string(output).unwrap();
|
|
assert!(text.contains("# Shift"));
|
|
assert!(text.contains("**documents**"));
|
|
let html = convert_document(&input, "html", None, None).unwrap();
|
|
assert!(fs::read_to_string(html)
|
|
.unwrap()
|
|
.contains("<!DOCTYPE html>"));
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
#[test]
|
|
fn textutil_fallback_converts_markdown_to_word_formats() {
|
|
for target in ["docx", "rtf"] {
|
|
let dir = scratch_dir();
|
|
let input = dir.join("note.md");
|
|
fs::write(&input, "# Shift\n\nLocal **documents**.\n").unwrap();
|
|
|
|
let output = textutil_convert(&input, target, None)
|
|
.unwrap()
|
|
.unwrap_or_else(|| panic!("textutil did not write {target}"));
|
|
assert_eq!(
|
|
output.extension().and_then(|value| value.to_str()),
|
|
Some(target)
|
|
);
|
|
assert!(output.exists(), "{output:?}");
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
#[test]
|
|
fn renders_documents_to_pdf_with_native_helper() {
|
|
let dir = scratch_dir();
|
|
let input = dir.join("sample.html");
|
|
fs::write(&input, "<h1>Shift</h1><p>Native PDF.</p>").unwrap();
|
|
let output = convert_document(&input, "pdf", None, None).unwrap();
|
|
assert!(output.exists());
|
|
assert_eq!(
|
|
output.extension().and_then(|value| value.to_str()),
|
|
Some("pdf")
|
|
);
|
|
assert!(fs::read(&output).unwrap().starts_with(b"%PDF"));
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
#[test]
|
|
fn renders_image_only_docx_pages_to_pdf() {
|
|
use std::io::Write as _;
|
|
use zip::{write::SimpleFileOptions, ZipWriter};
|
|
|
|
let dir = scratch_dir();
|
|
let first = dir.join("first.png");
|
|
let second = dir.join("second.png");
|
|
sample_image(&first);
|
|
sample_image(&second);
|
|
let input = dir.join("scan.docx");
|
|
let file = fs::File::create(&input).unwrap();
|
|
let mut zip = ZipWriter::new(file);
|
|
zip.start_file("word/_rels/document.xml.rels", SimpleFileOptions::default())
|
|
.unwrap();
|
|
zip.write_all(
|
|
br#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
|
|
<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="media/first.png"/>
|
|
<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="media/second.png"/>
|
|
</Relationships>"#,
|
|
)
|
|
.unwrap();
|
|
zip.start_file("word/document.xml", SimpleFileOptions::default())
|
|
.unwrap();
|
|
zip.write_all(
|
|
br#"<w:document xmlns:w="w" xmlns:a="a" xmlns:r="r"><w:body>
|
|
<w:p><w:r><w:drawing><a:blip r:embed="rId1"/></w:drawing></w:r></w:p>
|
|
<w:p><w:r><w:drawing><a:blip r:embed="rId2"/></w:drawing></w:r></w:p>
|
|
</w:body></w:document>"#,
|
|
)
|
|
.unwrap();
|
|
for (name, path) in [("first.png", &first), ("second.png", &second)] {
|
|
zip.start_file(format!("word/media/{name}"), SimpleFileOptions::default())
|
|
.unwrap();
|
|
zip.write_all(&fs::read(path).unwrap()).unwrap();
|
|
}
|
|
zip.finish().unwrap();
|
|
|
|
let progress = std::sync::Mutex::new(Vec::new());
|
|
let report = |done, total, packaging| {
|
|
progress.lock().unwrap().push((done, total, packaging));
|
|
};
|
|
let output = convert_document(&input, "pdf", None, Some(&report)).unwrap();
|
|
let pages = lopdf::Document::load(&output).unwrap().get_pages().len();
|
|
assert_eq!(pages, 2);
|
|
assert_eq!(
|
|
*progress.lock().unwrap(),
|
|
vec![(1, 2, false), (2, 2, false)]
|
|
);
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
#[test]
|
|
fn renders_presentations_to_pdf() {
|
|
use std::io::Write as _;
|
|
use zip::{write::SimpleFileOptions, ZipWriter};
|
|
|
|
let dir = scratch_dir();
|
|
let input = dir.join("slides.pptx");
|
|
let file = fs::File::create(&input).unwrap();
|
|
let mut zip = ZipWriter::new(file);
|
|
zip.start_file("ppt/slides/slide1.xml", SimpleFileOptions::default())
|
|
.unwrap();
|
|
zip.write_all(
|
|
br#"<p:sld xmlns:p="p" xmlns:a="a"><a:p><a:r><a:t>Hello</a:t></a:r></a:p></p:sld>"#,
|
|
)
|
|
.unwrap();
|
|
zip.finish().unwrap();
|
|
|
|
let outcome = perform_action(
|
|
"convert",
|
|
&[input.to_string_lossy().to_string()],
|
|
Some("pdf"),
|
|
Some(&dir),
|
|
None,
|
|
)
|
|
.unwrap();
|
|
assert_eq!(outcome.outputs.len(), 1);
|
|
assert!(outcome.outputs[0].ends_with("slides.pdf"));
|
|
assert!(fs::read(&outcome.outputs[0]).unwrap().starts_with(b"%PDF"));
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
#[test]
|
|
fn renders_spreadsheets_to_pdf() {
|
|
let dir = scratch_dir();
|
|
let input = dir.join("sheet.csv");
|
|
fs::write(&input, "name,value\nAlpha,1\n").unwrap();
|
|
|
|
let outcome = perform_action(
|
|
"convert",
|
|
&[input.to_string_lossy().to_string()],
|
|
Some("pdf"),
|
|
Some(&dir),
|
|
None,
|
|
)
|
|
.unwrap();
|
|
assert_eq!(outcome.outputs.len(), 1);
|
|
assert!(outcome.outputs[0].ends_with("sheet.pdf"));
|
|
assert!(fs::read(&outcome.outputs[0]).unwrap().starts_with(b"%PDF"));
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn converts_pdf_text_layer_to_docx_when_pandoc_is_available() {
|
|
if which::which("pandoc").is_err() {
|
|
return;
|
|
}
|
|
let dir = scratch_dir();
|
|
let input = dir.join("report.pdf");
|
|
write_text_pdf(&input, "Quarterly numbers");
|
|
|
|
let outcome = perform_action(
|
|
"convert",
|
|
&[input.to_string_lossy().to_string()],
|
|
Some("docx"),
|
|
None,
|
|
None,
|
|
)
|
|
.expect("a PDF text layer should convert to DOCX");
|
|
assert_eq!(outcome.outputs.len(), 1);
|
|
assert!(
|
|
outcome.outputs[0].ends_with("report.docx"),
|
|
"output must follow the requested format, not .pdf: {:?}",
|
|
outcome.outputs[0]
|
|
);
|
|
assert!(Path::new(&outcome.outputs[0]).exists());
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn converts_pdf_text_layer_to_rtf_when_pandoc_is_available() {
|
|
if which::which("pandoc").is_err() {
|
|
return;
|
|
}
|
|
let dir = scratch_dir();
|
|
let input = dir.join("report.pdf");
|
|
write_text_pdf(&input, "Quarterly numbers");
|
|
|
|
let outcome = perform_action(
|
|
"convert",
|
|
&[input.to_string_lossy().to_string()],
|
|
Some("rtf"),
|
|
None,
|
|
None,
|
|
)
|
|
.expect("PDF to RTF failed");
|
|
assert_eq!(outcome.outputs.len(), 1);
|
|
assert!(
|
|
outcome.outputs[0].ends_with("report.rtf"),
|
|
"output must follow the requested format: {:?}",
|
|
outcome.outputs[0]
|
|
);
|
|
assert!(fs::read_to_string(&outcome.outputs[0])
|
|
.unwrap()
|
|
.starts_with("{\\rtf1"));
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn pdf_to_odt_is_rejected() {
|
|
let dir = scratch_dir();
|
|
let input = dir.join("report.pdf");
|
|
write_text_pdf(&input, "Quarterly numbers");
|
|
|
|
let error = perform_action(
|
|
"convert",
|
|
&[input.to_string_lossy().to_string()],
|
|
Some("odt"),
|
|
None,
|
|
None,
|
|
)
|
|
.unwrap_err();
|
|
assert!(error.contains("DOCX or RTF"), "{error}");
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn pdf_docx_conversion_honours_a_custom_output_folder() {
|
|
if which::which("pandoc").is_err() {
|
|
return;
|
|
}
|
|
let dir = scratch_dir();
|
|
let output_dir = dir.join("Shift");
|
|
let input = dir.join("nested").join("report.pdf");
|
|
fs::create_dir_all(input.parent().unwrap()).unwrap();
|
|
write_text_pdf(&input, "Budget details");
|
|
|
|
let outcome = perform_action(
|
|
"convert",
|
|
&[input.to_string_lossy().to_string()],
|
|
Some("docx"),
|
|
Some(&output_dir),
|
|
None,
|
|
)
|
|
.unwrap();
|
|
let produced = PathBuf::from(&outcome.outputs[0]);
|
|
assert_eq!(
|
|
produced.parent(),
|
|
Some(output_dir.as_path()),
|
|
"a custom output folder must win over the source folder: {produced:?}"
|
|
);
|
|
assert!(
|
|
produced.to_string_lossy().contains("report"),
|
|
"{produced:?}"
|
|
);
|
|
assert_eq!(produced.extension().and_then(|v| v.to_str()), Some("docx"));
|
|
// Nothing should leak next to the original.
|
|
assert!(!dir.join("nested").join("report.docx").exists());
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
/// A one-page PDF with a real text layer, built with the same crate the
|
|
/// production code reads through.
|
|
fn write_text_pdf(path: &Path, text: &str) {
|
|
use lopdf::{dictionary, Document, Object, Stream};
|
|
let mut document = Document::new();
|
|
let font_id = document.add_object(dictionary! {
|
|
"Type" => "Font", "Subtype" => "Type1", "BaseFont" => "Helvetica",
|
|
});
|
|
let content = format!("BT /F1 18 Tf 72 720 Td ({text}) Tj ET");
|
|
let content_id = document.add_object(Stream::new(dictionary! {}, content.into_bytes()));
|
|
let pages_id = document.add_object(
|
|
dictionary! { "Type" => "Pages", "Kids" => Vec::<Object>::new(), "Count" => 0_i64 },
|
|
);
|
|
let page_id = document.add_object(dictionary! {
|
|
"Type" => "Page",
|
|
"Parent" => pages_id,
|
|
"MediaBox" => vec![0.into(), 0.into(), 612.into(), 792.into()],
|
|
"Contents" => content_id,
|
|
"Resources" => dictionary! { "Font" => dictionary! { "F1" => font_id } },
|
|
});
|
|
document.objects.insert(
|
|
pages_id,
|
|
dictionary! { "Type" => "Pages", "Kids" => vec![Object::Reference(page_id)], "Count" => 1_i64 }
|
|
.into(),
|
|
);
|
|
let catalog = document.add_object(dictionary! { "Type" => "Catalog", "Pages" => pages_id });
|
|
document.trailer.set("Root", catalog);
|
|
document.save(path).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn converts_a_docx_back_to_markdown_when_pandoc_is_available() {
|
|
if which::which("pandoc").is_err() {
|
|
return;
|
|
}
|
|
let dir = scratch_dir();
|
|
let source = dir.join("sample.md");
|
|
let docx = dir.join("sample.docx");
|
|
fs::write(&source, "# Shift\n\nDocument round trip.\n").unwrap();
|
|
let status = Command::new("pandoc")
|
|
.arg(&source)
|
|
.args(["-o"])
|
|
.arg(&docx)
|
|
.status()
|
|
.unwrap();
|
|
assert!(status.success());
|
|
|
|
let output = convert_document(&docx, "md", None, None).unwrap();
|
|
let text = fs::read_to_string(output).unwrap();
|
|
assert!(text.contains("Shift"));
|
|
assert!(text.contains("Document round trip"));
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn image_bearing_docx_to_html_embeds_images() {
|
|
if which::which("pandoc").is_err() {
|
|
return;
|
|
}
|
|
let dir = scratch_dir();
|
|
let image = dir.join("sample.png");
|
|
sample_image(&image);
|
|
let source = dir.join("sample.md");
|
|
fs::write(&source, "\n").unwrap();
|
|
let docx = dir.join("sample.docx");
|
|
let status = Command::new("pandoc")
|
|
.current_dir(&dir)
|
|
.arg("sample.md")
|
|
.args(["-o", "sample.docx"])
|
|
.status()
|
|
.unwrap();
|
|
assert!(status.success());
|
|
|
|
let output = convert_document(&docx, "html", None, None).unwrap();
|
|
let html = fs::read_to_string(output).unwrap();
|
|
assert!(html.contains("<img"), "{html}");
|
|
assert!(html.contains("src=\"data:image/"), "{html}");
|
|
assert!(!html.contains("src=\"media/"), "{html}");
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
/// Writes an animated GIF with the given frame count and delay.
|
|
fn sample_animated_gif(path: &Path, frames: usize, delay_ms: u32) {
|
|
let mut buffer: Vec<u8> = Vec::new();
|
|
{
|
|
let mut encoder = image::codecs::gif::GifEncoder::new(&mut buffer);
|
|
for index in 0..frames {
|
|
let mut frame = RgbaImage::from_pixel(64, 48, Rgba([index as u8, 40, 90, 255]));
|
|
frame.put_pixel(0, 0, Rgba([255, 255, 255, 255]));
|
|
encoder
|
|
.encode_frame(Frame::from_parts(
|
|
frame,
|
|
0,
|
|
0,
|
|
Delay::from_numer_denom_ms(delay_ms, 1),
|
|
))
|
|
.unwrap();
|
|
}
|
|
}
|
|
fs::write(path, buffer).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn gif_conversion_keeps_animation() {
|
|
let dir = scratch_dir();
|
|
let input = dir.join("animated.gif");
|
|
sample_animated_gif(&input, 8, 50);
|
|
|
|
let output = convert_file(&input, "gif", None).unwrap();
|
|
let decoder = GifDecoder::new(BufReader::new(File::open(&output).unwrap())).unwrap();
|
|
let frames = decoder
|
|
.into_frames()
|
|
.collect::<Result<Vec<_>, _>>()
|
|
.unwrap();
|
|
assert_eq!(frames.len(), 8, "animation must survive the conversion");
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn gif_conversion_caps_duration_and_size() {
|
|
let dir = scratch_dir();
|
|
let input = dir.join("long.gif");
|
|
// 240 frames of 100 ms is 24 seconds, well past the 15 second cap.
|
|
sample_animated_gif(&input, 240, 100);
|
|
|
|
let output = convert_file(&input, "gif", None).unwrap();
|
|
let bytes = fs::metadata(&output).unwrap().len();
|
|
assert!(
|
|
bytes <= GIF_MAX_BYTES,
|
|
"GIF grew past the ceiling: {bytes} bytes"
|
|
);
|
|
|
|
let decoder = GifDecoder::new(BufReader::new(File::open(&output).unwrap())).unwrap();
|
|
let mut elapsed = 0_u32;
|
|
let mut count = 0_usize;
|
|
for frame in decoder.into_frames() {
|
|
let frame = frame.unwrap();
|
|
elapsed = elapsed.saturating_add(frame.delay().numer_denom_ms().0);
|
|
count += 1;
|
|
}
|
|
assert!(count <= GIF_MAX_FRAMES, "too many frames kept: {count}");
|
|
assert!(
|
|
elapsed <= GIF_MAX_MILLIS,
|
|
"animation is longer than the cap: {elapsed} ms"
|
|
);
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn gif_conversion_respects_a_tight_byte_ceiling() {
|
|
let dir = scratch_dir();
|
|
let input = dir.join("noisy.gif");
|
|
sample_animated_gif(&input, 40, 40);
|
|
|
|
let output = dir.join("small.gif");
|
|
save_gif_capped(&input, &output, 20_000).unwrap();
|
|
let bytes = fs::metadata(&output).unwrap().len();
|
|
assert!(bytes <= 20_000, "GIF grew past the ceiling: {bytes} bytes");
|
|
|
|
// The result must still be a readable GIF, not a truncated file.
|
|
let decoder = GifDecoder::new(BufReader::new(File::open(&output).unwrap())).unwrap();
|
|
assert!(decoder.into_frames().next().unwrap().is_ok());
|
|
fs::remove_dir_all(dir).unwrap();
|
|
}
|
|
}
|