@u1f992/pdfdiff 0.2.2 → 0.3.1

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/tsconfig.json

@@ -1,50 +1,53 @@
-{
-  // Visit https://aka.ms/tsconfig to read more about this file
-  "compilerOptions": {
-    // File Layout
-    "rootDir": "./src",
-    "outDir": "./dist",
-
-    // Environment Settings
-    // See also https://aka.ms/tsconfig/module
-    "module": "esnext",
-    "target": "esnext",
-    // "types": [],
-    // For nodejs:
-    "lib": ["esnext", "WebWorker", "DOM"],
-    "types": ["node"],
-    // and npm install -D @types/node
-
-    // Other Outputs
-    "sourceMap": true,
-    "declaration": true,
-    "declarationMap": true,
-
-    // Stricter Typechecking Options
-    "noUncheckedIndexedAccess": true,
-    "exactOptionalPropertyTypes": true,
-
-    // Style Options
-    // "noImplicitReturns": true,
-    // "noImplicitOverride": true,
-    // "noUnusedLocals": true,
-    // "noUnusedParameters": true,
-    // "noFallthroughCasesInSwitch": true,
-    // "noPropertyAccessFromIndexSignature": true,
-
-    // Recommended Options
-    "strict": true,
-    "jsx": "react-jsx",
-    "verbatimModuleSyntax": true,
-    "isolatedModules": true,
-    "noUncheckedSideEffectImports": true,
-    "moduleDetection": "force",
-    "skipLibCheck": true,
-
-    // With Rollup
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "rewriteRelativeImportExtensions": true,
-    "noEmit": true
-  }
-}
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    // File Layout
+    "rootDir": "./src",
+    "outDir": "./dist",
+
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "esnext",
+    "target": "esnext",
+    // "types": [],
+    // For nodejs:
+    "lib": ["esnext", "WebWorker", "DOM"],
+    "types": ["node"],
+    // and npm install -D @types/node
+
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+
+    // With Rollup
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "noEmit": true
+  },
+  // Keep `tsc --noEmit` runnable as a type check: scripts/version.ts is run
+  // directly by node (type stripping) and lives outside rootDir.
+  "include": ["src"]
+}

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,179 @@
+#include "core.h"
+
+#include <math.h>
+#include <stdlib.h>
+
+#define COORD_INITIAL_CAPACITY 256
+
+/* Zero constant for CoreResult; assigning it replaces struct-zeroing memset,
+   which clang-tidy's insecureAPI check rejects. */
+static const CoreResult CORE_RESULT_ZERO = {0};
+
+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);
+  *r = CORE_RESULT_ZERO;
+}
+
+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;
+  }
+
+  *out = CORE_RESULT_ZERO;
+
+  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;
+}