Upload 19 files

tests/bch.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest';
+import { BchCodec } from '../core/bch.js';
+
+describe('BCH', () => {
+  const bch63 = new BchCodec({ n: 63, k: 36, t: 5, m: 6 });
+
+  it('should encode and decode without errors (63,36,5)', () => {
+    const message = new Uint8Array(36);
+    for (let i = 0; i < 36; i++) message[i] = Math.random() > 0.5 ? 1 : 0;
+
+    const codeword = bch63.encode(message);
+    expect(codeword.length).toBe(63);
+
+    const decoded = bch63.decode(codeword);
+    expect(decoded).not.toBeNull();
+    expect(Array.from(decoded!)).toEqual(Array.from(message));
+  });
+
+  it('should correct up to t=5 errors (63,36,5)', () => {
+    const message = new Uint8Array(36);
+    for (let i = 0; i < 36; i++) message[i] = Math.random() > 0.5 ? 1 : 0;
+
+    const codeword = bch63.encode(message);
+
+    // Introduce 5 errors at random positions
+    const errorPositions = new Set<number>();
+    while (errorPositions.size < 5) {
+      errorPositions.add(Math.floor(Math.random() * 63));
+    }
+    const corrupted = new Uint8Array(codeword);
+    for (const pos of errorPositions) {
+      corrupted[pos] ^= 1;
+    }
+
+    const decoded = bch63.decode(corrupted);
+    expect(decoded).not.toBeNull();
+    expect(Array.from(decoded!)).toEqual(Array.from(message));
+  });
+
+  it('should handle zero message', () => {
+    const message = new Uint8Array(36); // all zeros
+    const codeword = bch63.encode(message);
+    const decoded = bch63.decode(codeword);
+    expect(decoded).not.toBeNull();
+    expect(Array.from(decoded!)).toEqual(Array.from(message));
+  });
+});

tests/crc.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { crcAppend, crcVerify } from '../core/crc.js';
+
+describe('CRC', () => {
+  for (const bits of [4, 8, 16] as const) {
+    it(`should append and verify CRC-${bits}`, () => {
+      const data = new Uint8Array(32);
+      for (let i = 0; i < 32; i++) data[i] = Math.random() > 0.5 ? 1 : 0;
+
+      const withCrc = crcAppend(data, bits);
+      expect(withCrc.length).toBe(32 + bits);
+
+      const verified = crcVerify(withCrc, bits);
+      expect(verified).not.toBeNull();
+      expect(Array.from(verified!)).toEqual(Array.from(data));
+    });
+
+    it(`should reject corrupted data with CRC-${bits}`, () => {
+      const data = new Uint8Array(32);
+      for (let i = 0; i < 32; i++) data[i] = Math.random() > 0.5 ? 1 : 0;
+
+      const withCrc = crcAppend(data, bits);
+      // Flip a bit in the data
+      withCrc[5] ^= 1;
+
+      const verified = crcVerify(withCrc, bits);
+      expect(verified).toBeNull();
+    });
+  }
+});

tests/dct.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { dctForward8x8, dctInverse8x8 } from '../core/dct.js';
+
+describe('DCT', () => {
+  it('should round-trip an 8x8 block', () => {
+    const block = new Float64Array(64);
+    for (let i = 0; i < 64; i++) {
+      block[i] = Math.random() * 255;
+    }
+    const original = new Float64Array(block);
+
+    dctForward8x8(block);
+    dctInverse8x8(block);
+
+    for (let i = 0; i < 64; i++) {
+      expect(block[i]).toBeCloseTo(original[i], 6);
+    }
+  });
+
+  it('should produce DC coefficient as mean of block', () => {
+    const block = new Float64Array(64);
+    let sum = 0;
+    for (let i = 0; i < 64; i++) {
+      block[i] = 100 + Math.random() * 10;
+      sum += block[i];
+    }
+    const mean = sum / 64;
+
+    dctForward8x8(block);
+
+    // DC coefficient should be proportional to the mean
+    // DC = alpha(0) * alpha(0) * sum = (1/8) * sum = mean * 8 * (1/8) = mean * sqrt(64)/...
+    // Actually: DC = (1/sqrt(8)) * (1/sqrt(8)) * sum(block) = sum/8
+    expect(block[0]).toBeCloseTo(sum / 8, 4);
+  });
+});

