haraldandClaude Opus 5.5
392c22bc4a
Höchster Zoom 1000 % statt 500 % (Issue #1). Importierte PDF-Seiten werden mit doppelter Auflösung nachgerendert, sobald die Standardauflösung sichtbar vergrößert würde; bis dahin bleibt sie als Ersatz sichtbar. Texte werden bis 8 Pixel je Einheit gerastert. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
326 lines
12 KiB
Rust
326 lines
12 KiB
Rust
//! Lesen und Rendern importierter PDF-Dateien mit `hayro` (reines Rust, nur CPU).
|
|
//!
|
|
//! Das Rendern einer Seite kann einige hundert Millisekunden dauern; [`PdfRenderService`]
|
|
//! erledigt es deshalb in einem Hintergrund-Thread und meldet fertige Seiten zurück.
|
|
|
|
use std::collections::{HashMap, HashSet};
|
|
use std::path::PathBuf;
|
|
use std::sync::mpsc::{self, Receiver, Sender};
|
|
|
|
use hayro::hayro_interpret::InterpreterSettings;
|
|
use hayro::hayro_syntax::{LoadPdfError, Pdf};
|
|
use hayro::vello_cpu::color::palette::css::WHITE;
|
|
use hayro::{PixmapSettings, RenderCache, RenderSettings};
|
|
|
|
use crate::assets::RgbaImage;
|
|
|
|
/// Längste Kante einer gerenderten Seite für die Anzeige in Pixeln (A4 ≈ 220 dpi).
|
|
pub const DISPLAY_RENDER_PIXELS: u32 = 2560;
|
|
/// Längste Kante beim starken Hineinzoomen (A4 ≈ 440 dpi).
|
|
pub const ZOOMED_RENDER_PIXELS: u32 = 5120;
|
|
|
|
/// Texturschlüssel einer PDF-Seite: `<asset>#<seite>`, gerendert mit mehr als
|
|
/// [`DISPLAY_RENDER_PIXELS`] als `<asset>#<seite>@<pixel>`. Liefert Asset, Seite und Pixel.
|
|
pub fn parse_page_key(key: &str) -> Option<(&str, usize, u32)> {
|
|
let (asset, rest) = key.split_once('#')?;
|
|
let (page, pixels) = match rest.split_once('@') {
|
|
Some((page, pixels)) => (page, pixels.parse().ok()?),
|
|
None => (rest, DISPLAY_RENDER_PIXELS),
|
|
};
|
|
Some((asset, page.parse().ok()?, pixels))
|
|
}
|
|
/// Größte Seitenzahl, die importiert wird.
|
|
pub const MAX_IMPORT_PAGES: usize = 2000;
|
|
|
|
/// Öffnet ein PDF und liefert die angezeigte Größe jeder Seite in Punkt (Drehung
|
|
/// berücksichtigt).
|
|
pub fn page_sizes(bytes: Vec<u8>) -> Result<Vec<(f32, f32)>, String> {
|
|
let pdf = open(bytes)?;
|
|
let sizes: Vec<(f32, f32)> = pdf.pages().iter().map(|p| p.render_dimensions()).collect();
|
|
if sizes.is_empty() {
|
|
return Err("Das PDF enthält keine Seiten".into());
|
|
}
|
|
if sizes.len() > MAX_IMPORT_PAGES {
|
|
return Err(format!(
|
|
"Das PDF hat {} Seiten, höchstens {MAX_IMPORT_PAGES} werden unterstützt",
|
|
sizes.len()
|
|
));
|
|
}
|
|
Ok(sizes)
|
|
}
|
|
|
|
fn open(bytes: Vec<u8>) -> Result<Pdf, String> {
|
|
Pdf::new(bytes).map_err(|e| match e {
|
|
LoadPdfError::Decryption(_) => {
|
|
"Das PDF ist verschlüsselt oder passwortgeschützt und kann nicht geöffnet werden"
|
|
.to_string()
|
|
}
|
|
LoadPdfError::Invalid => "Die Datei ist kein lesbares PDF".to_string(),
|
|
})
|
|
}
|
|
|
|
/// Rendert Seite `index` so, dass die längste Kante höchstens `max_pixels` lang ist,
|
|
/// auf weißem Grund.
|
|
pub fn render_page(pdf: &Pdf, index: usize, max_pixels: u32) -> Result<RgbaImage, String> {
|
|
let page = pdf
|
|
.pages()
|
|
.get(index)
|
|
.ok_or_else(|| format!("Seite {} fehlt im PDF", index + 1))?;
|
|
let (w, h) = page.render_dimensions();
|
|
let scale = (max_pixels as f32 / w.max(h).max(1.0)).min(16.0);
|
|
let pixmap = hayro::render(
|
|
page,
|
|
&RenderCache::new(),
|
|
&InterpreterSettings::default(),
|
|
&RenderSettings::default(),
|
|
&PixmapSettings {
|
|
x_scale: scale,
|
|
y_scale: scale,
|
|
bg_color: WHITE,
|
|
},
|
|
);
|
|
// Auf weißem Grund ist jedes Pixel deckend: vormultipliziert = gerade Farbe
|
|
Ok(RgbaImage {
|
|
width: pixmap.width() as u32,
|
|
height: pixmap.height() as u32,
|
|
pixels: pixmap.data_as_u8_slice().to_vec(),
|
|
})
|
|
}
|
|
|
|
/// Öffnet die Datei und rendert eine Seite (für den PDF-Export als Ersatzbild).
|
|
pub fn render_file_page(
|
|
path: &std::path::Path,
|
|
index: usize,
|
|
max_pixels: u32,
|
|
) -> Result<RgbaImage, String> {
|
|
let bytes = std::fs::read(path).map_err(|e| e.to_string())?;
|
|
render_page(&open(bytes)?, index, max_pixels)
|
|
}
|
|
|
|
struct RenderRequest {
|
|
key: String,
|
|
path: PathBuf,
|
|
page: usize,
|
|
max_pixels: u32,
|
|
}
|
|
|
|
/// Ergebnis eines Render-Auftrags.
|
|
pub type RenderResult = Result<RgbaImage, String>;
|
|
|
|
/// Rendert PDF-Seiten im Hintergrund. Fertige Seiten holt der Event-Loop mit
|
|
/// [`PdfRenderService::take`] ab; `on_ready` weckt ihn dafür auf.
|
|
pub struct PdfRenderService {
|
|
requests: Sender<RenderRequest>,
|
|
results: Receiver<(String, RenderResult)>,
|
|
pending: HashSet<String>,
|
|
ready: HashMap<String, RenderResult>,
|
|
}
|
|
|
|
impl PdfRenderService {
|
|
pub fn new(on_ready: impl Fn() + Send + 'static) -> Self {
|
|
let (req_tx, req_rx) = mpsc::channel::<RenderRequest>();
|
|
let (res_tx, res_rx) = mpsc::channel();
|
|
std::thread::Builder::new()
|
|
.name("pdf-render".into())
|
|
.spawn(move || {
|
|
// Zuletzt geöffnetes PDF behalten: Blättern rendert meist dieselbe Datei
|
|
let mut open_pdf: Option<(PathBuf, Pdf)> = None;
|
|
while let Ok(request) = req_rx.recv() {
|
|
if open_pdf.as_ref().map(|(p, _)| p) != Some(&request.path) {
|
|
open_pdf = std::fs::read(&request.path)
|
|
.map_err(|e| e.to_string())
|
|
.and_then(open)
|
|
.map_err(|e| eprintln!("[PDF] '{}': {e}", request.path.display()))
|
|
.ok()
|
|
.map(|pdf| (request.path.clone(), pdf));
|
|
}
|
|
let result = match &open_pdf {
|
|
Some((_, pdf)) => render_page(pdf, request.page, request.max_pixels),
|
|
None => Err("PDF kann nicht geöffnet werden".into()),
|
|
};
|
|
if res_tx.send((request.key, result)).is_err() {
|
|
break;
|
|
}
|
|
on_ready();
|
|
}
|
|
})
|
|
.expect("PDF-Render-Thread konnte nicht gestartet werden");
|
|
Self {
|
|
requests: req_tx,
|
|
results: res_rx,
|
|
pending: HashSet::new(),
|
|
ready: HashMap::new(),
|
|
}
|
|
}
|
|
|
|
/// Rendert eine Seite vorab (z. B. die nächste), ohne auf das Ergebnis zu warten;
|
|
/// [`Self::take`] liefert es später sofort.
|
|
pub fn prefetch(&mut self, key: &str, path: PathBuf, page: usize) {
|
|
self.collect();
|
|
if self.ready.contains_key(key) || self.pending.contains(key) {
|
|
return;
|
|
}
|
|
// Vorab gerenderte Seiten nicht unbegrenzt aufheben
|
|
if self.ready.len() >= 2 {
|
|
self.ready.clear();
|
|
}
|
|
self.request(key, path, page, DISPLAY_RENDER_PIXELS);
|
|
}
|
|
|
|
fn collect(&mut self) {
|
|
while let Ok((done, result)) = self.results.try_recv() {
|
|
self.pending.remove(&done);
|
|
self.ready.insert(done, result);
|
|
}
|
|
}
|
|
|
|
/// Erteilt den Auftrag, falls noch keiner läuft. `false`, wenn der Thread beendet ist.
|
|
fn request(&mut self, key: &str, path: PathBuf, page: usize, max_pixels: u32) -> bool {
|
|
if !self.pending.insert(key.to_string()) {
|
|
return true;
|
|
}
|
|
let request = RenderRequest {
|
|
key: key.to_string(),
|
|
path,
|
|
page,
|
|
max_pixels,
|
|
};
|
|
if self.requests.send(request).is_err() {
|
|
self.pending.remove(key);
|
|
return false;
|
|
}
|
|
true
|
|
}
|
|
|
|
/// Fertiges Ergebnis für `key` abholen; sonst den Auftrag (einmalig) erteilen und `None`.
|
|
/// Die Seite wird so gerendert, dass die längste Kante `max_pixels` lang ist.
|
|
pub fn take(
|
|
&mut self,
|
|
key: &str,
|
|
path: PathBuf,
|
|
page: usize,
|
|
max_pixels: u32,
|
|
) -> Option<RenderResult> {
|
|
self.collect();
|
|
if let Some(result) = self.ready.remove(key) {
|
|
return Some(result);
|
|
}
|
|
if !self.request(key, path, page, max_pixels) {
|
|
return Some(Err("PDF-Render-Thread beendet".into()));
|
|
}
|
|
None
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) mod tests {
|
|
use super::*;
|
|
|
|
/// Minimales gültiges PDF mit Seiten der angegebenen Größen (Punkt); jede Seite zeigt ein
|
|
/// rotes Rechteck in der linken oberen Ecke. Optional mit `/Rotate`.
|
|
pub(crate) fn sample_pdf(pages: &[(f32, f32, i32)]) -> Vec<u8> {
|
|
let mut objects: Vec<String> = Vec::new();
|
|
let n = pages.len();
|
|
// 1: Katalog, 2: Seitenbaum, danach je Seite: Seite + Inhalt
|
|
objects.push("<< /Type /Catalog /Pages 2 0 R >>".into());
|
|
let kids: Vec<String> = (0..n).map(|i| format!("{} 0 R", 3 + 2 * i)).collect();
|
|
objects.push(format!(
|
|
"<< /Type /Pages /Kids [{}] /Count {n} >>",
|
|
kids.join(" ")
|
|
));
|
|
for (i, (w, h, rotate)) in pages.iter().enumerate() {
|
|
let content_id = 4 + 2 * i;
|
|
objects.push(format!(
|
|
"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 {w} {h}] /Rotate {rotate} /Contents {content_id} 0 R /Resources << >> >>"
|
|
));
|
|
let content = format!("1 0 0 rg 0 {} 40 40 re f", h - 40.0);
|
|
objects.push(format!(
|
|
"<< /Length {} >>\nstream\n{content}\nendstream",
|
|
content.len()
|
|
));
|
|
}
|
|
let mut out = b"%PDF-1.4\n".to_vec();
|
|
let mut offsets = Vec::new();
|
|
for (i, obj) in objects.iter().enumerate() {
|
|
offsets.push(out.len());
|
|
out.extend_from_slice(format!("{} 0 obj\n{obj}\nendobj\n", i + 1).as_bytes());
|
|
}
|
|
let xref_pos = out.len();
|
|
out.extend_from_slice(
|
|
format!("xref\n0 {}\n0000000000 65535 f \n", objects.len() + 1).as_bytes(),
|
|
);
|
|
for off in offsets {
|
|
out.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
|
|
}
|
|
out.extend_from_slice(
|
|
format!(
|
|
"trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{xref_pos}\n%%EOF\n",
|
|
objects.len() + 1
|
|
)
|
|
.as_bytes(),
|
|
);
|
|
out
|
|
}
|
|
|
|
#[test]
|
|
fn test_page_sizes_and_errors() {
|
|
let pdf = sample_pdf(&[(595.0, 842.0, 0), (842.0, 595.0, 0), (595.0, 842.0, 90)]);
|
|
let sizes = page_sizes(pdf).unwrap();
|
|
assert_eq!(sizes, vec![(595.0, 842.0), (842.0, 595.0), (842.0, 595.0)]);
|
|
assert!(page_sizes(b"kein pdf".to_vec()).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn test_render_page_draws_content() {
|
|
let pdf = open(sample_pdf(&[(200.0, 100.0, 0)])).unwrap();
|
|
let image = render_page(&pdf, 0, 400).unwrap();
|
|
assert_eq!((image.width, image.height), (400, 200));
|
|
let px = |x: u32, y: u32| {
|
|
let i = ((y * image.width + x) * 4) as usize;
|
|
&image.pixels[i..i + 4]
|
|
};
|
|
// Rotes Quadrat oben links, sonst weiß
|
|
assert_eq!(px(20, 20), &[255, 0, 0, 255]);
|
|
assert_eq!(px(300, 150), &[255, 255, 255, 255]);
|
|
assert!(render_page(&pdf, 5, 400).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn test_render_service_delivers_in_background() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join("a.pdf");
|
|
std::fs::write(&path, sample_pdf(&[(400.0, 300.0, 0)])).unwrap();
|
|
let (wake_tx, wake_rx) = mpsc::channel();
|
|
let mut service = PdfRenderService::new(move || {
|
|
let _ = wake_tx.send(());
|
|
});
|
|
let px = DISPLAY_RENDER_PIXELS;
|
|
assert!(service.take("a#0", path.clone(), 0, px).is_none());
|
|
// Zweite Anfrage erteilt keinen weiteren Auftrag
|
|
assert!(service.take("a#0", path.clone(), 0, px).is_none());
|
|
wake_rx
|
|
.recv_timeout(std::time::Duration::from_secs(20))
|
|
.unwrap();
|
|
let image = service.take("a#0", path.clone(), 0, px).unwrap().unwrap();
|
|
assert_eq!(image.width, DISPLAY_RENDER_PIXELS);
|
|
|
|
// Vorab rendern: danach sofort verfügbar
|
|
service.prefetch("a#0", path.clone(), 0);
|
|
wake_rx
|
|
.recv_timeout(std::time::Duration::from_secs(20))
|
|
.unwrap();
|
|
assert!(service.take("a#0", path, 0, px).unwrap().is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn test_parse_page_key() {
|
|
assert_eq!(
|
|
parse_page_key("abc.pdf#3"),
|
|
Some(("abc.pdf", 3, DISPLAY_RENDER_PIXELS))
|
|
);
|
|
assert_eq!(parse_page_key("abc.pdf#3@5120"), Some(("abc.pdf", 3, 5120)));
|
|
assert_eq!(parse_page_key("abc.png"), None);
|
|
assert_eq!(parse_page_key("abc.pdf#x"), None);
|
|
}
|
|
}
|