@u1f992/pdfdiff 0.2.2 → 0.3.0

package/src/transferable.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/>.
- */
-
 /**
- * Slice a typed-array view into a standalone backing buffer of the same kind
+ * Slice an ArrayBufferView 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 {
+export function sliceBackingBuffer<TArrayBuffer extends ArrayBufferLike>(src: {
+  buffer: TArrayBuffer;
+  byteOffset: number;
+  byteLength: number;
+}): TArrayBuffer {
   return src.buffer.slice(
     src.byteOffset,
     src.byteOffset + src.byteLength,

package/src/worker.ts

@@ -1,40 +1,14 @@
-/*
- * 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 mupdf from "mupdf";
-
-import { drawDifference, type Pallet } from "./diff.ts";
-import {
-  composeLayers,
-  createEmptyImage,
-  type AlignStrategy,
-} from "./image.ts";
+import { decodePng } from "./decode.ts";
+import { type Pallet } from "./diff.ts";
+import { alignSize, createEmptyImage, type AlignStrategy } from "./image.ts";
 import type { JimpInstance } from "./jimp.ts";
-import { pageToImage } from "./pdf.ts";
 import { perf, type Counters } from "./perf.ts";
+import { type RGBAColor } from "./rgba-color.ts";
 import { sliceBackingBuffer } from "./transferable.ts";
+import createWasmModule, { type MainModule } from "./wasm/core.js";
 
 export type InitMessage = {
   type: "init";
-  aBytes: Uint8Array;
-  bBytes: Uint8Array;
-  maskBytes: Uint8Array | null;
-  dpi: number;
-  alpha: boolean;
   pallet: Pallet;
   align: AlignStrategy;
 };
@@ -42,6 +16,11 @@ export type InitMessage = {
 export type PageMessage = {
   type: "page";
   index: number;
+  // PNG bytes rendered on the main thread, or null when the source PDF has no
+  // such page (the diff then treats it as an empty/transparent page).
+  a: ArrayBuffer | null;
+  b: ArrayBuffer | null;
+  mask: ArrayBuffer | null;
 };
 
 export type LoadedMessage = {
@@ -58,9 +37,9 @@ export type PageResultMessage = {
   a: { width: number; height: number; data: ArrayBuffer };
   b: { width: number; height: number; data: ArrayBuffer };
   diff: { width: number; height: number; data: ArrayBuffer };
-  addition: [number, number][];
-  deletion: [number, number][];
-  modification: [number, number][];
+  addition: ArrayBuffer;
+  deletion: ArrayBuffer;
+  modification: ArrayBuffer;
   perf?: Counters | undefined;
 };
 
@@ -69,54 +48,83 @@ export type ErrorMessage = {
   message: string;
 };
 
-let pdfA: mupdf.Document;
-let pdfB: mupdf.Document;
-let pdfMask: mupdf.Document;
+type WasmProcessResult = {
+  overlay: Uint8Array<ArrayBuffer>;
+  addition: Int32Array<ArrayBuffer>;
+  deletion: Int32Array<ArrayBuffer>;
+  modification: Int32Array<ArrayBuffer>;
+};
+
 let opts: {
-  dpi: number;
-  alpha: boolean;
   pallet: Pallet;
   align: AlignStrategy;
 };
 
-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)
-      : createEmptyImage(1, 1),
-    index < pdfB.countPages()
-      ? pageToImage(pdfB.loadPage(index), opts.dpi, opts.alpha)
-      : createEmptyImage(1, 1),
-    index < pdfMask.countPages()
-      ? pageToImage(pdfMask.loadPage(index), opts.dpi, opts.alpha)
-      : Promise.resolve(null),
+let wasm: MainModule | null = null;
+async function getWasm(): Promise<MainModule> {
+  if (!wasm) wasm = await createWasmModule();
+  return wasm;
+}
+
+function packColor([r, g, b, a]: RGBAColor): number {
+  return ((r << 24) | (g << 16) | (b << 8) | a) >>> 0;
+}
+
+async function processPage(msg: PageMessage): Promise<PageResultMessage> {
+  const index = msg.index;
+  const sLoad = perf.span("worker.decodeAll_ms");
+  const [pageA, pageB, pageMaskOrNull] = (await Promise.all([
+    msg.a !== null ? decodePng(msg.a) : createEmptyImage(1, 1),
+    msg.b !== null ? decodePng(msg.b) : createEmptyImage(1, 1),
+    msg.mask !== null ? decodePng(msg.mask) : 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);
-  sDiff.stop();
-
-  const sCompose = perf.span("worker.composeLayers_ms");
-  const layers: [JimpInstance, number][] = [
-    [pageA, 0.2],
-    [pageB, 0.2],
-  ];
-  if (hasDiff) layers.push([diffLayer, 1]);
-  const diff = composeLayers(pageA.width, pageA.height, layers);
-  sCompose.stop();
+  const sAlign = perf.span("worker.alignSize_ms");
+  let aAligned: JimpInstance;
+  let bAligned: JimpInstance;
+  let maskAligned: JimpInstance | null;
+  if (pageMaskOrNull !== null) {
+    [aAligned, bAligned, maskAligned] = alignSize(
+      [pageA, pageB, pageMaskOrNull],
+      opts.align,
+    );
+  } else {
+    [aAligned, bAligned] = alignSize([pageA, pageB], opts.align);
+    maskAligned = null;
+  }
+  sAlign.stop();
+
+  const width = aAligned.width;
+  const height = aAligned.height;
+  const aData = aAligned.bitmap.data;
+  const bData = bAligned.bitmap.data;
+  const maskData = maskAligned !== null ? maskAligned.bitmap.data : null;
+
+  const sProcess = perf.span("worker.processPage_ms");
+  const wasmModule = await getWasm();
+  const result = wasmModule.processPage(
+    aData,
+    bData,
+    maskData,
+    width,
+    height,
+    packColor(opts.pallet.addition),
+    packColor(opts.pallet.deletion),
+    packColor(opts.pallet.modification),
+  ) as WasmProcessResult | number;
+  if (typeof result === "number") {
+    throw new Error(`wasm processPage failed: ${result}`);
+  }
+  sProcess.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);
+  const aBuf = sliceBackingBuffer(aData);
+  const bBuf = sliceBackingBuffer(bData);
+  const dBuf = sliceBackingBuffer(result.overlay);
+  const addBuf = sliceBackingBuffer(result.addition);
+  const delBuf = sliceBackingBuffer(result.deletion);
+  const modBuf = sliceBackingBuffer(result.modification);
   sXfer.stop();
   perf.incr("worker.pages");
 
@@ -129,12 +137,12 @@ async function processPage(index: number): Promise<PageResultMessage> {
   return {
     type: "pageResult",
     index,
-    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,
+    a: { width, height, data: aBuf },
+    b: { width, height, data: bBuf },
+    diff: { width, height, data: dBuf },
+    addition: addBuf,
+    deletion: delBuf,
+    modification: modBuf,
     perf: pagePerf,
   };
 }
@@ -145,26 +153,22 @@ self.addEventListener(
     try {
       const msg = e.data;
       if (msg.type === "init") {
-        pdfA = mupdf.PDFDocument.openDocument(msg.aBytes, "application/pdf");
-        pdfB = mupdf.PDFDocument.openDocument(msg.bBytes, "application/pdf");
-        pdfMask = msg.maskBytes
-          ? mupdf.PDFDocument.openDocument(msg.maskBytes, "application/pdf")
-          : new mupdf.PDFDocument();
         opts = {
-          dpi: msg.dpi,
-          alpha: msg.alpha,
           pallet: msg.pallet,
           align: msg.align,
         };
-        if (pdfA.countPages() > 0) pdfA.loadPage(0).destroy();
+        await getWasm();
         const ready: ReadyMessage = { type: "ready" };
         self.postMessage(ready);
       } else if (msg.type === "page") {
-        const result = await processPage(msg.index);
+        const result = await processPage(msg);
         self.postMessage(result, [
           result.a.data,
           result.b.data,
           result.diff.data,
+          result.addition,
+          result.deletion,
+          result.modification,
         ]);
       }
     } catch (err) {

package/wasm/Makefile

@@ -0,0 +1,34 @@
+OUT_DIR := ../src/wasm
+C_SOURCES := core.c
+CPP_SOURCES := bindings.cpp
+HEADERS := core.h
+
+EMFLAGS := \
+	-lembind \
+	-s MODULARIZE=1 \
+	-s EXPORT_ES6=1 \
+	-s ALLOW_MEMORY_GROWTH=1 \
+	--emit-tsd core.d.ts \
+	-O3
+
+all: $(OUT_DIR)/core.js
+
+$(OUT_DIR)/core.js: $(C_SOURCES) $(CPP_SOURCES) $(HEADERS)
+	mkdir -p $(OUT_DIR)
+	em++ $(C_SOURCES) $(CPP_SOURCES) -o $@ $(EMFLAGS)
+
+debug: $(C_SOURCES) $(CPP_SOURCES) $(HEADERS)
+	mkdir -p $(OUT_DIR)
+	em++ $(C_SOURCES) $(CPP_SOURCES) -o $(OUT_DIR)/core.js $(EMFLAGS) -DCORE_DEBUG -g -O0
+
+format:
+	clang-format -i $(C_SOURCES) $(CPP_SOURCES) $(HEADERS)
+
+tidy:
+	clang-tidy $(C_SOURCES) -- -I.
+	@echo "Note: $(CPP_SOURCES) skipped (requires Emscripten include paths)"
+
+clean:
+	rm -rf $(OUT_DIR)
+
+.PHONY: all debug format tidy clean

package/wasm/bindings.cpp

@@ -0,0 +1,76 @@
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+
+#include <cstdint>
+#include <vector>
+
+#include "core.h"
+
+using emscripten::val;
+
+static CoreColor unpackColor(uint32_t packed) {
+  CoreColor c;
+  c.r = (uint8_t)((packed >> 24) & 0xff);
+  c.g = (uint8_t)((packed >> 16) & 0xff);
+  c.b = (uint8_t)((packed >> 8) & 0xff);
+  c.a = (uint8_t)(packed & 0xff);
+  return c;
+}
+
+val processPage(val aPixelsVal, val bPixelsVal, val maskPixelsVal,
+                int32_t width, int32_t height, uint32_t additionPacked,
+                uint32_t deletionPacked, uint32_t modificationPacked) {
+  if (width <= 0 || height <= 0 ||
+      (int64_t)width * (int64_t)height > INT32_MAX) {
+    return val(CORE_ERROR_INVALID);
+  }
+
+  std::vector<uint8_t> a =
+      emscripten::convertJSArrayToNumberVector<uint8_t>(aPixelsVal);
+  std::vector<uint8_t> b =
+      emscripten::convertJSArrayToNumberVector<uint8_t>(bPixelsVal);
+
+  bool hasMask = !maskPixelsVal.isNull() && !maskPixelsVal.isUndefined();
+  std::vector<uint8_t> mask;
+  if (hasMask) {
+    mask = emscripten::convertJSArrayToNumberVector<uint8_t>(maskPixelsVal);
+  }
+
+  CorePallet pallet = {unpackColor(additionPacked), unpackColor(deletionPacked),
+                       unpackColor(modificationPacked)};
+
+  CoreResult result;
+  int32_t rc = process_page(a.data(), b.data(), hasMask ? mask.data() : nullptr,
+                            width, height, &pallet, &result);
+  if (rc != CORE_OK) {
+    return val(rc);
+  }
+
+  size_t pixelByteCount = (size_t)width * (size_t)height * 4;
+
+  val obj = val::object();
+
+  val overlayArr = val::global("Uint8Array").new_(pixelByteCount);
+  overlayArr.call<void>("set", val(emscripten::typed_memory_view(
+                                   pixelByteCount, result.overlay)));
+  obj.set("overlay", overlayArr);
+
+  auto attachCoords = [&](const char *name, int32_t *xy, int32_t count) {
+    int32_t len = count * 2;
+    val arr = val::global("Int32Array").new_(len);
+    if (len > 0) {
+      arr.call<void>("set",
+                     val(emscripten::typed_memory_view((size_t)len, xy)));
+    }
+    obj.set(name, arr);
+  };
+  attachCoords("addition", result.addition_xy, result.addition_count);
+  attachCoords("deletion", result.deletion_xy, result.deletion_count);
+  attachCoords("modification", result.modification_xy,
+               result.modification_count);
+
+  core_result_free(&result);
+  return obj;
+}
+
+EMSCRIPTEN_BINDINGS(core) { emscripten::function("processPage", &processPage); }

package/wasm/core.c

@@ -0,0 +1,176 @@
+#include "core.h"
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define COORD_INITIAL_CAPACITY 256
+
+typedef struct {
+  int32_t *data;
+  int32_t count;
+  int32_t capacity;
+} Coords;
+
+static int32_t coords_init(Coords *c) {
+  c->capacity = COORD_INITIAL_CAPACITY;
+  c->count = 0;
+  c->data = (int32_t *)malloc((size_t)c->capacity * 2 * sizeof(int32_t));
+  if (!c->data) {
+    return CORE_ERROR_ALLOC;
+  }
+  return CORE_OK;
+}
+
+static int32_t coords_push(Coords *c, int32_t x, int32_t y) {
+  if (c->count >= c->capacity) {
+    int32_t new_cap = c->capacity * 2;
+    int32_t *new_data =
+        (int32_t *)realloc(c->data, (size_t)new_cap * 2 * sizeof(int32_t));
+    if (!new_data) {
+      return CORE_ERROR_ALLOC;
+    }
+    c->data = new_data;
+    c->capacity = new_cap;
+  }
+  c->data[c->count * 2] = x;
+  c->data[c->count * 2 + 1] = y;
+  c->count++;
+  return CORE_OK;
+}
+
+static void coords_dispose(Coords *c) {
+  free(c->data);
+  c->data = NULL;
+}
+
+/*
+ * Mirrors the original JS `composeLayers` Porter-Duff "over" math, including
+ * Math.round() (round-half-up for non-negative values), to keep output
+ * byte-identical to the previous JS implementation.
+ */
+static void blend_over(uint8_t *dst, uint8_t sr, uint8_t sg, uint8_t sb,
+                       uint8_t s_alpha, double opacity) {
+  double sa = ((double)s_alpha / 255.0) * opacity;
+  if (sa == 0.0) {
+    return;
+  }
+  double da = (double)dst[3] / 255.0;
+  double oa = sa + da * (1.0 - sa);
+  if (oa == 0.0) {
+    return;
+  }
+  double sw = sa / oa;
+  double dw = (da * (1.0 - sa)) / oa;
+  dst[0] = (uint8_t)floor((double)sr * sw + (double)dst[0] * dw + 0.5);
+  dst[1] = (uint8_t)floor((double)sg * sw + (double)dst[1] * dw + 0.5);
+  dst[2] = (uint8_t)floor((double)sb * sw + (double)dst[2] * dw + 0.5);
+  dst[3] = (uint8_t)floor(oa * 255.0 + 0.5);
+}
+
+void core_result_free(CoreResult *r) {
+  if (!r) {
+    return;
+  }
+  free(r->overlay);
+  free(r->addition_xy);
+  free(r->deletion_xy);
+  free(r->modification_xy);
+  memset(r, 0, sizeof(*r));
+}
+
+int32_t process_page(const uint8_t *a_pixels, const uint8_t *b_pixels,
+                     const uint8_t *mask_pixels, int32_t width, int32_t height,
+                     const CorePallet *pallet, CoreResult *out) {
+  if (!a_pixels || !b_pixels || !pallet || !out) {
+    return CORE_ERROR_INVALID;
+  }
+  if (width <= 0 || height <= 0) {
+    return CORE_ERROR_INVALID;
+  }
+
+  memset(out, 0, sizeof(*out));
+
+  size_t pixel_count = (size_t)width * (size_t)height;
+  size_t byte_count = pixel_count * 4;
+
+  uint8_t *overlay = (uint8_t *)calloc(byte_count, 1);
+  if (!overlay) {
+    return CORE_ERROR_ALLOC;
+  }
+
+  Coords add = {0}, del = {0}, mod = {0};
+  if (coords_init(&add) != CORE_OK || coords_init(&del) != CORE_OK ||
+      coords_init(&mod) != CORE_OK) {
+    coords_dispose(&add);
+    coords_dispose(&del);
+    coords_dispose(&mod);
+    free(overlay);
+    return CORE_ERROR_ALLOC;
+  }
+
+  /* Diff layer (per-pixel pallet color) is reused into `overlay` directly:
+     for each pixel we compute the diff classification, then alpha-over
+     a*0.2, b*0.2, and the diff-pixel*1.0 onto overlay. The diff layer
+     itself is never materialized as a separate buffer. */
+  for (int32_t y = 0; y < height; y++) {
+    for (int32_t x = 0; x < width; x++) {
+      size_t idx = (size_t)(y * width + x) * 4;
+
+      const uint8_t *ap = a_pixels + idx;
+      const uint8_t *bp = b_pixels + idx;
+      uint8_t *op = overlay + idx;
+
+      /* Compose a (opacity 0.2). */
+      blend_over(op, ap[0], ap[1], ap[2], ap[3], 0.2);
+      /* Compose b (opacity 0.2). */
+      blend_over(op, bp[0], bp[1], bp[2], bp[3], 0.2);
+
+      if (mask_pixels && mask_pixels[idx + 3] != 0) {
+        continue;
+      }
+
+      uint8_t a_alpha = ap[3];
+      uint8_t b_alpha = bp[3];
+      if (a_alpha == b_alpha && ap[0] == bp[0] && ap[1] == bp[1] &&
+          ap[2] == bp[2]) {
+        continue;
+      }
+      if (a_alpha == 0 && b_alpha == 0) {
+        continue;
+      }
+
+      Coords *target;
+      const CoreColor *color;
+      if (a_alpha == 0) {
+        target = &add;
+        color = &pallet->addition;
+      } else if (b_alpha == 0) {
+        target = &del;
+        color = &pallet->deletion;
+      } else {
+        target = &mod;
+        color = &pallet->modification;
+      }
+      if (coords_push(target, x, y) != CORE_OK) {
+        coords_dispose(&add);
+        coords_dispose(&del);
+        coords_dispose(&mod);
+        free(overlay);
+        return CORE_ERROR_ALLOC;
+      }
+
+      /* Compose diff pixel (opacity 1.0) on top. */
+      blend_over(op, color->r, color->g, color->b, color->a, 1.0);
+    }
+  }
+
+  out->overlay = overlay;
+  out->addition_xy = add.data;
+  out->addition_count = add.count;
+  out->deletion_xy = del.data;
+  out->deletion_count = del.count;
+  out->modification_xy = mod.data;
+  out->modification_count = mod.count;
+  return CORE_OK;
+}