tests/dmqim.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from 'vitest';
+import { dmqimEmbed, dmqimExtractSoft, dmqimExtractHard } from '../core/dmqim.js';
+
+describe('DM-QIM', () => {
+  it('should embed and extract bit 0 correctly', () => {
+    const coeff = 42.5;
+    const delta = 10;
+    const dither = 3.7;
+
+    const embedded = dmqimEmbed(coeff, 0, delta, dither);
+    const hard = dmqimExtractHard(embedded, delta, dither);
+    expect(hard).toBe(0);
+  });
+
+  it('should embed and extract bit 1 correctly', () => {
+    const coeff = 42.5;
+    const delta = 10;
+    const dither = 3.7;
+
+    const embedded = dmqimEmbed(coeff, 1, delta, dither);
+    const hard = dmqimExtractHard(embedded, delta, dither);
+    expect(hard).toBe(1);
+  });
+
+  it('should produce correct soft decisions', () => {
+    const delta = 20;
+    const dither = 5.0;
+
+    for (let bit = 0; bit <= 1; bit++) {
+      const embedded = dmqimEmbed(50, bit, delta, dither);
+      const soft = dmqimExtractSoft(embedded, delta, dither);
+
+      if (bit === 1) {
+        expect(soft).toBeGreaterThan(0);
+      } else {
+        expect(soft).toBeLessThanOrEqual(0);
+      }
+    }
+  });
+
+  it('should work with various coefficient values and dithers', () => {
+    const delta = 15;
+    for (let trial = 0; trial < 100; trial++) {
+      const coeff = (Math.random() - 0.5) * 200;
+      const dither = (Math.random() - 0.5) * delta;
+      const bit = Math.random() > 0.5 ? 1 : 0;
+
+      const embedded = dmqimEmbed(coeff, bit, delta, dither);
+      const extracted = dmqimExtractHard(embedded, delta, dither);
+      expect(extracted).toBe(bit);
+    }
+  });
+});

tests/dwt.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest';
+import { createBuffer2D, dwtForward, dwtInverse, yPlaneToBuffer, bufferToYPlane } from '../core/dwt.js';
+
+describe('DWT', () => {
+  it('should round-trip a simple buffer (1 level)', () => {
+    const width = 16;
+    const height = 16;
+    const buf = createBuffer2D(width, height);
+    for (let i = 0; i < buf.data.length; i++) {
+      buf.data[i] = Math.round(Math.random() * 255);
+    }
+    const original = new Float64Array(buf.data);
+
+    const { buf: transformed, dims } = dwtForward(buf, 1);
+    dwtInverse(transformed, dims);
+
+    for (let i = 0; i < original.length; i++) {
+      expect(transformed.data[i]).toBeCloseTo(original[i], 8);
+    }
+  });
+
+  it('should round-trip a buffer (2 levels)', () => {
+    const width = 64;
+    const height = 64;
+    const buf = createBuffer2D(width, height);
+    for (let i = 0; i < buf.data.length; i++) {
+      buf.data[i] = Math.round(Math.random() * 255);
+    }
+    const original = new Float64Array(buf.data);
+
+    const { buf: transformed, dims } = dwtForward(buf, 2);
+    dwtInverse(transformed, dims);
+
+    for (let i = 0; i < original.length; i++) {
+      expect(transformed.data[i]).toBeCloseTo(original[i], 8);
+    }
+  });
+
+  it('should convert Y plane to buffer and back', () => {
+    const width = 32;
+    const height = 32;
+    const yPlane = new Uint8Array(width * height);
+    for (let i = 0; i < yPlane.length; i++) {
+      yPlane[i] = Math.floor(Math.random() * 256);
+    }
+
+    const buf = yPlaneToBuffer(yPlane, width, height);
+    const result = bufferToYPlane(buf);
+
+    expect(result).toEqual(yPlane);
+  });
+});

