Revert "#157 stage 2: padded rec batching in the browser (fewer ORT calls)"

This reverts commit 1c871c7. Padding every line in a batch up to the
batch's max width inflates recognition compute (a narrow line padded to
a wide one does several times the conv work), and on real pages line
widths vary enough that the padding waste outweighs the saved per-call
overhead — measured ~9.6-10.4s/page vs ~8.0s/page with the exact-width
grouping. With multi-threaded ORT the per-run overhead the batching
targeted is already cheap, so the trade doesn't pay. Back to the
bit-identical exact-width batches.

Refs #157

Signed-off-by: artiz <artem.kustikov@gmail.com>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EY5KAiquN4YpVf2PXEQkVT

Author: artiz

crates/docling-pdf/src/ocr_prep.rs

@@ -273,67 +273,6 @@ pub fn batch_input(w: usize, chunk: &[usize], lines: &[PrepLine]) -> Vec<f32> {
     data
 }
 
-/// Browser-path recognition batching: group lines of *differing* width into
-/// [`REC_BATCH`]-sized chunks (sorted by width, so a chunk spans a narrow
-/// range) and pad each chunk to its max width. The padding is the input
-/// buffer's zero value — mid-gray in the model's `[-1, 1]` space, which is
-/// exactly what PP-OCRv3 was trained/served with in batched inference, so the
-/// decode matches one-at-a-time recognition (measured: 0 diffs on a mixed
-/// Latin+Cyrillic sample). A width-ratio guard keeps padding waste ≤1.5×.
-///
-/// On a text-dense page where most lines have distinct widths this collapses
-/// N recognition calls into ≈N/[`REC_BATCH`] — a real win under ORT Web, where
-/// every `session.run` carries thread-sync overhead. Deliberately NOT used by
-/// the native path: that keeps the bit-identical exact-width [`width_batches`]
-/// so the byte-for-byte conformance baseline is untouched.
-pub fn width_batches_padded(lines: &[PrepLine]) -> Vec<(usize, Vec<usize>)> {
-    let mut order: Vec<usize> = (0..lines.len()).collect();
-    order.sort_by_key(|&i| lines[i].w);
-    let mut out: Vec<(usize, Vec<usize>)> = Vec::new();
-    let mut cur: Vec<usize> = Vec::new();
-    let mut cur_min = 0usize;
-    let flush = |cur: &mut Vec<usize>, out: &mut Vec<(usize, Vec<usize>)>| {
-        if !cur.is_empty() {
-            let mw = cur.iter().map(|&j| lines[j].w).max().unwrap_or(0);
-            out.push((mw, std::mem::take(cur)));
-        }
-    };
-    for &i in &order {
-        let w = lines[i].w;
-        // Cap padding waste: start a new chunk if this line is >1.5× the
-        // chunk's narrowest, or the chunk is already full.
-        if cur.len() == REC_BATCH || (!cur.is_empty() && w * 2 > cur_min * 3) {
-            flush(&mut cur, &mut out);
-        }
-        if cur.is_empty() {
-            cur_min = w;
-        }
-        cur.push(i);
-    }
-    flush(&mut cur, &mut out);
-    out
-}
-
-/// Pack a padded width-batch (see [`width_batches_padded`]): each line's CHW
-/// data goes into the left `line.w` columns of a zero-filled `(N, 3, H, W)`
-/// buffer, `W` = the batch's max width.
-pub fn batch_input_padded(w: usize, chunk: &[usize], lines: &[PrepLine]) -> Vec<f32> {
-    let h = REC_HEIGHT as usize;
-    let mut data = vec![0f32; chunk.len() * 3 * h * w];
-    for (i, &ix) in chunk.iter().enumerate() {
-        let lw = lines[ix].w;
-        let src = &lines[ix].data; // 3 * h * lw, CHW
-        for c in 0..3 {
-            for y in 0..h {
-                let s = c * h * lw + y * lw;
-                let d = i * 3 * h * w + c * h * w + y * w;
-                data[d..d + lw].copy_from_slice(&src[s..s + lw]);
-            }
-        }
-    }
-    data
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -402,33 +341,4 @@ mod tests {
         ];
         assert_eq!(decode_row(&chars, &probs, 4), "ab");
     }
