@u1f992/pdfdiff 0.2.1 → 0.3.0

package/src/diff.ts

@@ -1,22 +1,6 @@
-/*
- * Copyright (C) 2025  Koutaro Mukai
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
 import { type JimpInstance } from "./jimp.ts";
 import { alignSize, createEmptyImage, type AlignStrategy } from "./image.ts";
+import { perf } from "./perf.ts";
 import { type RGBAColor } from "./rgba-color.ts";
 
 export type Pallet = {
@@ -28,58 +12,122 @@ export type Pallet = {
 export function drawDifference(
   a: JimpInstance,
   b: JimpInstance,
-  mask: JimpInstance,
+  mask: JimpInstance | null,
   pallet: Readonly<Pallet>,
   align: AlignStrategy,
 ) {
-  const [aNew, bNew, maskNew] = alignSize([a, b, mask], align);
+  const sAlign = perf.span("diff.align_ms");
+  let aNew: JimpInstance;
+  let bNew: JimpInstance;
+  let maskNew: JimpInstance | null;
+  if (mask !== null) {
+    [aNew, bNew, maskNew] = alignSize([a, b, mask], align);
+  } else {
+    [aNew, bNew] = alignSize([a, b], align);
+    maskNew = null;
+  }
+  sAlign.stop();
+
   const width = aNew.width;
   const height = aNew.height;
   const aData = aNew.bitmap.data;
   const bData = bNew.bitmap.data;
-  const mData = maskNew.bitmap.data;
+  const mData = maskNew !== null ? maskNew.bitmap.data : null;
 
+  const sCreate = perf.span("diff.createEmpty_ms");
   const diffImage = createEmptyImage(width, height);
   const dData = diffImage.bitmap.data;
+  sCreate.stop();
 
   const addition: [number, number][] = [];
   const deletion: [number, number][] = [];
   const modification: [number, number][] = [];
 
-  for (let x = 0; x < width; x++) {
-    for (let y = 0; y < height; y++) {
-      const idx = (y * width + x) * 4;
-      if (mData[idx + 3]! !== 0) continue;
-      const aAlpha = aData[idx + 3]!;
-      const bAlpha = bData[idx + 3]!;
-      if (
-        aAlpha === bAlpha &&
-        aData[idx] === bData[idx] &&
-        aData[idx + 1] === bData[idx + 1] &&
-        aData[idx + 2] === bData[idx + 2]
-      ) {
-        continue;
+  const sScan = perf.span("diff.scan_ms");
+  let diffPixels = 0;
+
+  if (mData !== null) {
+    for (let x = 0; x < width; x++) {
+      for (let y = 0; y < height; y++) {
+        const idx = (y * width + x) * 4;
+        if (mData[idx + 3]! !== 0) continue;
+        const aAlpha = aData[idx + 3]!;
+        const bAlpha = bData[idx + 3]!;
+        if (
+          aAlpha === bAlpha &&
+          aData[idx] === bData[idx] &&
+          aData[idx + 1] === bData[idx + 1] &&
+          aData[idx + 2] === bData[idx + 2]
+        ) {
+          continue;
+        }
+        if (aAlpha === 0 && bAlpha === 0) continue;
+        let target: [number, number][];
+        let color: Readonly<RGBAColor>;
+        if (aAlpha === 0) {
+          target = addition;
+          color = pallet.addition;
+        } else if (bAlpha === 0) {
+          target = deletion;
+          color = pallet.deletion;
+        } else {
+          target = modification;
+          color = pallet.modification;
+        }
+        target.push([x, y]);
+        diffPixels++;
+        dData[idx] = color[0];
+        dData[idx + 1] = color[1];
+        dData[idx + 2] = color[2];
+        dData[idx + 3] = color[3];
       }
-      if (aAlpha === 0 && bAlpha === 0) continue;
-      let target: [number, number][];
-      let color: Readonly<RGBAColor>;
-      if (aAlpha === 0) {
-        target = addition;
-        color = pallet.addition;
-      } else if (bAlpha === 0) {
-        target = deletion;
-        color = pallet.deletion;
-      } else {
-        target = modification;
-        color = pallet.modification;
+    }
+  } else {
+    for (let x = 0; x < width; x++) {
+      for (let y = 0; y < height; y++) {
+        const idx = (y * width + x) * 4;
+        const aAlpha = aData[idx + 3]!;
+        const bAlpha = bData[idx + 3]!;
+        if (
+          aAlpha === bAlpha &&
+          aData[idx] === bData[idx] &&
+          aData[idx + 1] === bData[idx + 1] &&
+          aData[idx + 2] === bData[idx + 2]
+        ) {
+          continue;
+        }
+        if (aAlpha === 0 && bAlpha === 0) continue;
+        let target: [number, number][];
+        let color: Readonly<RGBAColor>;
+        if (aAlpha === 0) {
+          target = addition;
+          color = pallet.addition;
+        } else if (bAlpha === 0) {
+          target = deletion;
+          color = pallet.deletion;
+        } else {
+          target = modification;
+          color = pallet.modification;
+        }
+        target.push([x, y]);
+        diffPixels++;
+        dData[idx] = color[0];
+        dData[idx + 1] = color[1];
+        dData[idx + 2] = color[2];
+        dData[idx + 3] = color[3];
       }
-      target.push([x, y]);
-      dData[idx] = color[0];
-      dData[idx + 1] = color[1];
-      dData[idx + 2] = color[2];
-      dData[idx + 3] = color[3];
     }
   }
+  sScan.stop();
+  perf.incr("diff.diffPixels", diffPixels);
+  perf.incr("diff.totalPixels", width * height);
+  perf.incr("diff.pages");
 
-  return { diff: diffImage, addition, deletion, modification };
+  return {
+    diff: diffImage,
+    addition,
+    deletion,
+    modification,
+    hasDiff: diffPixels > 0,
+  };
 }

package/src/image.ts

@@ -1,22 +1,6 @@
-/*
- * Copyright (C) 2025  Koutaro Mukai
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
 import * as jimp from "jimp";
 import { type JimpInstance } from "./jimp.ts";
+import { perf } from "./perf.ts";
 
 export function createEmptyImage(width: number, height: number) {
   return new jimp.Jimp({
@@ -68,7 +52,7 @@ function alignImage(
   targetWidth: number,
   targetHeight: number,
   align: AlignStrategy,
-) {
+): JimpInstance {
   if (align === "resize") {
     return img.resize({ w: targetWidth, h: targetHeight });
   } else {
@@ -117,6 +101,7 @@ export function composeLayers(
   canvasHeight: number,
   layers: [JimpInstance, number][],
 ) {
+  const _span = perf.span("image.compose_ms");
   const canvas = createEmptyImage(canvasWidth, canvasHeight);
   const dData = canvas.bitmap.data;
   for (const [image, opacity] of layers) {
@@ -146,5 +131,6 @@ export function composeLayers(
       }
     }
   }
+  _span.stop();
   return canvas;
 }

package/src/index.html

@@ -49,7 +49,7 @@
         </div>
         <div>
           <label for="workers">Workers:</label>
-          <input type="number" id="workers" value="1" min="1" />
+          <input type="number" id="workers" placeholder="auto" min="1" />
         </div>
         <div>
           <label for="addition-color">Addition:</label>
@@ -64,6 +64,11 @@
           <input type="color" id="modification-color" value="#ffc105" />
         </div>
         <button type="submit">Submit</button>
+        <label>
+          <input type="checkbox" id="hide-no-diff" />
+          Hide pages with no diff
+        </label>
+        <button type="button" id="download-zip" disabled>Download zip</button>
       </form>
     </div>
     <div class="error" id="error-message"></div>

package/src/index.test.ts

@@ -1,26 +1,10 @@
-/*
- * Copyright (C) 2025  Koutaro Mukai
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
 import assert from "node:assert/strict";
 import fs from "node:fs";
 import test from "node:test";
 
 import {
   defaultOptions,
+  defaultWorkers,
   formatHex,
   isValidAlignStrategy,
   parseHex,
@@ -50,10 +34,18 @@ test("defaultOptions", () => {
       deletion: [0xff, 0x57, 0x24, 0xff],
       modification: [0xff, 0xc1, 0x05, 0xff],
     },
-    workers: 1,
+    workers: defaultWorkers,
   });
 });
 
+test("defaultWorkers scales with cores, capped at 4", () => {
+  assert.equal(
+    defaultWorkers,
+    Math.max(1, Math.min(globalThis.navigator?.hardwareConcurrency ?? 1, 4)),
+  );
+  assert.ok(defaultWorkers >= 1 && defaultWorkers <= 4);
+});
+
 test("isValidAlignStrategy", async (ctx) => {
   for (const s of [
     "resize",

package/src/index.ts

@@ -1,28 +1,13 @@
-/*
- * Copyright (C) 2025  Koutaro Mukai
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
 import * as jimp from "jimp";
-import * as mupdf from "mupdf";
 import Worker from "web-worker";
 
 import { type Pallet } from "./diff.ts";
 import { isValidAlignStrategy, type AlignStrategy } from "./image.ts";
 import { withIndex } from "./iterable.ts";
+import { countPages, renderPageRangePng } from "./pdf.ts";
+import { perf } from "./perf.ts";
 import { parseHex, formatHex } from "./rgba-color.ts";
+import { sliceBackingBuffer } from "./transferable.ts";
 import { VERSION } from "./version.ts";
 import type { JimpInstance } from "./jimp.ts";
 import type {
@@ -34,7 +19,7 @@ import type {
   ReadyMessage,
 } from "./worker.ts";
 
-export { withIndex, isValidAlignStrategy, parseHex, formatHex };
+export { withIndex, isValidAlignStrategy, parseHex, formatHex, perf };
 
 type Options = {
   dpi: number;
@@ -54,6 +39,15 @@ type Result = {
   modification: [number, number][];
 };
 
+// Default parallelism scales with the machine: rendering and diffing run across
+// several workers, so the out-of-the-box run uses the CPU rather than a single
+// core. Capped at 4 to keep the default memory footprint and oversubscription
+// modest; raise --workers explicitly for large jobs on big machines.
+export const defaultWorkers = Math.max(
+  1,
+  Math.min(globalThis.navigator?.hardwareConcurrency ?? 1, 4),
+);
+
 export const defaultOptions: Options = {
   dpi: 150,
   alpha: true,
@@ -64,25 +58,9 @@ export const defaultOptions: Options = {
     deletion: [0xff, 0x57, 0x24, 0xff],
     modification: [0xff, 0xc1, 0x05, 0xff],
   },
-  workers: 1,
+  workers: defaultWorkers,
 };
 
-function asSharedBytes(bytes: Uint8Array): Uint8Array {
-  const isNode =
-    typeof globalThis.process !== "undefined" &&
-    !!globalThis.process.versions?.node;
-  const coiOk =
-    (globalThis as { crossOriginIsolated?: boolean }).crossOriginIsolated ===
-    true;
-  if (typeof SharedArrayBuffer !== "undefined" && (isNode || coiOk)) {
-    const sab = new SharedArrayBuffer(bytes.byteLength);
-    const view = new Uint8Array(sab);
-    view.set(bytes);
-    return view;
-  }
-  return new Uint8Array(bytes);
-}
-
 type WorkerResponse =
   | LoadedMessage
   | ReadyMessage
@@ -135,12 +113,29 @@ class WorkerHandle {
     });
   }
 
-  processPage(index: number): Promise<PageResultMessage> {
+  processDiff(
+    index: number,
+    a: Uint8Array<ArrayBuffer> | null,
+    b: Uint8Array<ArrayBuffer> | null,
+    mask: Uint8Array<ArrayBuffer> | null,
+  ): Promise<PageResultMessage> {
     return new Promise<PageResultMessage>((resolve, reject) => {
       this.pendingResolve = resolve as (data: WorkerResponse) => void;
       this.pendingReject = reject;
-      const msg: PageMessage = { type: "page", index };
-      this.worker.postMessage(msg);
+      const aBuf = a !== null ? sliceBackingBuffer(a) : null;
+      const bBuf = b !== null ? sliceBackingBuffer(b) : null;
+      const maskBuf = mask !== null ? sliceBackingBuffer(mask) : null;
+      const msg: PageMessage = {
+        type: "page",
+        index,
+        a: aBuf,
+        b: bBuf,
+        mask: maskBuf,
+      };
+      const transfer = [aBuf, bBuf, maskBuf].filter(
+        (buf): buf is ArrayBuffer => buf !== null,
+      );
+      this.worker.postMessage(msg, transfer);
     });
   }
 
@@ -154,8 +149,18 @@ function workerUrl(): URL {
   return new URL(`${file}?v=${encodeURIComponent(VERSION)}`, import.meta.url);
 }
 
+function unpackCoords(buf: ArrayBuffer): [number, number][] {
+  const arr = new Int32Array(buf);
+  const out: [number, number][] = new Array(arr.length >>> 1);
+  for (let i = 0, j = 0; j < out.length; i += 2, j++) {
+    out[j] = [arr[i]!, arr[i + 1]!];
+  }
+  return out;
+}
+
 function pageResultToResult(msg: PageResultMessage): Result {
-  return {
+  const sP = perf.span("main.pageResultToResult_ms");
+  const r = {
     a: jimp.Jimp.fromBitmap({
       width: msg.a.width,
       height: msg.a.height,
@@ -171,10 +176,14 @@ function pageResultToResult(msg: PageResultMessage): Result {
       height: msg.diff.height,
       data: new Uint8Array(msg.diff.data),
     }) as JimpInstance,
-    addition: msg.addition,
-    deletion: msg.deletion,
-    modification: msg.modification,
+    addition: unpackCoords(msg.addition),
+    deletion: unpackCoords(msg.deletion),
+    modification: unpackCoords(msg.modification),
   };
+  sP.stop();
+  perf.incr("main.resultsReceived");
+  if (msg.perf) perf.merge(msg.perf);
+  return r;
 }
 
 export async function* visualizeDifferences(
@@ -196,62 +205,144 @@ export async function* visualizeDifferences(
     workers: options?.workers ?? defaultOptions.workers,
   };
 
-  const probe = mupdf.PDFDocument.openDocument(a, "application/pdf");
-  const probeB = mupdf.PDFDocument.openDocument(b, "application/pdf");
-  const probeMask =
+  const [aPages, bPages, maskPages] = await Promise.all([
+    countPages(a),
+    countPages(b),
     typeof merged.mask !== "undefined"
-      ? mupdf.PDFDocument.openDocument(merged.mask, "application/pdf")
-      : new mupdf.PDFDocument();
-  const maxPages = Math.max(
-    probe.countPages(),
-    probeB.countPages(),
-    probeMask.countPages(),
-  );
-  probe.destroy();
-  probeB.destroy();
-  probeMask.destroy();
+      ? countPages(merged.mask)
+      : Promise.resolve(0),
+  ]);
+  const maxPages = Math.max(aPages, bPages, maskPages);
 
   if (maxPages === 0) return;
 
-  const aBytes = asSharedBytes(a);
-  const bBytes = asSharedBytes(b);
-  const maskBytes =
-    typeof merged.mask !== "undefined" ? asSharedBytes(merged.mask) : null;
+  const mask = merged.mask;
+  const hasMask = typeof mask !== "undefined" && maskPages > 0;
+  const numDocs = hasMask ? 3 : 2;
 
   const initMsg: InitMessage = {
     type: "init",
-    aBytes,
-    bBytes,
-    maskBytes,
-    dpi: merged.dpi,
-    alpha: merged.alpha,
     pallet: merged.pallet,
     align: merged.align,
   };
 
   const N = Math.max(1, Math.min(merged.workers, maxPages));
   const url = workerUrl();
-  const worker0 = new WorkerHandle(url);
-  await worker0.init(initMsg);
-
-  const buffered = new Map<number, Result>();
-  let nextToAssign = 0;
-
-  const workers: WorkerHandle[] = [worker0];
-  for (let i = 1; i < N; i++) {
+  const workers: WorkerHandle[] = [];
+  for (let i = 0; i < N; i++) {
     const w = new WorkerHandle(url);
     await w.init(initMsg);
     workers.push(w);
   }
 
+  let aborted: unknown = null;
+
+  // One PNG slot per page per document, fulfilled as render chunks complete.
+  // Pages past a document's page count resolve to null (an empty/transparent
+  // page). The defensive catch keeps a chunk failure from surfacing as an
+  // unhandled rejection before a diff lane awaits the slot.
+  type Slot = {
+    p: Promise<Uint8Array<ArrayBuffer> | null>;
+    resolve: (v: Uint8Array<ArrayBuffer> | null) => void;
+    reject: (e: unknown) => void;
+  };
+  const makeSlots = (count: number): Slot[] =>
+    Array.from({ length: maxPages }, (_, i) => {
+      if (i >= count) {
+        return { p: Promise.resolve(null), resolve: () => {}, reject: () => {} };
+      }
+      let resolve!: (v: Uint8Array<ArrayBuffer> | null) => void;
+      let reject!: (e: unknown) => void;
+      const p = new Promise<Uint8Array<ArrayBuffer> | null>((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      p.catch(() => {});
+      return { p, resolve, reject };
+    });
+  const slots = {
+    a: makeSlots(aPages),
+    b: makeSlots(bPages),
+    mask: makeSlots(hasMask ? maskPages : 0),
+  };
+
+  // Render chunk tasks: batch several pages per gs() call to amortize startup,
+  // interleaving A/B/mask by page range so the early pages of every document
+  // become available together (which keeps the diff stage fed).
+  // Render concurrency. Aim for ~2x as many chunks as render slots so pages
+  // arrive in waves and the diff/decode stage overlaps later renders instead of
+  // waiting for one big batch. A floor keeps each chunk large enough to amortize
+  // Ghostscript's per-call startup: when there are many slots relative to pages,
+  // the slots are already saturated, so batching beats finer streaming.
+  const MIN_CHUNK = 4;
+  const R = Math.max(merged.workers, numDocs);
+  const totalRenderPages = aPages + bPages + (hasMask ? maskPages : 0);
+  const chunkSize = Math.max(
+    1,
+    Math.min(maxPages, Math.max(MIN_CHUNK, Math.ceil(totalRenderPages / (2 * R)))),
+  );
+  type Task = { bytes: Uint8Array; start: number; end: number; slots: Slot[] };
+  const tasks: Task[] = [];
+  const pushChunk = (
+    bytes: Uint8Array | undefined,
+    count: number,
+    target: Slot[],
+    start: number,
+  ) => {
+    if (bytes === undefined || start >= count) return;
+    tasks.push({
+      bytes,
+      start,
+      end: Math.min(start + chunkSize, count) - 1,
+      slots: target,
+    });
+  };
+  for (let start = 0; start < maxPages; start += chunkSize) {
+    pushChunk(a, aPages, slots.a, start);
+    pushChunk(b, bPages, slots.b, start);
+    if (hasMask) pushChunk(mask, maskPages, slots.mask, start);
+  }
+
+  let taskIdx = 0;
+  const renderLoops = Array.from(
+    { length: Math.min(R, tasks.length) },
+    async () => {
+      while (taskIdx < tasks.length && aborted === null) {
+        const t = tasks[taskIdx++]!;
+        try {
+          const pngs = await renderPageRangePng(
+            t.bytes,
+            t.start,
+            t.end,
+            merged.dpi,
+            merged.alpha,
+          );
+          for (let i = t.start; i <= t.end; i++) {
+            t.slots[i]!.resolve(pngs.get(i) ?? null);
+          }
+        } catch (e) {
+          aborted = e;
+          for (let i = t.start; i <= t.end; i++) t.slots[i]!.reject(e);
+        }
+      }
+    },
+  );
+
+  const buffered = new Map<number, Result>();
+  let nextToAssign = 0;
   const resolvers = new Map<number, (r: Result) => void>();
   let workerError: unknown = null;
 
-  const loops = workers.map(async (w) => {
+  const diffLoops = workers.map(async (w) => {
     while (nextToAssign < maxPages && workerError === null) {
       const idx = nextToAssign++;
       try {
-        const msg = await w.processPage(idx);
+        const [aPng, bPng, maskPng] = await Promise.all([
+          slots.a[idx]!.p,
+          slots.b[idx]!.p,
+          slots.mask[idx]!.p,
+        ]);
+        const msg = await w.processDiff(idx, aPng, bPng, maskPng);
         const result = pageResultToResult(msg);
         const resolve = resolvers.get(idx);
         if (resolve) {
@@ -259,9 +350,11 @@ export async function* visualizeDifferences(
           resolve(result);
         } else {
           buffered.set(idx, result);
+          perf.setMax("main.bufferedPeak", buffered.size);
         }
       } catch (e) {
         workerError = e;
+        aborted = e;
         for (const [, resolve] of resolvers) resolve(null as never);
         resolvers.clear();
         return;
@@ -278,13 +371,20 @@ export async function* visualizeDifferences(
         buffered.delete(i);
         r = buf;
       } else {
+        const sWait = perf.span("main.yieldWaitMain_ms");
         r = await new Promise<Result>((resolve) => resolvers.set(i, resolve));
+        sWait.stop();
         if (workerError !== null) throw workerError;
       }
+      const sYield = perf.span("main.consumerTime_ms");
       yield r;
+      sYield.stop();
     }
-    await Promise.all(loops);
+    await Promise.all(diffLoops);
+    await Promise.all(renderLoops);
   } finally {
+    aborted = aborted ?? new Error("aborted");
+    await Promise.allSettled(renderLoops);
     for (const w of workers) w.terminate();
   }
 }

package/src/iterable.test.ts

@@ -1,20 +1,3 @@
-/*
- * Copyright (C) 2025  Koutaro Mukai
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
 import assert from "assert";
 import test from "node:test";