fix: add skip_images flag to Rust renderer — thumbnails skip image decoding (17s → ms per page)

Author: mojtabakarimi

open-pdf-render/src/interpreter.rs

@@ -111,12 +111,36 @@ impl TextState {
 pub struct Interpreter;
 
 impl Interpreter {
+    /// Execute content stream, rendering all content including images.
     pub fn execute(
         content_bytes: &[u8],
         renderer: &mut SkiaRenderer,
         state: &mut GraphicsStateStack,
         doc: &Document,
         resources: &Dictionary,
+    ) -> Result<(), RenderError> {
+        Self::execute_internal(content_bytes, renderer, state, doc, resources, false)
+    }
+
+    /// Execute content stream but skip image XObjects. Used for fast
+    /// thumbnail rendering where image decoding would take seconds.
+    pub fn execute_skip_images(
+        content_bytes: &[u8],
+        renderer: &mut SkiaRenderer,
+        state: &mut GraphicsStateStack,
+        doc: &Document,
+        resources: &Dictionary,
+    ) -> Result<(), RenderError> {
+        Self::execute_internal(content_bytes, renderer, state, doc, resources, true)
+    }
+
+    fn execute_internal(
+        content_bytes: &[u8],
+        renderer: &mut SkiaRenderer,
+        state: &mut GraphicsStateStack,
+        doc: &Document,
+        resources: &Dictionary,
+        skip_images: bool,
     ) -> Result<(), RenderError> {
         let content = Content::decode(content_bytes)
             .map_err(|e| RenderError::ParseError(format!("Content decode: {}", e)))?;
@@ -198,7 +222,7 @@ impl Interpreter {
                 "W" | "W*" => {}
                 "BT" | "ET" | "Tf" | "Td" | "TD" | "Tm" | "Tj" | "TJ" | "T*" | "'" | "\"" | "Tc" | "Tw" | "Tz" | "TL" | "Ts" | "Tr" => {}
                 "Do" => {
-                    Self::handle_do_execute(&op.operands, renderer, state, doc, resources);
+                    Self::handle_do_execute(&op.operands, renderer, state, doc, resources, skip_images);
                 }
                 "gs" | "ri" | "i" => {}
                 _ => {}
@@ -213,6 +237,7 @@ impl Interpreter {
         state: &mut GraphicsStateStack,
         doc: &Document,
         resources: &Dictionary,
+        skip_images: bool,
     ) {
         let name = match operands.first() {
             Some(Object::Name(n)) => n,
@@ -240,7 +265,9 @@ impl Interpreter {
         };
         let subtype = stream.dict.get(b"Subtype").ok().and_then(|s| s.as_name().ok());
         if subtype == Some(b"Image" as &[u8]) {
-            Self::handle_image_execute(stream, renderer, state, doc);
+            if !skip_images {
+                Self::handle_image_execute(stream, renderer, state, doc);
+            }
             return;
         }
         if subtype != Some(b"Form" as &[u8]) {
@@ -261,7 +288,7 @@ impl Interpreter {
         let form_resources = Self::extract_form_resources(&stream.dict, doc);
         let res = form_resources.as_ref().unwrap_or(resources);
         if let Ok(content_bytes) = stream.decompressed_content() {
-            let _ = Self::execute(&content_bytes, renderer, state, doc, res);
+            let _ = Self::execute_internal(&content_bytes, renderer, state, doc, res, skip_images);
         }
         state.restore();
     }

open-pdf-render/src/parser.rs

@@ -41,6 +41,17 @@ impl DocumentHandle {
     /// app (e.g. user-applied rotation via the rotate-left/right buttons).
     /// Both rotations are clockwise-when-displayed, in degrees.
     pub fn render_page(&self, page: usize, scale: f32, extra_rotation: i32) -> Result<RenderedPage, RenderError> {
+        self.render_page_internal(page, scale, extra_rotation, false)
+    }
+
+    /// Render a page without decoding embedded images. Produces vector-only
+    /// output suitable for thumbnails — runs in milliseconds instead of
+    /// seconds for image-heavy pages.
+    pub fn render_page_no_images(&self, page: usize, scale: f32, extra_rotation: i32) -> Result<RenderedPage, RenderError> {
+        self.render_page_internal(page, scale, extra_rotation, true)
+    }
+
+    fn render_page_internal(&self, page: usize, scale: f32, extra_rotation: i32, skip_images: bool) -> Result<RenderedPage, RenderError> {
         let page_id = self.get_page_id(page)?;
         let (x0, y0, w_pt, h_pt) = self.extract_media_box_full(page_id)?;
 
@@ -78,7 +89,11 @@ impl DocumentHandle {
 
         let content_bytes = self.get_content_stream(page_id)?;
         let resources = self.get_page_resources(page_id)?;
-        crate::interpreter::Interpreter::execute(&content_bytes, &mut renderer, &mut state, &self.doc, &resources)?;
+        if skip_images {
+            crate::interpreter::Interpreter::execute_skip_images(&content_bytes, &mut renderer, &mut state, &self.doc, &resources)?;
+        } else {
+            crate::interpreter::Interpreter::execute(&content_bytes, &mut renderer, &mut state, &self.doc, &resources)?;
+        }
 
         Ok(RenderedPage { width, height, rgba: renderer.into_rgba() })
     }

open-pdf-studio/js/ui/panels/left-panel.js

@@ -413,22 +413,24 @@ async function renderThumbnailToDataURL(pdfDoc, pageNum) {
   if (!pdfDoc || pageNum > pdfDoc.numPages) return null;
   const _th0 = performance.now();
 
-  // Try Rust thumbnail rendering first (10-50ms vs 5-10 sec with PDF.js)
+  // Try Rust thumbnail rendering first — uses skip_images=true so only
+  // vector content is rendered (fast). Image decoding is skipped because
+  // it can take 17+ seconds per page for complex PDFs, blocking the Rust
+  // backend and preventing page navigation.
   const doc = getActiveDocument();
   if (doc?.filePath && window.__TAURI__) {
     try {
-      console.log(`[PERF-THUMB] page ${pageNum}: Rust render START`);
       const { invoke } = window.__TAURI__.core;
       const result = await invoke('render_thumbnail', {
         path: doc.filePath,
         pageIndex: pageNum - 1,
         maxWidth: 200,
+        skipImages: true,
       });
       const data = JSON.parse(result);
-      console.log(`[PERF-THUMB] page ${pageNum}: Rust render DONE: ${(performance.now() - _th0).toFixed(0)}ms`);
       return { dataURL: data.dataURL, width: data.width, height: data.height };
     } catch (e) {
-      console.warn(`[PERF-THUMB] page ${pageNum}: Rust render FAILED (${(performance.now() - _th0).toFixed(0)}ms):`, e);
+      console.warn(`[Thumbnails] Rust render failed for page ${pageNum}:`, e);
       // Fall through to PDF.js fallback
     }
   }

open-pdf-studio/src-tauri/src/lib.rs

@@ -911,11 +911,13 @@ fn render_thumbnail(
     page_index: u32,
     max_width: u32,
     rotation: Option<i32>,
+    skip_images: Option<bool>,
     bytes_cache: tauri::State<PdfBytesCache>,
     handle_cache: tauri::State<DocHandleCache>,
 ) -> Result<String, String> {
     let doc = get_or_load_doc(&path, &bytes_cache, &handle_cache)?;
     let extra_rot = rotation.unwrap_or(0);
+    let skip_img = skip_images.unwrap_or(false);
 
     // Get page dimensions to calculate thumbnail scale
     let (w_pt, h_pt) = doc.page_dimensions(page_index as usize)
@@ -924,8 +926,13 @@ fn render_thumbnail(
     // Scale so the longest side fits within max_width pixels
     let scale = max_width as f32 / w_pt.max(h_pt);
 
-    // Render at thumbnail scale
-    let page = doc.render_page(page_index as usize, scale, extra_rot).map_err(|e| format!("{}", e))?;
+    // Render at thumbnail scale — skip_images=true skips heavy image
+    // decoding so thumbnails render in milliseconds instead of seconds.
+    let page = if skip_img {
+        doc.render_page_no_images(page_index as usize, scale, extra_rot)
+    } else {
+        doc.render_page(page_index as usize, scale, extra_rot)
+    }.map_err(|e| format!("{}", e))?;
 
     // Convert RGBA to RGB (JPEG doesn't support alpha)
     let pixel_count = (page.width * page.height) as usize;