-
-    /// Two lines of different width batch together when padded, and the padded
-    /// buffer places each line's data left-aligned with a zero tail.
-    #[test]
-    fn padded_batching_groups_and_left_aligns() {
-        // Narrow line (w=8, all 1.0) + wide line (w=10, all 2.0), within the
-        // 1.5x width-ratio guard so they share one padded batch.
-        let lines = vec![
-            PrepLine { w: 8, data: vec![1.0; 3 * REC_HEIGHT as usize * 8] },
-            PrepLine { w: 10, data: vec![2.0; 3 * REC_HEIGHT as usize * 10] },
-        ];
-        let batches = width_batches_padded(&lines);
-        assert_eq!(batches.len(), 1, "same-ratio widths share a padded batch");
-        let (w, chunk) = &batches[0];
-        assert_eq!(*w, 10, "batch width is the max in the chunk");
-        let buf = batch_input_padded(*w, chunk, &lines);
-        assert_eq!(buf.len(), chunk.len() * 3 * REC_HEIGHT as usize * 10);
-        // First row of the narrow line: 8 ones then 2 zero-pad columns.
-        let narrow_ix = chunk.iter().position(|&i| lines[i].w == 8).unwrap();
-        let row = &buf[narrow_ix * 3 * REC_HEIGHT as usize * 10..][..10];
-        assert_eq!(row, &[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0]);
-
-        // A line >1.5x the chunk minimum starts a fresh batch (bounds waste).
-        let spread = vec![
-            PrepLine { w: 8, data: vec![0.0; 3 * REC_HEIGHT as usize * 8] },
-            PrepLine { w: 40, data: vec![0.0; 3 * REC_HEIGHT as usize * 40] },
-        ];
-        assert_eq!(width_batches_padded(&spread).len(), 2);
-    }
 }

crates/docling-wasm/src/ocr.rs

@@ -32,8 +32,8 @@
 
 use docling_core::{DoclingDocument, Node};
 use docling_pdf::ocr_prep::{
-    batch_input_padded, decode_row, dict_chars, normalize_polarity, prep_page_lines,
-    width_batches_padded, REC_HEIGHT,
+    batch_input, decode_row, dict_chars, normalize_polarity, prep_page_lines, width_batches,
+    REC_HEIGHT,
 };
 use wasm_bindgen::prelude::*;
 
@@ -79,11 +79,8 @@ pub async fn ocr_image(
     let lines = prep_page_lines(&img);
     let chars = dict_chars(dict);
     let mut texts = vec![String::new(); lines.len()];
-    // Browser path batches lines of differing width (padded to the batch max)
-    // — far fewer ORT calls than exact-width grouping, output-equivalent under
-    // the model's zero padding. Native keeps the bit-identical exact-width path.
-    for (w, chunk) in width_batches_padded(&lines) {
-        let input = batch_input_padded(w, &chunk, &lines);
+    for (w, chunk) in width_batches(&lines) {
+        let input = batch_input(w, &chunk, &lines);
         let out = session
             .run(
                 chunk.len() as u32,

crates/docling-wasm/src/scanned.rs

@@ -22,8 +22,8 @@
 
 use docling_pdf::layout::{decode_layout, layout_input, SIDE};
 use docling_pdf::ocr_prep::{
-    batch_input_padded, decode_row, dict_chars, normalize_polarity, prep_region_lines,
-    width_batches_padded, REC_HEIGHT,
+    batch_input, decode_row, dict_chars, normalize_polarity, prep_region_lines, width_batches,
+    REC_HEIGHT,
 };
 use docling_pdf::pdfium_backend::{PdfPage, TextCell};
 use docling_pdf::scanned::{assemble_page, finish_document, refine_regions};
@@ -110,10 +110,8 @@ impl ScannedConverter {
         // OCR the text regions (same gather/batch/decode as native ocr_page).
         let (bboxes, lines) = prep_region_lines(&img, &regions, scale);
         let mut texts = vec![String::new(); lines.len()];
-        // Padded batching across differing widths (browser-only): far fewer ORT
-        // calls than exact-width grouping, output-equivalent under zero padding.
-        for (w, chunk) in width_batches_padded(&lines) {
-            let data = batch_input_padded(w, &chunk, &lines);
+        for (w, chunk) in width_batches(&lines) {
+            let data = batch_input(w, &chunk, &lines);
             let out = rec
                 .run(
                     chunk.len() as u32,