1641 lines
62 KiB
Rust
1641 lines
62 KiB
Rust
use std::{
|
|
collections::BTreeMap,
|
|
fs,
|
|
io::Read,
|
|
path::{Path, PathBuf},
|
|
};
|
|
#[cfg(not(target_os = "macos"))]
|
|
use std::{
|
|
process::Stdio,
|
|
time::{Duration, Instant},
|
|
};
|
|
|
|
use image::GenericImageView;
|
|
use lopdf::{Document, Object, ObjectId};
|
|
use printpdf::{Mm, Op, PdfDocument, PdfPage, RawImage, XObjectTransform};
|
|
use zip::ZipArchive;
|
|
|
|
use crate::files::unique_output_in;
|
|
|
|
fn load(path: &Path) -> Result<Document, String> {
|
|
Document::load(path).map_err(|error| format!("Could not read {}: {error}", path.display()))
|
|
}
|
|
|
|
fn page_numbers(doc: &Document) -> Vec<u32> {
|
|
doc.get_pages().keys().copied().collect()
|
|
}
|
|
|
|
/// The JPEG pages are written by the renderer, so a failure here must be
|
|
/// reported instead of leaving a body-less or zero-page DOCX behind.
|
|
fn remove_on_error<T>(path: &Path, result: Result<T, String>) -> Result<T, String> {
|
|
if result.is_err() {
|
|
let _ = fs::remove_file(path);
|
|
}
|
|
result
|
|
}
|
|
|
|
/// Page content is normally only a few KiB even for an image-heavy page: the
|
|
/// pixels live in XObjects, not in the content stream. A much larger stream is
|
|
/// either malformed or a decompression bomb, and must not be inflated without
|
|
/// a bound.
|
|
const MAX_PAGE_CONTENT: usize = 16 * 1024 * 1024;
|
|
/// Poppler opens the document once for a whole batch. The timeout therefore
|
|
/// applies to a lack of new rendered pages, not to the entire document: a
|
|
/// hundred-page scan is slow but healthy, while a renderer stuck on one page
|
|
/// still fails without leaving the UI processing forever.
|
|
#[cfg(not(target_os = "macos"))]
|
|
const PDF_RENDER_STALL_TIMEOUT: Duration = Duration::from_secs(90);
|
|
/// Longest rendered page edge in pixels. Poppler's `-scale-to` is an edge
|
|
/// length, not a total-pixel budget: passing a pixel budget here would allow a
|
|
/// single scan page to become tens of thousands of pixels wide and exhaust
|
|
/// memory. 1800 px keeps Letter-sized pages at roughly 125-220 DPI while
|
|
/// bounding pathological pages before they reach GDI.
|
|
#[cfg(not(target_os = "macos"))]
|
|
const PDF_RENDER_MAX_EDGE: &str = "1800";
|
|
|
|
pub fn merge(paths: &[PathBuf], output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
if paths.len() < 2 {
|
|
return Err("Select at least two PDF files to merge.".into());
|
|
}
|
|
let mut max_id = 1;
|
|
let mut page_objects = BTreeMap::new();
|
|
let mut objects = BTreeMap::new();
|
|
let mut merged = Document::with_version("1.5");
|
|
|
|
for path in paths {
|
|
let mut document = load(path)?;
|
|
document.renumber_objects_with(max_id);
|
|
max_id = document.max_id + 1;
|
|
for page_id in document.get_pages().into_values() {
|
|
if let Ok(object) = document.get_object(page_id) {
|
|
page_objects.insert(page_id, object.clone());
|
|
}
|
|
}
|
|
objects.extend(document.objects);
|
|
}
|
|
|
|
let mut catalog: Option<(ObjectId, Object)> = None;
|
|
let mut pages_root: Option<(ObjectId, Object)> = None;
|
|
for (object_id, object) in objects {
|
|
match object.type_name().unwrap_or(b"") {
|
|
b"Catalog" => {
|
|
if catalog.is_none() {
|
|
catalog = Some((object_id, object));
|
|
}
|
|
}
|
|
b"Pages" => {
|
|
let mut dict = object.as_dict().map_err(|error| error.to_string())?.clone();
|
|
if let Some((_, Object::Dictionary(previous))) = pages_root.as_ref() {
|
|
dict.extend(previous);
|
|
}
|
|
pages_root = Some((
|
|
pages_root
|
|
.as_ref()
|
|
.map(|value| value.0)
|
|
.unwrap_or(object_id),
|
|
Object::Dictionary(dict),
|
|
));
|
|
}
|
|
b"Page" | b"Outlines" | b"Outline" => {}
|
|
_ => {
|
|
merged.objects.insert(object_id, object);
|
|
}
|
|
}
|
|
}
|
|
|
|
let (pages_id, pages_object) = pages_root.ok_or("No PDF pages found.")?;
|
|
let (catalog_id, catalog_object) = catalog.ok_or("No PDF catalog found.")?;
|
|
|
|
for (object_id, object) in page_objects {
|
|
let mut dict = object.as_dict().map_err(|error| error.to_string())?.clone();
|
|
dict.set("Parent", pages_id);
|
|
merged.objects.insert(object_id, Object::Dictionary(dict));
|
|
}
|
|
|
|
let mut pages_dict = pages_object
|
|
.as_dict()
|
|
.map_err(|error| error.to_string())?
|
|
.clone();
|
|
let kids: Vec<Object> = merged
|
|
.objects
|
|
.iter()
|
|
.filter_map(|(id, object)| {
|
|
if object.type_name().ok() == Some(b"Page") {
|
|
Some(Object::Reference(*id))
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect();
|
|
pages_dict.set("Kids", kids);
|
|
pages_dict.set(
|
|
"Count",
|
|
merged
|
|
.objects
|
|
.values()
|
|
.filter(|object| object.type_name().ok() == Some(b"Page"))
|
|
.count() as i64,
|
|
);
|
|
merged
|
|
.objects
|
|
.insert(pages_id, Object::Dictionary(pages_dict));
|
|
|
|
let mut catalog_dict = catalog_object
|
|
.as_dict()
|
|
.map_err(|error| error.to_string())?
|
|
.clone();
|
|
catalog_dict.set("Pages", pages_id);
|
|
catalog_dict.remove(b"Outlines");
|
|
merged
|
|
.objects
|
|
.insert(catalog_id, Object::Dictionary(catalog_dict));
|
|
merged.trailer.set("Root", catalog_id);
|
|
merged.renumber_objects();
|
|
let output = unique_output_in(&paths[0], output_dir, " (merged)", "pdf")?;
|
|
merged
|
|
.save(&output)
|
|
.map_err(|error| format!("Could not save merged PDF: {error}"))?;
|
|
Ok(output)
|
|
}
|
|
|
|
pub fn split(input: &Path, output_dir: Option<&Path>) -> Result<Vec<PathBuf>, String> {
|
|
let page_count = load(input)?.get_pages().len();
|
|
let parent = output_dir.map(PathBuf::from).unwrap_or_else(|| {
|
|
input
|
|
.parent()
|
|
.unwrap_or_else(|| Path::new("."))
|
|
.to_path_buf()
|
|
});
|
|
let stem = input
|
|
.file_stem()
|
|
.and_then(|value| value.to_str())
|
|
.unwrap_or("PDF");
|
|
let mut folder = parent.join(format!("{stem} pages"));
|
|
let mut counter = 2;
|
|
while folder.exists() {
|
|
folder = parent.join(format!("{stem} pages {counter}"));
|
|
counter += 1;
|
|
}
|
|
fs::create_dir_all(&folder).map_err(|error| error.to_string())?;
|
|
let all_pages: Vec<u32> = (1..=page_count as u32).collect();
|
|
let mut outputs = Vec::new();
|
|
for page_number in 1..=page_count as u32 {
|
|
let mut document = load(input)?;
|
|
let remove: Vec<u32> = all_pages
|
|
.iter()
|
|
.copied()
|
|
.filter(|number| *number != page_number)
|
|
.collect();
|
|
document.delete_pages(&remove);
|
|
let output = folder.join(format!("Page {page_number:03}.pdf"));
|
|
document
|
|
.save(&output)
|
|
.map_err(|error| format!("Could not save page {page_number}: {error}"))?;
|
|
outputs.push(output);
|
|
}
|
|
Ok(outputs)
|
|
}
|
|
|
|
pub fn rotate(input: &Path, degrees: i64, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let mut document = load(input)?;
|
|
let page_ids: Vec<ObjectId> = document.get_pages().into_values().collect();
|
|
for page_id in page_ids {
|
|
let object = document
|
|
.get_object_mut(page_id)
|
|
.map_err(|error| error.to_string())?;
|
|
let dict = object.as_dict_mut().map_err(|error| error.to_string())?;
|
|
let current = dict
|
|
.get(b"Rotate")
|
|
.ok()
|
|
.and_then(|value| value.as_i64().ok())
|
|
.unwrap_or(0);
|
|
dict.set("Rotate", (current + degrees).rem_euclid(360));
|
|
}
|
|
let output = unique_output_in(input, output_dir, " (rotated)", "pdf")?;
|
|
document
|
|
.save(&output)
|
|
.map_err(|error| format!("Could not save rotated PDF: {error}"))?;
|
|
Ok(output)
|
|
}
|
|
|
|
/// The text layer of a PDF, or a clear error when it is a scan.
|
|
pub fn text_of(input: &Path) -> Result<String, String> {
|
|
let document = load(input)?;
|
|
let pages = page_numbers(&document);
|
|
let mut text = String::new();
|
|
for page in pages {
|
|
match document.extract_text_with_limit(&[page], MAX_PAGE_CONTENT) {
|
|
Ok(page_text) => {
|
|
text.push_str(&page_text);
|
|
if !page_text.ends_with('\n') {
|
|
text.push('\n');
|
|
}
|
|
}
|
|
Err(lopdf::Error::Decompress(
|
|
lopdf::DecompressError::MemoryLimitExceeded { .. },
|
|
)) => {
|
|
return Err(
|
|
"A page in this PDF is too large to extract safely. Convert it to Word to keep the page images."
|
|
.into(),
|
|
)
|
|
}
|
|
Err(error) => {
|
|
return Err(format!("Could not extract PDF text: {error}"));
|
|
}
|
|
}
|
|
}
|
|
if text.trim().is_empty() {
|
|
return Err("This PDF has no text layer. Use OCR instead for scanned PDFs.".into());
|
|
}
|
|
Ok(text)
|
|
}
|
|
|
|
/// PDF-to-Word keeps text selectable unless the document actually contains
|
|
/// raster content. Looking at the object graph first avoids running a text
|
|
/// extraction over the large image streams that make scanned PDFs slow.
|
|
pub fn has_embedded_images(input: &Path) -> Result<bool, String> {
|
|
#[cfg(not(target_os = "macos"))]
|
|
if let Some(pdfimages) = crate::files::resolve_tool("pdfimages") {
|
|
if let Ok(has_images) = pdfimages_has_images(&pdfimages, input) {
|
|
return Ok(has_images);
|
|
}
|
|
}
|
|
|
|
let document = load(input)?;
|
|
Ok(document.objects.values().any(|object| {
|
|
matches!(
|
|
object,
|
|
Object::Stream(stream)
|
|
if is_name(stream.dict.get(b"Subtype"), b"Image")
|
|
)
|
|
}))
|
|
}
|
|
|
|
#[cfg(not(target_os = "macos"))]
|
|
fn pdfimages_has_images(pdfimages: &Path, input: &Path) -> Result<bool, String> {
|
|
let output = crate::process::output_with_timeout(
|
|
pdfimages,
|
|
&["-list", input.to_string_lossy().as_ref()],
|
|
Duration::from_secs(15),
|
|
)?;
|
|
if !output.status.success() {
|
|
return Err("The PDF image listing command failed.".to_string());
|
|
}
|
|
Ok(String::from_utf8_lossy(&output.stdout).lines().any(|line| {
|
|
line.split_whitespace()
|
|
.next()
|
|
.is_some_and(|page| page.parse::<u32>().is_ok())
|
|
}))
|
|
}
|
|
|
|
/// Converts a PDF to DOCX by rendering complete pages. Keeping the page bitmap
|
|
/// preserves diagrams, screenshots and vector artwork without first walking
|
|
/// every image stream in the PDF, which is prohibitively slow for scan-heavy
|
|
/// files on Windows. Pages stream into the package one at a time so a long
|
|
/// document does not need a second full-size copy in memory.
|
|
pub fn to_docx(input: &Path, output: &Path) -> Result<(), String> {
|
|
to_docx_with_progress(input, output, |_, _, _| {})
|
|
}
|
|
|
|
/// Page-level progress lets the ring say which page is running, so a long scan
|
|
/// does not look frozen even though the work is already off the UI thread.
|
|
pub fn to_docx_with_progress(
|
|
input: &Path,
|
|
output: &Path,
|
|
mut on_progress: impl FnMut(u32, u32, bool),
|
|
) -> Result<(), String> {
|
|
let _ = fs::remove_file(output);
|
|
let work = std::env::temp_dir().join(format!("shift-pdf-docx-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&work).map_err(|error| error.to_string())?;
|
|
let result = (|| {
|
|
let pages = render_pdf_to_docx_pages(input, &work, &mut on_progress)?;
|
|
on_progress(pages.len() as u32, pages.len() as u32, true);
|
|
write_image_docx(input, &pages, output)?;
|
|
let file = fs::File::open(output)
|
|
.map_err(|error| format!("The converter did not create a document: {error}"))?;
|
|
let mut archive = ZipArchive::new(file)
|
|
.map_err(|error| format!("The Word document is invalid: {error}"))?;
|
|
archive
|
|
.by_name("word/document.xml")
|
|
.map_err(|_| "The Word document has no document body.".to_string())?;
|
|
Ok(())
|
|
})();
|
|
let _ = fs::remove_dir_all(&work);
|
|
remove_on_error(output, result)
|
|
}
|
|
|
|
fn render_pdf_to_docx_pages(
|
|
input: &Path,
|
|
folder: &Path,
|
|
on_page: &mut impl FnMut(u32, u32, bool),
|
|
) -> Result<Vec<PathBuf>, String> {
|
|
let pages = to_docx_page_images(input, folder, on_page)?;
|
|
if pages.is_empty() {
|
|
return Err("No PDF pages were rendered.".into());
|
|
}
|
|
let mut stream = fs::File::open(&pages[0]).map_err(|error| error.to_string())?;
|
|
let mut signature = [0_u8; 2];
|
|
stream
|
|
.read_exact(&mut signature)
|
|
.map_err(|error| format!("The PDF renderer returned an unreadable page: {error}"))?;
|
|
if signature != [0xff, 0xd8] {
|
|
return Err("The PDF renderer did not return JPEG pages.".into());
|
|
}
|
|
Ok(pages)
|
|
}
|
|
|
|
/// Render the whole document with one renderer process. Poppler writes each
|
|
/// page as it finishes, so progress can be read from the output folder without
|
|
/// rasterising the entire document in memory. Restarting `pdftoppm` once per
|
|
/// page reparses the same image-heavy PDF dozens of times and was the reason a
|
|
/// scan-heavy PDF appeared to hang on Windows.
|
|
fn to_docx_page_images(
|
|
input: &Path,
|
|
folder: &Path,
|
|
on_page: &mut impl FnMut(u32, u32, bool),
|
|
) -> Result<Vec<PathBuf>, String> {
|
|
fs::create_dir_all(folder).map_err(|error| error.to_string())?;
|
|
let page_count = pdf_page_count(input)?;
|
|
if page_count == 0 {
|
|
return Err("No PDF pages were rendered.".into());
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
{
|
|
let pages = to_images_in(input, "jpg", folder)?;
|
|
for page in 1..=pages.len() as u32 {
|
|
on_page(page, pages.len() as u32, false);
|
|
}
|
|
Ok(pages)
|
|
}
|
|
|
|
#[cfg(not(target_os = "macos"))]
|
|
{
|
|
let pdftoppm = renderer_path().ok_or_else(|| {
|
|
"PDF page rendering needs Poppler (pdftoppm) on Windows and Linux.".to_string()
|
|
})?;
|
|
let prefix = folder.join("Page");
|
|
let mut command = crate::files::background_command(&pdftoppm);
|
|
command
|
|
.args([
|
|
"-jpeg",
|
|
"-r",
|
|
"120",
|
|
"-scale-to",
|
|
PDF_RENDER_MAX_EDGE,
|
|
input.to_string_lossy().as_ref(),
|
|
prefix.to_string_lossy().as_ref(),
|
|
])
|
|
.stdin(Stdio::null())
|
|
.stdout(Stdio::null())
|
|
.stderr(Stdio::null());
|
|
let mut child = command
|
|
.spawn()
|
|
.map_err(|error| format!("Could not start the PDF renderer: {error}"))?;
|
|
let mut reported = 0_u32;
|
|
let mut last_change = Instant::now();
|
|
// Keep trying to collect the renderer's exit status for a short while
|
|
// after killing it. On Windows a busy Poppler process can take a moment
|
|
// to disappear, and blocking forever in `wait` would freeze the worker.
|
|
let stop = |child: &mut std::process::Child| {
|
|
let _ = child.kill();
|
|
let deadline = Instant::now() + Duration::from_secs(3);
|
|
while Instant::now() < deadline {
|
|
match child.try_wait() {
|
|
Ok(Some(_)) | Err(_) => break,
|
|
Ok(None) => std::thread::sleep(Duration::from_millis(50)),
|
|
}
|
|
}
|
|
};
|
|
loop {
|
|
let rendered = rendered_jpegs(folder);
|
|
if rendered.len() as u32 > reported {
|
|
reported = rendered.len() as u32;
|
|
last_change = Instant::now();
|
|
on_page(reported.min(page_count), page_count, false);
|
|
}
|
|
match child.try_wait() {
|
|
Ok(Some(status)) if status.success() => break,
|
|
Ok(Some(status)) => {
|
|
stop(&mut child);
|
|
return Err(format!(
|
|
"PDF page rendering stopped after {reported} of {page_count} pages ({status})."
|
|
));
|
|
}
|
|
Ok(None)
|
|
if last_change.elapsed() >= Duration::from_secs(15) && rendered.is_empty() =>
|
|
{
|
|
stop(&mut child);
|
|
return Err("PDF rendering did not start within 15 seconds.".into());
|
|
}
|
|
Ok(None) if last_change.elapsed() >= PDF_RENDER_STALL_TIMEOUT => {
|
|
stop(&mut child);
|
|
return Err(format!(
|
|
"PDF rendering stopped responding after {reported} of {page_count} pages."
|
|
));
|
|
}
|
|
Ok(None) => std::thread::sleep(Duration::from_millis(100)),
|
|
Err(error) => {
|
|
stop(&mut child);
|
|
return Err(format!("Could not monitor the PDF renderer: {error}"));
|
|
}
|
|
}
|
|
}
|
|
let mut pages = rendered_jpegs(folder);
|
|
if pages.len() != page_count as usize {
|
|
return Err(format!(
|
|
"The PDF renderer returned {} of {page_count} pages.",
|
|
pages.len()
|
|
));
|
|
}
|
|
pages.sort_by_key(|path| page_number_in_name(path));
|
|
if reported < page_count {
|
|
on_page(page_count, page_count, false);
|
|
}
|
|
Ok(pages)
|
|
}
|
|
}
|
|
|
|
fn pdf_page_count(input: &Path) -> Result<u32, String> {
|
|
#[cfg(not(target_os = "macos"))]
|
|
if let Some(pdfinfo) = crate::files::resolve_tool("pdfinfo") {
|
|
if let Ok(output) = crate::process::output_with_timeout(
|
|
pdfinfo,
|
|
&[input.to_string_lossy().as_ref()],
|
|
Duration::from_secs(15),
|
|
) {
|
|
if output.status.success() {
|
|
let text = String::from_utf8_lossy(&output.stdout);
|
|
if let Some(pages) = parse_pdfinfo_pages(&text) {
|
|
return Ok(pages);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(load(input)?.get_pages().len() as u32)
|
|
}
|
|
|
|
#[cfg_attr(target_os = "macos", allow(dead_code))]
|
|
fn parse_pdfinfo_pages(output: &str) -> Option<u32> {
|
|
output.lines().find_map(|line| {
|
|
line.trim()
|
|
.strip_prefix("Pages:")
|
|
.and_then(|pages| pages.trim().parse().ok())
|
|
.filter(|pages| *pages > 0)
|
|
})
|
|
}
|
|
|
|
#[cfg(not(target_os = "macos"))]
|
|
fn rendered_jpegs(folder: &Path) -> Vec<PathBuf> {
|
|
let Ok(entries) = fs::read_dir(folder) else {
|
|
return Vec::new();
|
|
};
|
|
entries
|
|
.flatten()
|
|
.map(|entry| entry.path())
|
|
.filter(|path| {
|
|
path.extension()
|
|
.and_then(|value| value.to_str())
|
|
.is_some_and(|value| value.eq_ignore_ascii_case("jpg"))
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn write_image_docx(input: &Path, pages: &[PathBuf], output: &Path) -> Result<(), String> {
|
|
use std::io::Write as _;
|
|
use zip::{write::SimpleFileOptions, ZipWriter};
|
|
|
|
let dimensions: Vec<(u32, u32)> = pages
|
|
.iter()
|
|
.map(|path| {
|
|
let reader = image::ImageReader::open(path)
|
|
.map_err(|error| error.to_string())?
|
|
.with_guessed_format()
|
|
.map_err(|error| error.to_string())?;
|
|
let (width, height) = reader
|
|
.into_dimensions()
|
|
.or_else(|_| {
|
|
let mut file = fs::File::open(path)?;
|
|
let mut bytes = Vec::new();
|
|
file.read_to_end(&mut bytes)?;
|
|
let image = image::load_from_memory(&bytes)?;
|
|
Ok::<_, image::ImageError>(image.dimensions())
|
|
})
|
|
.map_err(|error| error.to_string())?;
|
|
Ok((width, height))
|
|
})
|
|
.collect::<Result<_, String>>()?;
|
|
let first = *dimensions
|
|
.first()
|
|
.ok_or_else(|| "No PDF pages were rendered.".to_string())?;
|
|
let short_side = 11_906.0;
|
|
let ratio = first.1 as f64 / first.0 as f64;
|
|
let (page_width, page_height) = if ratio >= 1.0 {
|
|
let width = short_side as u32;
|
|
let height = (short_side * ratio).round() as u32;
|
|
(width, height)
|
|
} else {
|
|
let height = short_side as u32;
|
|
let width = (short_side / ratio).round() as u32;
|
|
(width, height)
|
|
};
|
|
|
|
let title = input
|
|
.file_stem()
|
|
.and_then(|value| value.to_str())
|
|
.unwrap_or("PDF");
|
|
let mut document = String::with_capacity(pages.len() * 2600);
|
|
document.push_str(
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
|
|
<w:document xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" \
|
|
xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" \
|
|
xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" \
|
|
xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" \
|
|
xmlns:pic=\"http://schemas.openxmlformats.org/drawingml/2006/picture\"><w:body>",
|
|
);
|
|
let orientation = if page_width > page_height {
|
|
"landscape"
|
|
} else {
|
|
"portrait"
|
|
};
|
|
let section = format!(
|
|
"<w:sectPr><w:type w:val=\"nextPage\"/>\
|
|
<w:pgSz w:w=\"{page_width}\" w:h=\"{page_height}\" w:orient=\"{orientation}\"/>\
|
|
<w:pgMar w:top=\"0\" w:right=\"0\" w:bottom=\"0\" w:left=\"0\" \
|
|
w:header=\"0\" w:footer=\"0\" w:gutter=\"0\"/>\
|
|
<w:cols w:space=\"0\"/></w:sectPr>"
|
|
);
|
|
for (index, (width, height)) in dimensions.into_iter().enumerate() {
|
|
// Leave a fraction of a point for Word's inline-image baseline so a
|
|
// full-page image cannot spill into and collapse the next section.
|
|
let usable_height = page_height.saturating_sub(4);
|
|
let scale = (page_width as f64 / width as f64).min(usable_height as f64 / height as f64);
|
|
let image_width = (width as f64 * scale).floor().max(1.0) as u64;
|
|
let image_height = (height as f64 * scale).floor().max(1.0) as u64;
|
|
let extent_x = image_width * 635;
|
|
let extent_y = image_height * 635;
|
|
let relationship = index + 1;
|
|
let page_number = index + 1;
|
|
let page_section = if page_number < pages.len() {
|
|
section.as_str()
|
|
} else {
|
|
""
|
|
};
|
|
document.push_str(&format!(
|
|
"<w:p><w:pPr><w:spacing w:before=\"0\" w:after=\"0\" w:line=\"240\" \
|
|
w:lineRule=\"auto\"/>{page_section}</w:pPr><w:r><w:drawing>\
|
|
<wp:inline distT=\"0\" distB=\"0\" distL=\"0\" distR=\"0\">\
|
|
<wp:extent cx=\"{extent_x}\" cy=\"{extent_y}\"/>\
|
|
<wp:effectExtent l=\"0\" t=\"0\" r=\"0\" b=\"0\"/>\
|
|
<wp:docPr id=\"{page_number}\" name=\"Page {page_number}\" \
|
|
descr=\"PDF page {page_number}\"/>\
|
|
<wp:cNvGraphicFramePr><a:graphicFrameLocks noChangeAspect=\"1\"/>\
|
|
</wp:cNvGraphicFramePr><a:graphic>\
|
|
<a:graphicData uri=\"http://schemas.openxmlformats.org/drawingml/2006/picture\">\
|
|
<pic:pic><pic:nvPicPr><pic:cNvPr id=\"{page_number}\" name=\"Page {page_number}\"/>\
|
|
<pic:cNvPicPr/></pic:nvPicPr><pic:blipFill>\
|
|
<a:blip r:embed=\"rId{relationship}\"/><a:stretch><a:fillRect/></a:stretch>\
|
|
</pic:blipFill><pic:spPr><a:xfrm><a:off x=\"0\" y=\"0\"/>\
|
|
<a:ext cx=\"{extent_x}\" cy=\"{extent_y}\"/></a:xfrm>\
|
|
<a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom></pic:spPr></pic:pic>\
|
|
</a:graphicData></a:graphic></wp:inline></w:drawing></w:r></w:p>"
|
|
));
|
|
}
|
|
document.push_str(&format!(
|
|
"<w:sectPr><w:pgSz w:w=\"{page_width}\" w:h=\"{page_height}\" w:orient=\"{}\"/>\
|
|
<w:pgMar w:top=\"0\" w:right=\"0\" w:bottom=\"0\" w:left=\"0\" \
|
|
w:header=\"0\" w:footer=\"0\" w:gutter=\"0\"/></w:sectPr></w:body></w:document>",
|
|
orientation
|
|
));
|
|
|
|
let mut relationships = String::from(
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
|
|
<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">",
|
|
);
|
|
for index in 0..pages.len() {
|
|
relationships.push_str(&format!(
|
|
"<Relationship Id=\"rId{}\" \
|
|
Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/image\" \
|
|
Target=\"media/page-{:03}.jpg\"/>",
|
|
index + 1,
|
|
index + 1
|
|
));
|
|
}
|
|
relationships.push_str("</Relationships>");
|
|
|
|
let content_types = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
|
|
<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">\
|
|
<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>\
|
|
<Default Extension=\"xml\" ContentType=\"application/xml\"/>\
|
|
<Default Extension=\"jpg\" ContentType=\"image/jpeg\"/>\
|
|
<Override PartName=\"/word/document.xml\" \
|
|
ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml\"/>\
|
|
<Override PartName=\"/docProps/core.xml\" \
|
|
ContentType=\"application/vnd.openxmlformats-package.core-properties+xml\"/>\
|
|
<Override PartName=\"/docProps/app.xml\" \
|
|
ContentType=\"application/vnd.openxmlformats-officedocument.extended-properties+xml\"/>\
|
|
</Types>";
|
|
let root_relationships = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
|
|
<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\
|
|
<Relationship Id=\"rId1\" \
|
|
Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument\" \
|
|
Target=\"word/document.xml\"/>\
|
|
<Relationship Id=\"rId2\" \
|
|
Type=\"http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties\" \
|
|
Target=\"docProps/core.xml\"/>\
|
|
<Relationship Id=\"rId3\" \
|
|
Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties\" \
|
|
Target=\"docProps/app.xml\"/></Relationships>";
|
|
let escaped_title = xml_escape(title);
|
|
let core = format!(
|
|
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
|
|
<cp:coreProperties xmlns:cp=\"http://schemas.openxmlformats.org/package/2006/metadata/core-properties\" \
|
|
xmlns:dc=\"http://purl.org/dc/elements/1.1/\" \
|
|
xmlns:dcterms=\"http://purl.org/dc/terms/\" \
|
|
xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\
|
|
<dc:title>{escaped_title}</dc:title><dc:creator>Shift</dc:creator>\
|
|
<cp:lastModifiedBy>Shift</cp:lastModifiedBy></cp:coreProperties>"
|
|
);
|
|
let app = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
|
|
<Properties xmlns=\"http://schemas.openxmlformats.org/officeDocument/2006/extended-properties\">\
|
|
<Application>Shift</Application></Properties>";
|
|
|
|
let file = fs::File::create(output).map_err(|error| error.to_string())?;
|
|
let mut zip = ZipWriter::new(file);
|
|
let options = SimpleFileOptions::default();
|
|
for (name, value) in [
|
|
("[Content_Types].xml", content_types.as_bytes()),
|
|
("_rels/.rels", root_relationships.as_bytes()),
|
|
("word/document.xml", document.as_bytes()),
|
|
("word/_rels/document.xml.rels", relationships.as_bytes()),
|
|
("docProps/core.xml", core.as_bytes()),
|
|
("docProps/app.xml", app.as_bytes()),
|
|
] {
|
|
zip.start_file(name, options)
|
|
.map_err(|error| error.to_string())?;
|
|
zip.write_all(value).map_err(|error| error.to_string())?;
|
|
}
|
|
for (index, path) in pages.iter().enumerate() {
|
|
zip.start_file(format!("word/media/page-{:03}.jpg", index + 1), options)
|
|
.map_err(|error| error.to_string())?;
|
|
// Copy each rendered page straight into the ZIP. Reading every page
|
|
// into a Vec first doubles memory use on scans and can stall Windows.
|
|
let mut page = fs::File::open(path).map_err(|error| error.to_string())?;
|
|
std::io::copy(&mut page, &mut zip).map_err(|error| error.to_string())?;
|
|
}
|
|
zip.finish().map_err(|error| error.to_string())?;
|
|
Ok(())
|
|
}
|
|
|
|
fn xml_escape(value: &str) -> String {
|
|
value
|
|
.replace('&', "&")
|
|
.replace('<', "<")
|
|
.replace('>', ">")
|
|
.replace('"', """)
|
|
.replace('\'', "'")
|
|
}
|
|
|
|
pub fn extract_text_to(
|
|
input: &Path,
|
|
extension: &str,
|
|
output_dir: Option<&Path>,
|
|
) -> Result<PathBuf, String> {
|
|
let text = text_of(input)?;
|
|
let output = unique_output_in(input, output_dir, " (text)", extension)?;
|
|
fs::write(&output, text).map_err(|error| error.to_string())?;
|
|
Ok(output)
|
|
}
|
|
|
|
pub fn extract_text(input: &Path, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
extract_text_to(input, "txt", output_dir)
|
|
}
|
|
|
|
pub fn strip_metadata(input: &Path, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let mut document = load(input)?;
|
|
document.trailer.remove(b"Info");
|
|
if let Ok(catalog) = document.catalog_mut() {
|
|
catalog.remove(b"Metadata");
|
|
}
|
|
let output = unique_output_in(input, output_dir, " (clean)", "pdf")?;
|
|
document
|
|
.save(&output)
|
|
.map_err(|error| format!("Could not save cleaned PDF: {error}"))?;
|
|
Ok(output)
|
|
}
|
|
|
|
/// Longest side kept for embedded images, and the JPEG quality used when
|
|
/// rewriting them. Scanned pages are routinely stored at 2500-3500 px, which is
|
|
/// wasted on screen reading; pruning objects alone barely moves those files.
|
|
const IMAGE_MAX_SIDE: u32 = 1440;
|
|
const IMAGE_JPEG_QUALITY: u8 = 60;
|
|
|
|
pub fn compress(input: &Path, output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
let mut document = load(input)?;
|
|
let resampled = resample_images(&mut document);
|
|
document.compress();
|
|
document.prune_objects();
|
|
document.renumber_objects();
|
|
let output = unique_output_in(input, output_dir, " (compressed)", "pdf")?;
|
|
document
|
|
.save(&output)
|
|
.map_err(|error| format!("Could not save compressed PDF: {error}"))?;
|
|
let input_size = fs::metadata(input)
|
|
.map_err(|error| error.to_string())?
|
|
.len();
|
|
let output_size = fs::metadata(&output)
|
|
.map_err(|error| error.to_string())?
|
|
.len();
|
|
if output_size >= input_size {
|
|
let _ = fs::remove_file(&output);
|
|
if resampled == 0 {
|
|
return Err("This PDF is already optimized.".into());
|
|
}
|
|
return Err(format!(
|
|
"Re-encoding {} embedded image(s) did not make this PDF smaller.",
|
|
resampled
|
|
));
|
|
}
|
|
Ok(output)
|
|
}
|
|
|
|
/// Rewrites embedded raster images as smaller JPEGs, the way a "optimize images
|
|
/// for screen" export does. Anything the pipeline cannot prove it can round-trip
|
|
/// — masks, soft masks, indexed or CMYK colour, sub-8-bit samples, or codecs we
|
|
/// do not decode — is left byte-for-byte untouched, so a failed heuristic can
|
|
/// only miss a saving, never corrupt a page.
|
|
fn resample_images(document: &mut Document) -> usize {
|
|
let ids: Vec<ObjectId> = document
|
|
.objects
|
|
.iter()
|
|
.filter(|(_, object)| matches!(object, Object::Stream(_)))
|
|
.map(|(id, _)| *id)
|
|
.collect();
|
|
let mut rewritten = 0;
|
|
for id in ids {
|
|
if rewrite_image(document, id) {
|
|
rewritten += 1;
|
|
}
|
|
}
|
|
rewritten
|
|
}
|
|
|
|
fn rewrite_image(document: &mut Document, id: ObjectId) -> bool {
|
|
let Some((image, is_gray)) = decode_image(document, id) else {
|
|
return false;
|
|
};
|
|
if image.width().max(image.height()) <= IMAGE_MAX_SIDE {
|
|
// Small enough already; rewriting could only lose quality.
|
|
return false;
|
|
}
|
|
let scaled = image.resize(
|
|
IMAGE_MAX_SIDE,
|
|
IMAGE_MAX_SIDE,
|
|
image::imageops::FilterType::Lanczos3,
|
|
);
|
|
let width = scaled.width();
|
|
let height = scaled.height();
|
|
// Encode explicitly so the declared quality is the quality that is written.
|
|
let mut encoded = Vec::new();
|
|
let encoded_ok = if is_gray {
|
|
image::codecs::jpeg::JpegEncoder::new_with_quality(&mut encoded, IMAGE_JPEG_QUALITY)
|
|
.encode_image(&image::DynamicImage::ImageLuma8(scaled.to_luma8()))
|
|
} else {
|
|
image::codecs::jpeg::JpegEncoder::new_with_quality(&mut encoded, IMAGE_JPEG_QUALITY)
|
|
.encode_image(&image::DynamicImage::ImageRgb8(scaled.to_rgb8()))
|
|
};
|
|
if encoded_ok.is_err() || encoded.is_empty() {
|
|
return false;
|
|
}
|
|
let original_len = match document.get_object(id) {
|
|
Ok(Object::Stream(stream)) => stream.content.len(),
|
|
_ => return false,
|
|
};
|
|
// Never trade a smaller pixel budget for a bigger file.
|
|
if encoded.len() >= original_len {
|
|
return false;
|
|
}
|
|
|
|
let Ok(Object::Stream(stream)) = document.get_object_mut(id) else {
|
|
return false;
|
|
};
|
|
stream.set_content(encoded);
|
|
let dict = &mut stream.dict;
|
|
dict.set("Filter", "DCTDecode");
|
|
dict.remove(b"DecodeParms");
|
|
dict.remove(b"Decode");
|
|
dict.set("Width", width as i64);
|
|
dict.set("Height", height as i64);
|
|
dict.set("BitsPerComponent", 8_i64);
|
|
// The JPEG is written with the same component count as the source, so the
|
|
// declared colour space still matches the decoded samples.
|
|
dict.set(
|
|
"ColorSpace",
|
|
if is_gray { "DeviceGray" } else { "DeviceRGB" },
|
|
);
|
|
true
|
|
}
|
|
|
|
/// Decodes an embedded image, or `None` when it is unsafe to rewrite.
|
|
fn decode_image(document: &Document, id: ObjectId) -> Option<(image::DynamicImage, bool)> {
|
|
let Object::Stream(stream) = document.get_object(id).ok()? else {
|
|
return None;
|
|
};
|
|
if !is_name(stream.dict.get(b"Subtype"), b"Image") {
|
|
return None;
|
|
}
|
|
// Masks carry alignment and colour-key semantics we would destroy.
|
|
for key in [
|
|
b"SMask".as_slice(),
|
|
b"Mask".as_slice(),
|
|
b"Alternates".as_slice(),
|
|
] {
|
|
if stream.dict.get(key).is_ok() {
|
|
return None;
|
|
}
|
|
}
|
|
if matches!(stream.dict.get(b"ImageMask"), Ok(mask) if matches!(mask.as_bool(), Ok(true))) {
|
|
return None;
|
|
}
|
|
if !matches!(stream.dict.get(b"BitsPerComponent"), Ok(bits) if matches!(bits.as_i64(), Ok(8))) {
|
|
return None;
|
|
}
|
|
let space = resolve_name(document, stream.dict.get(b"ColorSpace").ok()?.clone())?;
|
|
let is_gray = space == b"DeviceGray";
|
|
if !is_gray && space != b"DeviceRGB" {
|
|
return None;
|
|
}
|
|
let width = stream.dict.get(b"Width").ok()?.as_i64().ok()? as u32;
|
|
let height = stream.dict.get(b"Height").ok()?.as_i64().ok()? as u32;
|
|
if width == 0 || height == 0 || width > 20_000 || height > 20_000 {
|
|
return None;
|
|
}
|
|
|
|
match stream.filters().unwrap_or_default().as_slice() {
|
|
// Already a JPEG: decode, shrink, re-encode.
|
|
[b"DCTDecode"] => image::load_from_memory(&stream.content)
|
|
.ok()
|
|
.map(|image| (image, is_gray)),
|
|
// Raw or deflate-packed samples: rebuild from the pixel array.
|
|
[] | [b"FlateDecode"] => {
|
|
let bytes_per_pixel = if is_gray { 1 } else { 3 };
|
|
let decoded = stream.get_plain_content().ok()?;
|
|
if decoded.len() != (width as usize) * (height as usize) * bytes_per_pixel {
|
|
return None;
|
|
}
|
|
let image = if is_gray {
|
|
image::GrayImage::from_raw(width, height, decoded)
|
|
.map(image::DynamicImage::ImageLuma8)
|
|
} else {
|
|
image::RgbImage::from_raw(width, height, decoded)
|
|
.map(image::DynamicImage::ImageRgb8)
|
|
}?;
|
|
Some((image, is_gray))
|
|
}
|
|
// JPX, JBIG2, CCITT and chains we cannot verify: leave untouched.
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn is_name(result: lopdf::Result<&Object>, expected: &[u8]) -> bool {
|
|
matches!(result.and_then(Object::as_name), Ok(name) if name == expected)
|
|
}
|
|
|
|
/// Resolves a name that may be an indirect reference, for /ColorSpace lookups.
|
|
fn resolve_name(document: &Document, object: Object) -> Option<Vec<u8>> {
|
|
let resolved = match object {
|
|
Object::Name(name) => name.to_vec(),
|
|
Object::Reference(reference) => match document.get_object(reference).ok()? {
|
|
Object::Name(name) => name.to_vec(),
|
|
_ => return None,
|
|
},
|
|
_ => return None,
|
|
};
|
|
Some(resolved)
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
pub(crate) fn pdf_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!("pdf-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("pdf-render");
|
|
if sidecar.exists() {
|
|
return Some(sidecar);
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
/// The executable that provides PDF page rendering for the current platform.
|
|
pub(crate) fn renderer_path() -> Option<PathBuf> {
|
|
#[cfg(target_os = "macos")]
|
|
{
|
|
pdf_render_bridge()
|
|
}
|
|
#[cfg(not(target_os = "macos"))]
|
|
{
|
|
crate::files::resolve_tool("pdftoppm")
|
|
}
|
|
}
|
|
|
|
pub fn to_images(
|
|
input: &Path,
|
|
extension: &str,
|
|
output_dir: Option<&Path>,
|
|
) -> Result<Vec<PathBuf>, String> {
|
|
let parent = output_dir.map(PathBuf::from).unwrap_or_else(|| {
|
|
input
|
|
.parent()
|
|
.unwrap_or_else(|| Path::new("."))
|
|
.to_path_buf()
|
|
});
|
|
let stem = input
|
|
.file_stem()
|
|
.and_then(|value| value.to_str())
|
|
.unwrap_or("PDF");
|
|
let mut folder = parent.join(format!("{stem} pages"));
|
|
let mut counter = 2;
|
|
while folder.exists() {
|
|
folder = parent.join(format!("{stem} pages {counter}"));
|
|
counter += 1;
|
|
}
|
|
to_images_in(input, extension, &folder)
|
|
}
|
|
|
|
pub fn to_images_in(input: &Path, extension: &str, folder: &Path) -> Result<Vec<PathBuf>, String> {
|
|
let requested = extension.to_ascii_lowercase();
|
|
// HEIC has no page renderer of its own: pages render as PNG and are then
|
|
// re-encoded by the system codec, the same path image conversion uses.
|
|
let (extension, transcode_to) = match requested.as_str() {
|
|
"jpg" | "jpeg" => ("jpg", None),
|
|
"png" => ("png", None),
|
|
"tif" | "tiff" => ("tif", None),
|
|
"heic" | "heif" => (
|
|
"png",
|
|
Some(if requested == "heif" { "heif" } else { "heic" }),
|
|
),
|
|
other => return Err(format!("Unsupported PDF image format: {other}")),
|
|
};
|
|
fs::create_dir_all(folder).map_err(|error| error.to_string())?;
|
|
|
|
#[cfg(target_os = "macos")]
|
|
{
|
|
let bridge = renderer_path().ok_or_else(|| {
|
|
"The PDF renderer is missing. Run pnpm mac:drag-bridge and rebuild.".to_string()
|
|
})?;
|
|
let status = crate::files::background_command(&bridge)
|
|
.args([
|
|
input.to_string_lossy().as_ref(),
|
|
folder.to_string_lossy().as_ref(),
|
|
extension,
|
|
])
|
|
.status()
|
|
.map_err(|error| format!("Could not start PDF renderer: {error}"))?;
|
|
if !status.success() {
|
|
return Err("PDF page rendering failed.".into());
|
|
}
|
|
}
|
|
|
|
#[cfg(not(target_os = "macos"))]
|
|
{
|
|
let pdftoppm = renderer_path().ok_or_else(|| {
|
|
"PDF page rendering needs Poppler (pdftoppm) on Windows and Linux.".to_string()
|
|
})?;
|
|
let flag = match extension {
|
|
"jpg" => "-jpeg",
|
|
"tif" => "-tiff",
|
|
_ => "-png",
|
|
};
|
|
let prefix = folder.join("Page");
|
|
let status = crate::process::status_with_timeout(
|
|
pdftoppm,
|
|
&[
|
|
flag,
|
|
"-r",
|
|
"144",
|
|
"-scale-to",
|
|
PDF_RENDER_MAX_EDGE,
|
|
input.to_string_lossy().as_ref(),
|
|
prefix.to_string_lossy().as_ref(),
|
|
],
|
|
const { std::time::Duration::from_secs(60 * 8) },
|
|
)?;
|
|
if !status.success() {
|
|
return Err("PDF page rendering failed.".into());
|
|
}
|
|
let mut images: Vec<PathBuf> = fs::read_dir(folder)
|
|
.map_err(|error| error.to_string())?
|
|
.filter_map(Result::ok)
|
|
.map(|entry| entry.path())
|
|
.filter(|path| {
|
|
path.extension()
|
|
.and_then(|value| value.to_str())
|
|
.map(|value| value.eq_ignore_ascii_case(extension))
|
|
.unwrap_or(false)
|
|
})
|
|
.collect();
|
|
images.sort_by_key(|path| page_number_in_name(path));
|
|
for (index, path) in images.iter().enumerate() {
|
|
let target = folder.join(format!("Page {:03}.{extension}", index + 1));
|
|
if path != &target {
|
|
fs::rename(path, &target).map_err(|error| error.to_string())?;
|
|
}
|
|
}
|
|
}
|
|
|
|
let mut images: Vec<PathBuf> = fs::read_dir(folder)
|
|
.map_err(|error| error.to_string())?
|
|
.filter_map(Result::ok)
|
|
.map(|entry| entry.path())
|
|
.filter(|path| {
|
|
path.extension()
|
|
.and_then(|value| value.to_str())
|
|
.map(|value| value.eq_ignore_ascii_case(extension))
|
|
.unwrap_or(false)
|
|
})
|
|
.collect();
|
|
images.sort_by_key(|path| page_number_in_name(path));
|
|
if images.is_empty() {
|
|
return Err("No PDF pages were rendered.".into());
|
|
}
|
|
if let Some(target) = transcode_to {
|
|
let mut converted = Vec::with_capacity(images.len());
|
|
for page in &images {
|
|
let desired = page.with_extension(target);
|
|
crate::files::system_convert(page, &desired, target)?;
|
|
let _ = fs::remove_file(page);
|
|
converted.push(desired);
|
|
}
|
|
return Ok(converted);
|
|
}
|
|
Ok(images)
|
|
}
|
|
|
|
fn page_number_in_name(path: &Path) -> u32 {
|
|
path.file_stem()
|
|
.and_then(|value| value.to_str())
|
|
.and_then(|value| {
|
|
value
|
|
.rsplit(|character: char| !character.is_ascii_digit())
|
|
.next()
|
|
})
|
|
.and_then(|digits| digits.parse().ok())
|
|
.unwrap_or(u32::MAX)
|
|
}
|
|
|
|
pub fn images_to_pdf(paths: &[PathBuf], output_dir: Option<&Path>) -> Result<PathBuf, String> {
|
|
images_to_pdf_with_progress(paths, output_dir, |_, _| {})
|
|
}
|
|
|
|
fn image_for_pdf(path: &Path) -> Result<RawImage, String> {
|
|
let bytes = fs::read(path).map_err(|error| error.to_string())?;
|
|
match RawImage::decode_from_bytes(&bytes, &mut Vec::new()) {
|
|
Ok(image) => Ok(image),
|
|
Err(decode_error) => {
|
|
let converted =
|
|
std::env::temp_dir().join(format!("shift-pdf-image-{}.png", uuid::Uuid::new_v4()));
|
|
if let Err(convert_error) = crate::files::system_convert(path, &converted, "png") {
|
|
return Err(format!(
|
|
"Could not decode {} ({decode_error}). {convert_error}",
|
|
path.display()
|
|
));
|
|
}
|
|
let result = fs::read(&converted)
|
|
.map_err(|error| error.to_string())
|
|
.and_then(|bytes| {
|
|
RawImage::decode_from_bytes(&bytes, &mut Vec::new())
|
|
.map_err(|error| format!("Could not decode {}: {error}", path.display()))
|
|
});
|
|
let _ = fs::remove_file(converted);
|
|
result
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Builds a PDF page by page so every document path that already has page
|
|
/// images can report the same progress event as PDF-to-Word.
|
|
pub fn images_to_pdf_with_progress(
|
|
paths: &[PathBuf],
|
|
output_dir: Option<&Path>,
|
|
mut on_page: impl FnMut(u32, u32),
|
|
) -> Result<PathBuf, String> {
|
|
if paths.is_empty() {
|
|
return Err("Select at least one image.".into());
|
|
}
|
|
let mut document = PdfDocument::new("Shift images");
|
|
let mut pages = Vec::new();
|
|
let total = paths.len() as u32;
|
|
for (index, path) in paths.iter().enumerate() {
|
|
let image = image_for_pdf(path)?;
|
|
let width_mm = image.width as f32 * 25.4 / 300.0;
|
|
let height_mm = image.height as f32 * 25.4 / 300.0;
|
|
let image_id = document.add_image(&image);
|
|
pages.push(PdfPage::new(
|
|
Mm(width_mm.max(1.0)),
|
|
Mm(height_mm.max(1.0)),
|
|
vec![Op::UseXobject {
|
|
id: image_id,
|
|
transform: XObjectTransform::default(),
|
|
}],
|
|
));
|
|
on_page(index as u32 + 1, total);
|
|
}
|
|
document.with_pages(pages);
|
|
let output = unique_output_in(&paths[0], output_dir, " (images)", "pdf")?;
|
|
let mut warnings = Vec::new();
|
|
let bytes = document.save(&printpdf::PdfSaveOptions::default(), &mut warnings);
|
|
fs::write(&output, bytes).map_err(|error| error.to_string())?;
|
|
Ok(output)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use lopdf::dictionary;
|
|
|
|
fn make_pdf(path: &Path, pages: usize) {
|
|
let mut document = Document::with_version("1.5");
|
|
let pages_id = document.new_object_id();
|
|
let font_id = document.add_object(dictionary! {
|
|
"Type" => "Font",
|
|
"Subtype" => "Type1",
|
|
"BaseFont" => "Helvetica",
|
|
});
|
|
let mut kids = Vec::new();
|
|
for index in 0..pages {
|
|
let content = format!("BT /F1 18 Tf 72 720 Td (Page {}) Tj ET", index + 1);
|
|
let content_id =
|
|
document.add_object(lopdf::Stream::new(dictionary! {}, content.into_bytes()));
|
|
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 },
|
|
},
|
|
});
|
|
kids.push(Object::Reference(page_id));
|
|
}
|
|
document.objects.insert(
|
|
pages_id,
|
|
Object::Dictionary(dictionary! {
|
|
"Type" => "Pages",
|
|
"Kids" => kids,
|
|
"Count" => pages as i64,
|
|
}),
|
|
);
|
|
let catalog_id = document.add_object(dictionary! {
|
|
"Type" => "Catalog",
|
|
"Pages" => pages_id,
|
|
});
|
|
document.trailer.set("Root", catalog_id);
|
|
document.save(path).unwrap();
|
|
}
|
|
|
|
/// A PDF embedding an uncompressed RGB image on each page.
|
|
fn make_pdf_with_image(path: &Path, width: u32, height: u32, pages: usize) {
|
|
let mut document = Document::new();
|
|
let pixels: Vec<u8> = (0..width * height)
|
|
.flat_map(|index| {
|
|
let value = ((index % 251) as u8).wrapping_mul(3);
|
|
[value, value / 2, 255 - value]
|
|
})
|
|
.collect();
|
|
let image_id = document.add_object(lopdf::Stream::new(
|
|
dictionary! {
|
|
"Type" => "XObject",
|
|
"Subtype" => "Image",
|
|
"Width" => width as i64,
|
|
"Height" => height as i64,
|
|
"ColorSpace" => "DeviceRGB",
|
|
"BitsPerComponent" => 8_i64,
|
|
},
|
|
pixels,
|
|
));
|
|
let pages_id = document.new_object_id();
|
|
let mut kids = Vec::new();
|
|
for _ in 0..pages {
|
|
let content = "q 612 0 0 792 0 0 cm /Im0 Do Q".to_string();
|
|
let content_id =
|
|
document.add_object(lopdf::Stream::new(dictionary! {}, content.into_bytes()));
|
|
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! {
|
|
"XObject" => dictionary! { "Im0" => image_id },
|
|
},
|
|
});
|
|
kids.push(Object::Reference(page_id));
|
|
}
|
|
document.objects.insert(
|
|
pages_id,
|
|
Object::Dictionary(dictionary! {
|
|
"Type" => "Pages",
|
|
"Kids" => kids,
|
|
"Count" => pages as i64,
|
|
}),
|
|
);
|
|
let catalog_id = document.add_object(dictionary! {
|
|
"Type" => "Catalog",
|
|
"Pages" => pages_id,
|
|
});
|
|
document.trailer.set("Root", catalog_id);
|
|
document.save(path).unwrap();
|
|
}
|
|
|
|
fn embedded_image(path: &Path) -> (i64, i64, Option<String>) {
|
|
let document = load(path).unwrap();
|
|
for object in document.objects.values() {
|
|
if let Object::Stream(stream) = object {
|
|
if is_name(stream.dict.get(b"Subtype"), b"Image") {
|
|
let filter = stream
|
|
.dict
|
|
.get(b"Filter")
|
|
.ok()
|
|
.and_then(|value| value.as_name().ok())
|
|
.map(|name| String::from_utf8_lossy(name).to_string());
|
|
return (
|
|
stream.dict.get(b"Width").unwrap().as_i64().unwrap(),
|
|
stream.dict.get(b"Height").unwrap().as_i64().unwrap(),
|
|
filter,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
panic!("no embedded image found");
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
#[test]
|
|
fn renders_pdf_pages_to_heic() {
|
|
if pdf_render_bridge().is_none() {
|
|
return;
|
|
}
|
|
let directory = std::env::temp_dir().join(format!("shift-heic-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&directory).unwrap();
|
|
let input = directory.join("doc.pdf");
|
|
make_pdf(&input, 2);
|
|
match to_images(&input, "heic", None) {
|
|
Ok(pages) => {
|
|
assert_eq!(pages.len(), 2);
|
|
for page in &pages {
|
|
assert_eq!(page.extension().and_then(|v| v.to_str()), Some("heic"));
|
|
let bytes = fs::read(page).unwrap();
|
|
// ISO BMFF: four-byte length, then "ftyp" and an HEIC brand.
|
|
let brand = String::from_utf8_lossy(&bytes[4..12]).to_string();
|
|
assert!(brand.starts_with("ftyp"), "not a BMFF container: {brand}");
|
|
let heic_brand = String::from_utf8_lossy(&bytes[8..12]).to_string();
|
|
assert!(
|
|
matches!(
|
|
heic_brand.as_str(),
|
|
"heic" | "heix" | "heim" | "heis" | "mif1" | "msf1"
|
|
),
|
|
"unexpected HEIC brand: {heic_brand}"
|
|
);
|
|
assert_ne!(&bytes[0..4], b"\x89PNG", "output must not be a renamed PNG");
|
|
}
|
|
}
|
|
// A Mac without HEIC support must fail with a message, not silently.
|
|
Err(error) => assert!(error.contains("HEIC") || error.contains("heic"), "{error}"),
|
|
}
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn compress_resamples_large_embedded_images() {
|
|
let directory =
|
|
std::env::temp_dir().join(format!("shift-pdf-img-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&directory).unwrap();
|
|
let input = directory.join("scan.pdf");
|
|
// 1800 px raw RGB is ~9.7 MB, far above the 1440 px cap.
|
|
make_pdf_with_image(&input, 1800, 1800, 1);
|
|
assert_eq!(embedded_image(&input), (1800, 1800, None));
|
|
|
|
let output = compress(&input, None).unwrap();
|
|
let (width, height, filter) = embedded_image(&output);
|
|
assert_eq!(
|
|
filter.as_deref(),
|
|
Some("DCTDecode"),
|
|
"rewritten image must be JPEG"
|
|
);
|
|
assert_eq!(width, i64::from(IMAGE_MAX_SIDE));
|
|
assert_eq!(height, i64::from(IMAGE_MAX_SIDE));
|
|
assert!(
|
|
fs::metadata(&output).unwrap().len() < fs::metadata(&input).unwrap().len() / 4,
|
|
"a raw 9.7 MB embedded image must shrink dramatically"
|
|
);
|
|
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn compress_leaves_small_images_untouched() {
|
|
let directory =
|
|
std::env::temp_dir().join(format!("shift-pdf-small-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&directory).unwrap();
|
|
let input = directory.join("small.pdf");
|
|
make_pdf_with_image(&input, 64, 48, 1);
|
|
|
|
// Below the cap: compress may still shrink the file structurally, but it
|
|
// must not resample or re-encode an image that is already small.
|
|
let output =
|
|
compress(&input, None).expect("structural compression should shrink raw pixels");
|
|
let (width, height, filter) = embedded_image(&output);
|
|
assert_eq!(
|
|
(width, height),
|
|
(64, 48),
|
|
"small images must keep their dimensions"
|
|
);
|
|
assert_ne!(
|
|
filter.as_deref(),
|
|
Some("DCTDecode"),
|
|
"a small image must not be re-encoded as JPEG"
|
|
);
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn merges_splits_rotates_and_extracts_text() {
|
|
let directory = std::env::temp_dir().join(format!("shift-pdf-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&directory).unwrap();
|
|
let first = directory.join("first.pdf");
|
|
let second = directory.join("second.pdf");
|
|
make_pdf(&first, 2);
|
|
make_pdf(&second, 1);
|
|
|
|
let merged = merge(&[first.clone(), second.clone()], None).unwrap();
|
|
assert_eq!(load(&merged).unwrap().get_pages().len(), 3);
|
|
let text = extract_text(&first, None).unwrap();
|
|
assert!(fs::read_to_string(text).unwrap().contains("Page 1"));
|
|
let rotated = rotate(&first, 90, None).unwrap();
|
|
assert!(rotated.exists());
|
|
let split = split(&first, None).unwrap();
|
|
assert_eq!(split.len(), 2);
|
|
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn combines_images_into_pdf() {
|
|
let directory = std::env::temp_dir().join(format!("shift-images-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&directory).unwrap();
|
|
let image_path = directory.join("image.png");
|
|
image::RgbaImage::from_pixel(64, 48, image::Rgba([240, 90, 36, 255]))
|
|
.save_with_format(&image_path, image::ImageFormat::Png)
|
|
.unwrap();
|
|
let output = images_to_pdf(&[image_path], None).unwrap();
|
|
assert_eq!(load(&output).unwrap().get_pages().len(), 1);
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn pdf_outputs_can_use_a_custom_folder() {
|
|
let directory =
|
|
std::env::temp_dir().join(format!("shift-pdf-out-{}", uuid::Uuid::new_v4()));
|
|
let output_dir = directory.join("Shift");
|
|
fs::create_dir_all(&directory).unwrap();
|
|
let input = directory.join("input.pdf");
|
|
make_pdf(&input, 2);
|
|
|
|
let rotated = rotate(&input, 90, Some(&output_dir)).unwrap();
|
|
assert_eq!(rotated.parent(), Some(output_dir.as_path()));
|
|
let split = split(&input, Some(&output_dir)).unwrap();
|
|
assert_eq!(split.len(), 2);
|
|
assert!(split
|
|
.iter()
|
|
.all(|page| page.ancestors().any(|path| path == output_dir.as_path())));
|
|
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
#[test]
|
|
fn renders_pdf_pages_with_native_helper() {
|
|
if pdf_render_bridge().is_none() {
|
|
return;
|
|
}
|
|
let directory = std::env::temp_dir().join(format!("shift-render-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&directory).unwrap();
|
|
let input = directory.join("render.pdf");
|
|
make_pdf(&input, 2);
|
|
let pages = to_images(&input, "jpg", None).unwrap();
|
|
assert_eq!(pages.len(), 2);
|
|
assert!(pages.iter().all(|page| page.exists()));
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
#[test]
|
|
fn converts_heic_images_to_pdf() {
|
|
let directory =
|
|
std::env::temp_dir().join(format!("shift-heic-pdf-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&directory).unwrap();
|
|
let png = directory.join("source.png");
|
|
let image = image::RgbImage::from_pixel(32, 24, image::Rgb([30, 120, 210]));
|
|
image.save(&png).unwrap();
|
|
let heic = directory.join("source.heic");
|
|
if crate::files::system_convert(&png, &heic, "heic").is_err() {
|
|
fs::remove_dir_all(directory).unwrap();
|
|
return;
|
|
}
|
|
|
|
let output = images_to_pdf(&[heic], None).unwrap();
|
|
assert!(fs::read(&output).unwrap().starts_with(b"%PDF"));
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn converts_pdf_to_docx_with_rendered_page_images() {
|
|
use std::{fs::File, io::Read as _};
|
|
|
|
if renderer_path().is_none() {
|
|
return;
|
|
}
|
|
let directory = std::env::temp_dir().join(format!("shift-docx-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&directory).unwrap();
|
|
let input = directory.join("report.pdf");
|
|
let output = directory.join("report.docx");
|
|
make_pdf(&input, 2);
|
|
let mut progress = Vec::new();
|
|
to_docx_with_progress(&input, &output, |done, total, packaging| {
|
|
progress.push((done, total, packaging))
|
|
})
|
|
.unwrap();
|
|
assert_eq!(progress, vec![(1, 2, false), (2, 2, false), (2, 2, true)]);
|
|
let mut archive = ZipArchive::new(File::open(&output).unwrap()).unwrap();
|
|
let media_pages = (0..archive.len())
|
|
.filter(|index| {
|
|
archive
|
|
.by_index(*index)
|
|
.map(|entry| entry.name().starts_with("word/media/page-"))
|
|
.unwrap_or(false)
|
|
})
|
|
.count();
|
|
let mut body = String::new();
|
|
archive
|
|
.by_name("word/document.xml")
|
|
.unwrap()
|
|
.read_to_string(&mut body)
|
|
.unwrap();
|
|
assert!(body.contains("Page"), "{body}");
|
|
assert!(body.contains("<wp:inline"), "{body}");
|
|
assert!(
|
|
!body.contains("w:lineRule=\"exact\""),
|
|
"full-page images need an automatic line height or Word clips them"
|
|
);
|
|
assert!(body.contains("w:lineRule=\"auto\""), "{body}");
|
|
assert_eq!(body.matches("<w:type w:val=\"nextPage\"/>").count(), 1);
|
|
assert_eq!(media_pages, 2);
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn detects_whether_a_pdf_needs_page_rendering() {
|
|
let directory =
|
|
std::env::temp_dir().join(format!("shift-pdf-images-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&directory).unwrap();
|
|
|
|
let text = directory.join("text.pdf");
|
|
make_pdf(&text, 1);
|
|
assert!(!has_embedded_images(&text).unwrap());
|
|
|
|
let scan = directory.join("scan.pdf");
|
|
make_pdf_with_image(&scan, 40, 40, 1);
|
|
assert!(has_embedded_images(&scan).unwrap());
|
|
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn poppler_page_count_is_read_from_pdfinfo() {
|
|
let listing = "Title: report\nPages: 12\nEncrypted: no\n";
|
|
assert_eq!(parse_pdfinfo_pages(listing), Some(12));
|
|
assert_eq!(parse_pdfinfo_pages("Pages: 0\n"), None);
|
|
assert_eq!(parse_pdfinfo_pages("Title: report\n"), None);
|
|
}
|
|
|
|
#[test]
|
|
fn image_heavy_pdf_to_docx_completes_without_text_extraction() {
|
|
use std::time::{Duration, Instant};
|
|
|
|
if renderer_path().is_none() {
|
|
return;
|
|
}
|
|
let directory =
|
|
std::env::temp_dir().join(format!("shift-docx-image-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&directory).unwrap();
|
|
let input = directory.join("scan.pdf");
|
|
let output = directory.join("scan.docx");
|
|
// The page contains no text layer and a large embedded image. A text
|
|
// extractor would either return nothing or spend its time inflating the
|
|
// image stream; the page-rendering path must not depend on it.
|
|
make_pdf_with_image(&input, 900, 1200, 3);
|
|
let started = Instant::now();
|
|
let mut progress = Vec::new();
|
|
to_docx_with_progress(&input, &output, |done, total, packaging| {
|
|
progress.push((done, total, packaging))
|
|
})
|
|
.unwrap();
|
|
assert!(
|
|
started.elapsed() < Duration::from_secs(30),
|
|
"conversion took too long"
|
|
);
|
|
assert_eq!(
|
|
progress,
|
|
vec![(1, 3, false), (2, 3, false), (3, 3, false), (3, 3, true)]
|
|
);
|
|
assert!(output.exists());
|
|
let archive = ZipArchive::new(fs::File::open(&output).unwrap()).unwrap();
|
|
assert!(archive
|
|
.file_names()
|
|
.any(|name| name.starts_with("word/media/page-")));
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn text_extraction_rejects_an_oversized_page_without_inflating_it() {
|
|
use std::io::Write as _;
|
|
|
|
let directory =
|
|
std::env::temp_dir().join(format!("shift-pdf-bomb-{}", uuid::Uuid::new_v4()));
|
|
fs::create_dir_all(&directory).unwrap();
|
|
let input = directory.join("bomb.pdf");
|
|
let mut encoder = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::best());
|
|
encoder
|
|
.write_all(&vec![0_u8; MAX_PAGE_CONTENT + 1])
|
|
.unwrap();
|
|
let compressed = encoder.finish().unwrap();
|
|
|
|
let mut document = Document::new();
|
|
let pages_id = document.new_object_id();
|
|
let content_id = document.add_object(lopdf::Stream::new(
|
|
dictionary! { "Filter" => "FlateDecode" },
|
|
compressed,
|
|
));
|
|
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,
|
|
});
|
|
document.objects.insert(
|
|
pages_id,
|
|
Object::Dictionary(dictionary! {
|
|
"Type" => "Pages",
|
|
"Kids" => vec![Object::Reference(page_id)],
|
|
"Count" => 1_i64,
|
|
}),
|
|
);
|
|
let catalog_id = document.add_object(dictionary! {
|
|
"Type" => "Catalog",
|
|
"Pages" => pages_id,
|
|
});
|
|
document.trailer.set("Root", catalog_id);
|
|
document.save(&input).unwrap();
|
|
|
|
let error = text_of(&input).unwrap_err();
|
|
assert!(error.contains("too large"), "{error}");
|
|
fs::remove_dir_all(directory).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn rendered_page_names_sort_numerically_not_lexically() {
|
|
let mut pages = [
|
|
PathBuf::from("Page-1.jpg"),
|
|
PathBuf::from("Page-10.jpg"),
|
|
PathBuf::from("Page-2.jpg"),
|
|
];
|
|
pages.sort_by_key(|path| page_number_in_name(path));
|
|
assert_eq!(pages[0], PathBuf::from("Page-1.jpg"));
|
|
assert_eq!(pages[1], PathBuf::from("Page-2.jpg"));
|
|
assert_eq!(pages[2], PathBuf::from("Page-10.jpg"));
|
|
}
|
|
|
|
#[cfg(not(target_os = "macos"))]
|
|
#[test]
|
|
fn renderer_limit_is_an_edge_length_not_a_pixel_count() {
|
|
let edge: u32 = PDF_RENDER_MAX_EDGE.parse().unwrap();
|
|
// Passing a total-pixel budget to `pdftoppm -scale-to` would allow one
|
|
// page edge to grow into the tens of thousands and exhaust memory.
|
|
assert!(
|
|
(1000..=4096).contains(&edge),
|
|
"unexpected renderer edge: {edge}"
|
|
);
|
|
}
|
|
}
|