A fast, helpful, and open-source document parser
add screenshot rendering to pdfium and lit
Logan Markewich1a71554f89d4
diff --git a/cli/parse.ts b/cli/parse.tsindex 5b72400..8b6a225 100644--- a/cli/parse.ts+++ b/cli/parse.ts@@ -46,6 +46,7 @@ interface ScreenshotCommandOptions {dpi?: string;format?: string;password?: string;+ experimental?: boolean;config?: string;quiet?: boolean;}@@ -234,6 +235,7 @@ program.option("--dpi <dpi>", "DPI for rendering", DEFAULT_DPI.toString()).option("--format <format>", "Image format: png|jpg", DEFAULT_SCREENSHOT_FORMAT).option("--password <password>", "Password for encrypted/protected documents")+ .option("--experimental", "Use experimental Rust-based PDF engine").option("--config <file>", "Config file (JSON)").option("-q, --quiet", "Suppress progress output").action(async (file: string, options: ScreenshotCommandOptions) => {@@ -263,6 +265,7 @@ program...config,dpi: parseInt(options.dpi || DEFAULT_DPI.toString()),password: options.password,+ experimental: options.experimental || false,};// Parse target pagesdiff --git a/packages/rust/Cargo.lock b/packages/rust/Cargo.lockindex 3a40404..b0d79dd 100644--- a/packages/rust/Cargo.lock+++ b/packages/rust/Cargo.lock@@ -67,6 +67,12 @@ dependencies = ["windows-sys 0.61.2",]+[[package]]+name = "autocfg"+version = "1.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"+[[package]]name = "base64"version = "0.22.1"@@ -99,6 +105,18 @@ version = "2.11.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"+[[package]]+name = "bytemuck"+version = "1.25.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"++[[package]]+name = "byteorder-lite"+version = "0.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"+[[package]]name = "bytes"version = "1.11.1"@@ -212,6 +230,15 @@ dependencies = ["windows-sys 0.61.2",]+[[package]]+name = "fdeflate"+version = "0.3.7"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"+dependencies = [+ "simd-adler32",+]+[[package]]name = "filetime"version = "0.2.27"@@ -278,6 +305,19 @@ version = "1.10.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"+[[package]]+name = "image"+version = "0.25.10"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"+dependencies = [+ "bytemuck",+ "byteorder-lite",+ "moxcms",+ "num-traits",+ "png",+]+[[package]]name = "is_terminal_polyfill"version = "1.70.2"@@ -338,6 +378,7 @@ name = "liteparse-rs"version = "0.1.0"dependencies = ["clap",+ "image","pdfium","pdfium-sys","serde",@@ -372,6 +413,16 @@ dependencies = ["simd-adler32",]+[[package]]+name = "moxcms"+version = "0.8.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"+dependencies = [+ "num-traits",+ "pxfm",+]+[[package]]name = "nom"version = "7.1.3"@@ -382,6 +433,15 @@ dependencies = ["minimal-lexical",]+[[package]]+name = "num-traits"+version = "0.2.19"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"+dependencies = [+ "autocfg",+]+[[package]]name = "once_cell"version = "1.21.4"@@ -423,6 +483,19 @@ version = "0.2.3"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"+[[package]]+name = "png"+version = "0.18.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"+dependencies = [+ "bitflags",+ "crc32fast",+ "fdeflate",+ "flate2",+ "miniz_oxide",+]+[[package]]name = "prettyplease"version = "0.2.37"@@ -442,6 +515,12 @@ dependencies = ["unicode-ident",]+[[package]]+name = "pxfm"+version = "0.1.29"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e0c5ccf5294c6ccd63a74f1565028353830a9c2f5eb0c682c355c471726a6e3f"+[[package]]name = "quote"version = "1.0.45"diff --git a/packages/rust/crates/liteparse/Cargo.toml b/packages/rust/crates/liteparse/Cargo.tomlindex 051f909..b041979 100644--- a/packages/rust/crates/liteparse/Cargo.toml+++ b/packages/rust/crates/liteparse/Cargo.toml@@ -5,6 +5,7 @@ edition = "2024"[dependencies]clap = { version = "4.5.55", features = ["derive"] }+image = { version = "0.25", default-features = false, features = ["png"] }pdfium = { path = "../pdfium" }pdfium-sys = { path = "../pdfium-sys" }serde = { version = "1.0.228", features = ["derive"] }diff --git a/packages/rust/crates/liteparse/src/lib.rs b/packages/rust/crates/liteparse/src/lib.rsindex e01f64a..48262d5 100644--- a/packages/rust/crates/liteparse/src/lib.rs+++ b/packages/rust/crates/liteparse/src/lib.rs@@ -1,3 +1,4 @@pub mod extract;pub mod projection;+pub mod render;pub mod types;\ No newline at end of filediff --git a/packages/rust/crates/liteparse/src/main.rs b/packages/rust/crates/liteparse/src/main.rsindex 3811ef2..27ae92e 100644--- a/packages/rust/crates/liteparse/src/main.rs+++ b/packages/rust/crates/liteparse/src/main.rs@@ -1,6 +1,7 @@use clap::{Parser, Subcommand, Args};use liteparse_rs::extract;use liteparse_rs::projection;+use liteparse_rs::render;#[derive(Parser, Debug)]@@ -16,6 +17,12 @@ enum Commands {Extract(PdfCommand),/// Parse a PDF file: extract + grid projection, output projected pages as JSONParse(PdfCommand),+ /// Render a page to a PNG screenshot (file output)+ Screenshot(ScreenshotCommand),+ /// Render a page to PNG and write to stdout+ ScreenshotStdout(ScreenshotStdoutCommand),+ /// Extract embedded image bounding boxes from a page+ ImageBounds(PdfCommand),}@@ -30,6 +37,40 @@ struct PdfCommand {page_num: Option<u32>,}+#[derive(Args, Debug)]+struct ScreenshotCommand {+ /// Specify the path to the PDF file+ #[arg(long)]+ pdf_path: String,++ /// Target page number (1-based)+ #[arg(long)]+ page_num: u32,++ /// Output PNG file path+ #[arg(long)]+ output: String,++ /// DPI for rendering (default: 150)+ #[arg(long, default_value = "150")]+ dpi: f32,+}++#[derive(Args, Debug)]+struct ScreenshotStdoutCommand {+ /// Specify the path to the PDF file+ #[arg(long)]+ pdf_path: String,++ /// Target page number (1-based)+ #[arg(long)]+ page_num: u32,++ /// DPI for rendering (default: 150)+ #[arg(long, default_value = "150")]+ dpi: f32,+}+fn main() -> Result<(), Box<dyn std::error::Error>> {let cli = Cli::parse();@@ -54,6 +95,15 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {t3.duration_since(t0).as_secs_f64() * 1000.0,);}+ Commands::Screenshot(cmd) => {+ render::screenshot(&cmd.pdf_path, cmd.page_num, cmd.dpi, &cmd.output)?;+ }+ Commands::ScreenshotStdout(cmd) => {+ render::screenshot_to_stdout(&cmd.pdf_path, cmd.page_num, cmd.dpi)?;+ }+ Commands::ImageBounds(cmd) => {+ render::image_bounds(&cmd.pdf_path, cmd.page_num)?;+ }}Ok(())diff --git a/packages/rust/crates/liteparse/src/render.rs b/packages/rust/crates/liteparse/src/render.rsnew file mode 100644index 0000000..9302c7d--- /dev/null+++ b/packages/rust/crates/liteparse/src/render.rs@@ -0,0 +1,101 @@+use image::{ImageBuffer, Rgba};+use pdfium::Library;+use serde::Serialize;++/// Render a single page to a PNG file.+pub fn screenshot(+ pdf_path: &str,+ page_num: u32,+ dpi: f32,+ output_path: &str,+) -> Result<(), Box<dyn std::error::Error>> {+ let lib = Library::init();+ let document = lib.load_document(pdf_path, None)?;+ let page = document.page((page_num - 1) as i32)?;+ let bitmap = page.render(dpi)?;++ let width = bitmap.width() as u32;+ let height = bitmap.height() as u32;+ let rgba = bitmap.to_rgba();++ let img: ImageBuffer<Rgba<u8>, Vec<u8>> =+ ImageBuffer::from_raw(width, height, rgba)+ .ok_or("failed to create image buffer")?;++ img.save(output_path)?;+ eprintln!(+ "[rust-bin] rendered page {} at {dpi} DPI → {output_path} ({width}×{height})",+ page_num+ );++ Ok(())+}++/// Render a single page and write raw PNG bytes to stdout.+pub fn screenshot_to_stdout(+ pdf_path: &str,+ page_num: u32,+ dpi: f32,+) -> Result<(), Box<dyn std::error::Error>> {+ let lib = Library::init();+ let document = lib.load_document(pdf_path, None)?;+ let page = document.page((page_num - 1) as i32)?;+ let bitmap = page.render(dpi)?;++ let width = bitmap.width() as u32;+ let height = bitmap.height() as u32;+ let rgba = bitmap.to_rgba();++ let encoder = image::codecs::png::PngEncoder::new(std::io::stdout().lock());+ use image::ImageEncoder;+ encoder.write_image(&rgba, width, height, image::ColorType::Rgba8.into())?;++ Ok(())+}++#[derive(Debug, Serialize)]+struct ImageBoundsOutput {+ x: f32,+ y: f32,+ width: f32,+ height: f32,+}++/// Extract image bounding boxes and print as JSON to stdout.+pub fn image_bounds(+ pdf_path: &str,+ page_num: Option<u32>,+) -> Result<(), Box<dyn std::error::Error>> {+ let lib = Library::init();+ let document = lib.load_document(pdf_path, None)?;+ let page_count = document.page_count();++ for page_index in 0..page_count {+ if let Some(target) = page_num {+ if page_index as u32 + 1 != target {+ continue;+ }+ }++ let page = document.page(page_index)?;+ let bounds = page.image_bounds(25.0, 0.9);++ let output: Vec<ImageBoundsOutput> = bounds+ .iter()+ .map(|b| ImageBoundsOutput {+ x: b.x,+ y: b.y,+ width: b.width,+ height: b.height,+ })+ .collect();++ let json = serde_json::json!({+ "page_number": page_index + 1,+ "images": output,+ });+ println!("{}", serde_json::to_string(&json)?);+ }++ Ok(())+}diff --git a/packages/rust/crates/pdfium/src/bitmap.rs b/packages/rust/crates/pdfium/src/bitmap.rsnew file mode 100644index 0000000..429457d--- /dev/null+++ b/packages/rust/crates/pdfium/src/bitmap.rs@@ -0,0 +1,91 @@+use crate::error::PdfiumError;++pub struct Bitmap {+ handle: pdfium_sys::FPDF_BITMAP,+}++impl Bitmap {+ /// Wrap an existing FPDF_BITMAP handle (takes ownership, will destroy on drop).+ ///+ /// # Safety+ /// The handle must be a valid, non-null bitmap that the caller owns.+ pub unsafe fn from_handle(handle: pdfium_sys::FPDF_BITMAP) -> Self {+ Bitmap { handle }+ }++ /// Create a new BGRA bitmap with the given dimensions.+ pub fn new(width: i32, height: i32) -> Result<Self, PdfiumError> {+ let handle = unsafe {+ pdfium_sys::FPDFBitmap_CreateEx(+ width,+ height,+ pdfium_sys::FPDFBitmap_BGRA as i32,+ std::ptr::null_mut(),+ 0, // stride=0 lets pdfium choose+ )+ };+ if handle.is_null() {+ return Err(PdfiumError::OperationFailed);+ }+ Ok(Bitmap { handle })+ }++ pub fn handle(&self) -> pdfium_sys::FPDF_BITMAP {+ self.handle+ }++ pub fn width(&self) -> i32 {+ unsafe { pdfium_sys::FPDFBitmap_GetWidth(self.handle) }+ }++ pub fn height(&self) -> i32 {+ unsafe { pdfium_sys::FPDFBitmap_GetHeight(self.handle) }+ }++ pub fn stride(&self) -> i32 {+ unsafe { pdfium_sys::FPDFBitmap_GetStride(self.handle) }+ }++ /// Fill a rectangle with an ARGB color (0xAARRGGBB).+ pub fn fill_rect(&self, left: i32, top: i32, width: i32, height: i32, color: u64) {+ unsafe {+ pdfium_sys::FPDFBitmap_FillRect(self.handle, left, top, width, height, color);+ }+ }++ /// Get the raw pixel buffer as a byte slice.+ /// Format is BGRA, row-major, with `stride()` bytes per row.+ pub fn buffer(&self) -> &[u8] {+ let ptr = unsafe { pdfium_sys::FPDFBitmap_GetBuffer(self.handle) };+ let len = (self.stride() * self.height()) as usize;+ unsafe { std::slice::from_raw_parts(ptr as *const u8, len) }+ }++ /// Convert the BGRA buffer to RGBA in a new Vec.+ pub fn to_rgba(&self) -> Vec<u8> {+ let width = self.width() as usize;+ let height = self.height() as usize;+ let stride = self.stride() as usize;+ let src = self.buffer();+ let mut rgba = Vec::with_capacity(width * height * 4);++ for y in 0..height {+ let row = &src[y * stride..y * stride + width * 4];+ for pixel in row.chunks_exact(4) {+ // BGRA -> RGBA+ rgba.push(pixel[2]); // R+ rgba.push(pixel[1]); // G+ rgba.push(pixel[0]); // B+ rgba.push(pixel[3]); // A+ }+ }++ rgba+ }+}++impl Drop for Bitmap {+ fn drop(&mut self) {+ unsafe { pdfium_sys::FPDFBitmap_Destroy(self.handle) };+ }+}diff --git a/packages/rust/crates/pdfium/src/document.rs b/packages/rust/crates/pdfium/src/document.rsindex a807185..b7ed348 100644--- a/packages/rust/crates/pdfium/src/document.rs+++ b/packages/rust/crates/pdfium/src/document.rs@@ -17,6 +17,7 @@ impl Document {}Ok(Page {handle,+ doc_handle: self.handle,_doc: std::marker::PhantomData,})}diff --git a/packages/rust/crates/pdfium/src/lib.rs b/packages/rust/crates/pdfium/src/lib.rsindex 17b5ab0..6c11eaf 100644--- a/packages/rust/crates/pdfium/src/lib.rs+++ b/packages/rust/crates/pdfium/src/lib.rs@@ -4,10 +4,12 @@ mod library;mod document;mod page;mod text_page;+mod bitmap;pub use error::PdfiumError;pub use types::*;pub use library::Library;pub use document::Document;-pub use page::Page;+pub use page::{Page, ImageBounds};pub use text_page::{TextPage, TextChar, TextCharIter};+pub use bitmap::Bitmap;diff --git a/packages/rust/crates/pdfium/src/page.rs b/packages/rust/crates/pdfium/src/page.rsindex 05dff8d..7e324e1 100644--- a/packages/rust/crates/pdfium/src/page.rs+++ b/packages/rust/crates/pdfium/src/page.rs@@ -1,11 +1,23 @@use std::marker::PhantomData;+use crate::bitmap::Bitmap;use crate::document::Document;use crate::error::PdfiumError;use crate::text_page::TextPage;+/// Bounding box of an embedded image object on a page.+/// Coordinates are in PDF points with top-left origin (Y-down).+#[derive(Debug, Clone, Copy)]+pub struct ImageBounds {+ pub x: f32,+ pub y: f32,+ pub width: f32,+ pub height: f32,+}+pub struct Page<'doc> {pub(crate) handle: pdfium_sys::FPDF_PAGE,+ pub(crate) doc_handle: pdfium_sys::FPDF_DOCUMENT,pub(crate) _doc: PhantomData<&'doc Document>,}@@ -32,6 +44,121 @@ impl Page<'_> {_page: PhantomData,})}++ /// Render the page to a BGRA bitmap at the given DPI.+ pub fn render(&self, dpi: f32) -> Result<Bitmap, PdfiumError> {+ let scale = dpi / 72.0;+ let width = (self.width() * scale).round() as i32;+ let height = (self.height() * scale).round() as i32;++ let bitmap = Bitmap::new(width, height)?;++ // Fill with white (ARGB: 0xFFFFFFFF)+ bitmap.fill_rect(0, 0, width, height, 0xFFFFFFFF);++ let flags = (pdfium_sys::FPDF_ANNOT | pdfium_sys::FPDF_PRINTING) as i32;++ unsafe {+ pdfium_sys::FPDF_RenderPageBitmap(+ bitmap.handle(),+ self.handle,+ 0, // start_x+ 0, // start_y+ width, // size_x+ height, // size_y+ 0, // rotation+ flags,+ );+ }++ Ok(bitmap)+ }++ /// Extract bounding boxes of embedded image objects on this page.+ /// Returns coordinates in viewport space (Y-down, top-left origin) in PDF points.+ /// Filters out images smaller than `min_size_pt` and images covering more than+ /// `max_page_coverage` fraction of the page.+ pub fn image_bounds(&self, min_size_pt: f32, max_page_coverage: f32) -> Vec<ImageBounds> {+ let page_width = self.width();+ let page_height = self.height();+ let obj_count = unsafe { pdfium_sys::FPDFPage_CountObjects(self.handle) };+ let mut results = Vec::new();++ for i in 0..obj_count {+ let obj = unsafe { pdfium_sys::FPDFPage_GetObject(self.handle, i) };+ if obj.is_null() {+ continue;+ }++ let obj_type = unsafe { pdfium_sys::FPDFPageObj_GetType(obj) };+ if obj_type != pdfium_sys::FPDF_PAGEOBJ_IMAGE as i32 {+ continue;+ }++ let mut left: f32 = 0.0;+ let mut bottom: f32 = 0.0;+ let mut right: f32 = 0.0;+ let mut top: f32 = 0.0;+ let ok = unsafe {+ pdfium_sys::FPDFPageObj_GetBounds(obj, &mut left, &mut bottom, &mut right, &mut top)+ };+ if ok == 0 {+ continue;+ }++ let w = right - left;+ let h = top - bottom;++ if w < min_size_pt || h < min_size_pt {+ continue;+ }+ if w > page_width * max_page_coverage && h > page_height * max_page_coverage {+ continue;+ }++ // Convert from PDF coords (bottom-left origin) to viewport (top-left origin)+ results.push(ImageBounds {+ x: left,+ y: page_height - top,+ width: w,+ height: h,+ });+ }++ results+ }++ /// Get the rendered bitmap of a specific embedded image object by index.+ /// The index corresponds to the order from iterating page objects (image objects only).+ pub fn render_image_object(&self, image_obj_index: usize) -> Result<Bitmap, PdfiumError> {+ let obj_count = unsafe { pdfium_sys::FPDFPage_CountObjects(self.handle) };+ let mut image_idx = 0usize;++ for i in 0..obj_count {+ let obj = unsafe { pdfium_sys::FPDFPage_GetObject(self.handle, i) };+ if obj.is_null() {+ continue;+ }+ let obj_type = unsafe { pdfium_sys::FPDFPageObj_GetType(obj) };+ if obj_type != pdfium_sys::FPDF_PAGEOBJ_IMAGE as i32 {+ continue;+ }++ if image_idx == image_obj_index {+ let bmp_handle = unsafe {+ pdfium_sys::FPDFImageObj_GetRenderedBitmap(self.doc_handle, self.handle, obj)+ };+ if bmp_handle.is_null() {+ return Err(PdfiumError::OperationFailed);+ }+ // Wrap in our Bitmap (which will call Destroy on drop)+ return Ok(unsafe { Bitmap::from_handle(bmp_handle) });+ }+ image_idx += 1;+ }++ Err(PdfiumError::OperationFailed)+ }}impl Drop for Page<'_> {diff --git a/src/core/parser.ts b/src/core/parser.tsindex 39c5f31..aa1b5f8 100644--- a/src/core/parser.ts+++ b/src/core/parser.ts@@ -319,8 +319,12 @@ export class LiteParse {const results: ScreenshotResult[] = [];const pages = pageNumbers || Array.from({ length: totalPages }, (_, i) => i + 1);- const renderer = new PdfiumRenderer();- await renderer.loadDocument(pdfInput, this.config.password);+ const useRustRenderer = this.config.experimental && this.pdfEngine instanceof LiteParseRsEngine;++ const renderer = useRustRenderer ? null : new PdfiumRenderer();+ if (renderer) {+ await renderer.loadDocument(pdfInput, this.config.password);+ }try {for (const pageNum of pages) {@@ -330,7 +334,10 @@ export class LiteParse {}log(`Rendering page ${pageNum}...`);- const imageBuffer = await renderer.renderPageToBuffer(pdfInput, pageNum, this.config.dpi);++ const imageBuffer = useRustRenderer+ ? await this.pdfEngine.renderPageImage(doc, pageNum, this.config.dpi, this.config.password)+ : await renderer!.renderPageToBuffer(pdfInput, pageNum, this.config.dpi);const pageData = await this.pdfEngine.extractPage(doc, pageNum, { extractImages: false });@@ -342,7 +349,9 @@ export class LiteParse {});}} finally {- await renderer.close();+ if (renderer) {+ await renderer.close();+ }await this.pdfEngine.close(doc);if (needsCleanup && cleanupPath) {diff --git a/src/engines/pdf/liteparse-rs.ts b/src/engines/pdf/liteparse-rs.tsindex ad29682..54d3cad 100644--- a/src/engines/pdf/liteparse-rs.ts+++ b/src/engines/pdf/liteparse-rs.ts@@ -148,12 +148,31 @@ export class LiteParseRsEngine implements PdfEngine {async renderPageImage(_doc: PdfDocument,- _pageNum: number,- _dpi: number,+ pageNum: number,+ dpi: number,_password?: string): Promise<Buffer> {- // TODO: implement page rendering in the Rust CLI- throw new Error("renderPageImage is not yet implemented in liteparse-rs");+ const rustDoc = _doc as RustPdfDocument;+ const args = [+ "screenshot-stdout",+ "--pdf-path",+ rustDoc._filePath,+ "--page-num",+ String(pageNum),+ "--dpi",+ String(dpi),+ ];++ try {+ const result = await execFileAsync(BINARY_PATH, args, {+ maxBuffer: 100 * 1024 * 1024, // 100 MB+ encoding: "buffer" as BufferEncoding,+ });+ return Buffer.from(result.stdout as unknown as Buffer);+ } catch (err: unknown) {+ const message = err instanceof Error ? err.message : String(err);+ throw new Error(`liteparse-rs screenshot failed: ${message}`);+ }}async close(_doc: PdfDocument): Promise<void> {