package/wasm/core.h

@@ -0,0 +1,69 @@
+#ifndef CORE_H
+#define CORE_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+  CORE_OK = 0,
+  CORE_ERROR_ALLOC = -1,
+  CORE_ERROR_INVALID = -2,
+};
+
+typedef struct {
+  uint8_t r;
+  uint8_t g;
+  uint8_t b;
+  uint8_t a;
+} CoreColor;
+
+typedef struct {
+  CoreColor addition;
+  CoreColor deletion;
+  CoreColor modification;
+} CorePallet;
+
+/*
+ * Output buffers are owned by the caller; release with core_result_free.
+ * On error, the struct is left zero-initialized and nothing needs freeing.
+ *
+ * `overlay`     : width * height * 4 bytes RGBA. Final overlay computed as
+ *                 alpha-over of (a * 0.2), (b * 0.2), and (diff layer * 1.0).
+ * `*_xy`        : packed [x0, y0, x1, y1, ...] int32 coordinates.
+ * `*_count`     : number of pixels (each pixel uses 2 int32 entries).
+ */
+typedef struct {
+  uint8_t *overlay;
+  int32_t *addition_xy;
+  int32_t addition_count;
+  int32_t *deletion_xy;
+  int32_t deletion_count;
+  int32_t *modification_xy;
+  int32_t modification_count;
+} CoreResult;
+
+/*
+ * Diff scan + diff-layer paint + final overlay compose, in a single pass.
+ *
+ * a_pixels, b_pixels: width * height * 4 bytes RGBA, identical dimensions.
+ * mask_pixels       : NULL, or width * height * 4 bytes RGBA. Pixels where
+ *                     mask alpha != 0 are excluded from the diff scan.
+ * pallet            : colors used to paint the diff layer per category.
+ * out               : populated with overlay + per-category coordinates.
+ *
+ * Returns CORE_OK on success, negative on error.
+ */
+int32_t process_page(const uint8_t *a_pixels, const uint8_t *b_pixels,
+                     const uint8_t *mask_pixels, int32_t width, int32_t height,
+                     const CorePallet *pallet, CoreResult *out);
+
+void core_result_free(CoreResult *r);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif