@u1f992/pdfdiff 0.2.1 → 0.2.2

package/src/pdf.ts

@@ -19,6 +19,7 @@ import * as jimp from "jimp";
 import * as mupdf from "mupdf";
 
 import type { JimpInstance } from "./jimp.ts";
+import { perf } from "./perf.ts";
 
 export function* loadPages(pdf: mupdf.Document) {
   for (let i = 0; i < pdf.countPages(); i++) {
@@ -60,6 +61,7 @@ export async function pageToImage(
   alpha: boolean,
 ) {
   const zoom = dpi / 72;
+  const sToPixmap = perf.span("pdf.toPixmap_ms");
   const pixmap = page.toPixmap(
     [zoom, 0, 0, zoom, 0, 0],
     mupdf.ColorSpace.DeviceRGB,
@@ -67,8 +69,14 @@ export async function pageToImage(
   );
   const width = pixmap.getWidth();
   const height = pixmap.getHeight();
+  sToPixmap.stop();
+  const sRgba = perf.span("pdf.pixmapToRGBA_ms");
   const data = pixmapToRGBA(pixmap);
   pixmap.destroy();
   page.destroy();
-  return jimp.Jimp.fromBitmap({ width, height, data }) as JimpInstance;
+  sRgba.stop();
+  const sFromBitmap = perf.span("pdf.fromBitmap_ms");
+  const result = jimp.Jimp.fromBitmap({ width, height, data }) as JimpInstance;
+  sFromBitmap.stop();
+  return result;
 }

package/src/perf.ts

@@ -0,0 +1,94 @@
+/*
+ * 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/>.
+ */
+
+const _enabled = (() => {
+  try {
+    if (
+      typeof process !== "undefined" &&
+      process.env &&
+      process.env.PDFDIFF_PROFILE === "1"
+    ) {
+      return true;
+    }
+  } catch {
+    // process not available (e.g. in some browser worker environments)
+  }
+  const g = globalThis as { __PDFDIFF_PROFILE__?: boolean };
+  return g.__PDFDIFF_PROFILE__ === true;
+})();
+
+export type Counters = Readonly<Record<string, number>>;
+
+export type Span = { stop(): void };
+
+type Perf = {
+  readonly enabled: boolean;
+  span(key: string): Span;
+  incr(key: string, delta?: number): void;
+  setMax(key: string, value: number): void;
+  merge(other: Counters): void;
+  dump(): Counters;
+  reset(): void;
+};
+
+const _counters: Record<string, number> = Object.create(null);
+
+const _NOOP_SPAN: Span = Object.freeze({ stop() {} });
+const _noop = () => {};
+const _emptyDump = (): Counters => Object.freeze({});
+
+const _realPerf: Perf = {
+  enabled: true,
+  span(key) {
+    const t0 = performance.now();
+    return {
+      stop() {
+        _counters[key] = (_counters[key] ?? 0) + (performance.now() - t0);
+      },
+    };
+  },
+  incr(key, delta = 1) {
+    _counters[key] = (_counters[key] ?? 0) + delta;
+  },
+  setMax(key, value) {
+    const cur = _counters[key];
+    if (cur === undefined || value > cur) _counters[key] = value;
+  },
+  merge(other) {
+    for (const k of Object.keys(other)) {
+      _counters[k] = (_counters[k] ?? 0) + other[k]!;
+    }
+  },
+  dump() {
+    return { ..._counters };
+  },
+  reset() {
+    for (const k of Object.keys(_counters)) delete _counters[k];
+  },
+};
+
+const _noopPerf: Perf = {
+  enabled: false,
+  span: () => _NOOP_SPAN,
+  incr: _noop,
+  setMax: _noop,
+  merge: _noop,
+  dump: _emptyDump,
+  reset: _noop,
+};
+
+export const perf: Perf = _enabled ? _realPerf : _noopPerf;

package/src/style.css

@@ -11,9 +11,21 @@
 .diff-table {
   border: 1px solid black;
   border-collapse: collapse;
+  width: 100%;
+  table-layout: fixed;
 }
 
 .diff-table th,
 .diff-table td {
   border: 1px solid black;
 }
+
+.diff-table img {
+  display: block;
+  max-width: 100%;
+  height: auto;
+}
+
+body.hide-no-diff .diff-details.no-diff {
+  display: none;
+}

package/src/transferable.ts

@@ -0,0 +1,30 @@
+/*
+ * 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/>.
+ */
+
+/**
+ * Slice a typed-array view into a standalone backing buffer of the same kind
+ * (ArrayBuffer in, ArrayBuffer out; SharedArrayBuffer in, SharedArrayBuffer
+ * out). The buffer kind is preserved through the generic parameter.
+ */
+export function sliceBackingBuffer<TArrayBuffer extends ArrayBufferLike>(
+  src: Uint8Array<TArrayBuffer> | Uint8ClampedArray<TArrayBuffer>,
+): TArrayBuffer {
+  return src.buffer.slice(
+    src.byteOffset,
+    src.byteOffset + src.byteLength,
+  ) as TArrayBuffer;
+}

package/src/worker.ts

@@ -25,6 +25,8 @@ import {
 } from "./image.ts";
 import type { JimpInstance } from "./jimp.ts";
 import { pageToImage } from "./pdf.ts";
+import { perf, type Counters } from "./perf.ts";
+import { sliceBackingBuffer } from "./transferable.ts";
 
 export type InitMessage = {
   type: "init";
@@ -59,6 +61,7 @@ export type PageResultMessage = {
   addition: [number, number][];
   deletion: [number, number][];
   modification: [number, number][];
+  perf?: Counters | undefined;
 };
 
 export type ErrorMessage = {
@@ -76,19 +79,8 @@ let opts: {
   align: AlignStrategy;
 };
 
-function toTransferable(
-  src: Buffer | Uint8Array | Uint8ClampedArray | number[],
-): ArrayBuffer {
-  const view =
-    src instanceof Uint8Array || src instanceof Uint8ClampedArray
-      ? src
-      : Uint8Array.from(src as ArrayLike<number>);
-  const out = new ArrayBuffer(view.byteLength);
-  new Uint8Array(out).set(view);
-  return out;
-}
-
 async function processPage(index: number): Promise<PageResultMessage> {
+  const sLoad = perf.span("worker.pageToImageAll_ms");
   const [pageA, pageB, pageMask] = (await Promise.all([
     index < pdfA.countPages()
       ? pageToImage(pdfA.loadPage(index), opts.dpi, opts.alpha)
@@ -98,42 +90,52 @@ async function processPage(index: number): Promise<PageResultMessage> {
       : createEmptyImage(1, 1),
     index < pdfMask.countPages()
       ? pageToImage(pdfMask.loadPage(index), opts.dpi, opts.alpha)
-      : createEmptyImage(1, 1),
-  ])) as [JimpInstance, JimpInstance, JimpInstance];
+      : Promise.resolve(null),
+  ])) as [JimpInstance, JimpInstance, JimpInstance | null];
+  sLoad.stop();
 
+  const sDiff = perf.span("worker.drawDifference_ms");
   const {
     diff: diffLayer,
     addition,
     deletion,
     modification,
+    hasDiff,
   } = drawDifference(pageA, pageB, pageMask, opts.pallet, opts.align);
-  const diff = composeLayers(pageA.width, pageA.height, [
+  sDiff.stop();
+
+  const sCompose = perf.span("worker.composeLayers_ms");
+  const layers: [JimpInstance, number][] = [
     [pageA, 0.2],
     [pageB, 0.2],
-    [diffLayer, 1],
-  ]);
+  ];
+  if (hasDiff) layers.push([diffLayer, 1]);
+  const diff = composeLayers(pageA.width, pageA.height, layers);
+  sCompose.stop();
+
+  const sXfer = perf.span("worker.toTransferable_ms");
+  const aBuf = sliceBackingBuffer(pageA.bitmap.data);
+  const bBuf = sliceBackingBuffer(pageB.bitmap.data);
+  const dBuf = sliceBackingBuffer(diff.bitmap.data);
+  sXfer.stop();
+  perf.incr("worker.pages");
+
+  let pagePerf: Counters | undefined;
+  if (perf.enabled) {
+    pagePerf = perf.dump();
+    perf.reset();
+  }
 
   return {
     type: "pageResult",
     index,
-    a: {
-      width: pageA.width,
-      height: pageA.height,
-      data: toTransferable(pageA.bitmap.data),
-    },
-    b: {
-      width: pageB.width,
-      height: pageB.height,
-      data: toTransferable(pageB.bitmap.data),
-    },
-    diff: {
-      width: diff.width,
-      height: diff.height,
-      data: toTransferable(diff.bitmap.data),
-    },
+    a: { width: pageA.width, height: pageA.height, data: aBuf },
+    b: { width: pageB.width, height: pageB.height, data: bBuf },
+    diff: { width: diff.width, height: diff.height, data: dBuf },
     addition,
     deletion,
     modification,
+    perf: pagePerf,
   };
 }