tests/roundtrip.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect } from 'vitest';
+import { embedWatermark } from '../core/embedder.js';
+import { detectWatermark, detectWatermarkMultiFrame } from '../core/detector.js';
+import { getPreset } from '../core/presets.js';
+import type { PresetName } from '../core/types.js';
+
+/**
+ * Crop a Y plane by removing pixels from the edges.
+ */
+function cropYPlane(
+  yPlane: Uint8Array,
+  width: number,
+  height: number,
+  left: number,
+  top: number,
+  right: number,
+  bottom: number,
+): { cropped: Uint8Array; croppedW: number; croppedH: number } {
+  const croppedW = width - left - right;
+  const croppedH = height - top - bottom;
+  const cropped = new Uint8Array(croppedW * croppedH);
+  for (let y = 0; y < croppedH; y++) {
+    for (let x = 0; x < croppedW; x++) {
+      cropped[y * croppedW + x] = yPlane[(y + top) * width + (x + left)];
+    }
+  }
+  return { cropped, croppedW, croppedH };
+}
+
+/**
+ * Generate a synthetic Y plane (gradient + noise)
+ */
+function generateTestFrame(width: number, height: number): Uint8Array {
+  const frame = new Uint8Array(width * height);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const gradient = ((x + y) / (width + height)) * 200 + 20;
+      const noise = (Math.random() - 0.5) * 20;
+      frame[y * width + x] = Math.max(0, Math.min(255, Math.round(gradient + noise)));
+    }
+  }
+  return frame;
+}
+
+describe('Embed → Detect Round-trip', () => {
+  const width = 512;
+  const height = 512;
+  const payload = new Uint8Array([0xDE, 0xAD, 0xBE, 0xEF]);
+  const key = 'test-secret-key-2024';
+
+  // Test the presets that should work with a 512x512 frame
+  for (const presetName of ['light', 'moderate', 'strong'] as PresetName[]) {
+    it(`should round-trip with ${presetName} preset`, () => {
+      const config = getPreset(presetName);
+      const frame = generateTestFrame(width, height);
+
+      // Embed
+      const embedResult = embedWatermark(frame, width, height, payload, key, config);
+      expect(embedResult.psnr).toBeGreaterThan(15); // Higher presets sacrifice invisibility for robustness
+
+      // Detect
+      const detectResult = detectWatermark(embedResult.yPlane, width, height, key, config);
+      expect(detectResult.detected).toBe(true);
+      expect(detectResult.payload).not.toBeNull();
+      expect(Array.from(detectResult.payload!)).toEqual(Array.from(payload));
+    });
+  }
+
+  it('should not detect watermark with wrong key', () => {
+    const config = getPreset('moderate');
+    const frame = generateTestFrame(width, height);
+
+    const embedResult = embedWatermark(frame, width, height, payload, key, config);
+
+    const detectResult = detectWatermark(embedResult.yPlane, width, height, 'wrong-key', config);
+    expect(detectResult.detected).toBe(false);
+  });
+
+  it('should not detect watermark on unwatermarked frame', () => {
+    const config = getPreset('moderate');
+    const frame = generateTestFrame(width, height);
+
+    const detectResult = detectWatermark(frame, width, height, key, config);
+    expect(detectResult.detected).toBe(false);
+  });
+});
+
+describe('Crop-resilient detection', () => {
+  const width = 512;
+  const height = 512;
+  const payload = new Uint8Array([0xDE, 0xAD, 0xBE, 0xEF]);
+  const key = 'test-secret-key-2024';
+
+  it('should detect after arbitrary crop with multiple frames', () => {
+    const config = getPreset('strong');
+    // Generate multiple distinct frames (simulating video — at least 32 frames)
+    const frames: Uint8Array[] = [];
+    for (let i = 0; i < 32; i++) {
+      const frame = generateTestFrame(width, height);
+      const embedResult = embedWatermark(frame, width, height, payload, key, config);
+      // Crop by arbitrary offset (breaks DWT pixel pairing)
+      const { cropped } = cropYPlane(
+        embedResult.yPlane, width, height, 7, 3, 5, 9
+      );
+      frames.push(cropped);
+    }
+    const croppedW = width - 7 - 5;
+    const croppedH = height - 3 - 9;
+
+    const detectResult = detectWatermarkMultiFrame(
+      frames, croppedW, croppedH, key, config, { cropResilient: true }
+    );
+    expect(detectResult.detected).toBe(true);
+    expect(detectResult.payload).not.toBeNull();
+    expect(Array.from(detectResult.payload!)).toEqual(Array.from(payload));
+  });
+
+  it('should detect after large crop with multiple frames', () => {
+    const config = getPreset('strong');
+    const frames: Uint8Array[] = [];
+    for (let i = 0; i < 32; i++) {
+      const frame = generateTestFrame(width, height);
+      const embedResult = embedWatermark(frame, width, height, payload, key, config);
+      const { cropped } = cropYPlane(
+        embedResult.yPlane, width, height, 50, 50, 50, 50
+      );
+      frames.push(cropped);
+    }
+    const croppedW = width - 100;
+    const croppedH = height - 100;
+
+    const detectResult = detectWatermarkMultiFrame(
+      frames, croppedW, croppedH, key, config, { cropResilient: true }
+    );
+    expect(detectResult.detected).toBe(true);
+    expect(detectResult.payload).not.toBeNull();
+    expect(Array.from(detectResult.payload!)).toEqual(Array.from(payload));
+  });
+});