@pilio/gemini-watermark-remover 1.0.19 → 1.0.21

package/src/sdk/index.d.ts

@@ -45,6 +45,31 @@ export interface WatermarkConfig {
     logoSize: number;
     marginRight: number;
     marginBottom: number;
+    alphaVariant?: string;
+}
+
+export interface WatermarkHaloMeta {
+    bandCount: number;
+    outerCount: number;
+    bandMeanLum: number;
+    outerMeanLum: number;
+    bandStdLum: number;
+    outerStdLum: number;
+    deltaLum: number;
+    positiveDeltaLum: number;
+    visibility: number;
+}
+
+export interface WatermarkResidualVisibilityMeta {
+    visible: boolean;
+    positiveHaloLum: number;
+    haloVisibility: number;
+    spatialResidual: number;
+    gradientResidual: number;
+    visiblePositiveHalo: boolean;
+    visibleGradientResidual: boolean;
+    visibleSpatialResidual: boolean;
+    halo?: WatermarkHaloMeta;
 }
 
 export interface WatermarkDetectionMeta {
@@ -54,6 +79,7 @@ export interface WatermarkDetectionMeta {
     processedSpatialScore: number | null;
     processedGradientScore: number | null;
     suppressionGain: number | null;
+    residualVisibility?: WatermarkResidualVisibilityMeta | null;
 }
 
 export interface WatermarkSelectionDebug {
@@ -91,10 +117,12 @@ export interface WatermarkMeta {
 
 export interface RemoveOptions {
     adaptiveMode?: 'auto' | 'always' | 'never' | 'off';
+    aggressiveLocatedFallback?: boolean;
+    locatedAggressiveRemoval?: boolean;
     engine?: WatermarkEngine;
     alpha48?: Float32Array;
     alpha96?: Float32Array;
-    getAlphaMap?: (size: number) => Float32Array;
+    getAlphaMap?: (size: number | string) => Float32Array;
 }
 
 export interface ImageDataRemovalResult {

package/src/sdk/node.d.ts

@@ -1,4 +1,11 @@
 import type { ImageDataRemovalResult, RemoveOptions, WatermarkMeta } from './index.js';
+export type {
+    VideoBufferRemovalOptions,
+    VideoBufferRemovalResult,
+    VideoFileRemovalOptions,
+    VideoFileRemovalResult,
+    VideoRemovalMeta
+} from './video.js';
 
 export interface NodeCodecContext {
     mimeType: string;
@@ -40,3 +47,9 @@ export function removeWatermarkFromFile(
     inputPath: string,
     options: NodeFileRemovalOptions
 ): Promise<NodeFileRemovalResult>;
+export {
+    inferVideoMimeTypeFromPath,
+    isVideoMimeType,
+    removeVideoWatermarkFromBuffer,
+    removeVideoWatermarkFromFile
+} from './video.js';

package/src/sdk/node.js

@@ -75,3 +75,10 @@ export async function removeWatermarkFromFile(inputPath, options = {}) {
         outputPath
     };
 }
+
+export {
+    inferVideoMimeTypeFromPath,
+    isVideoMimeType,
+    removeVideoWatermarkFromBuffer,
+    removeVideoWatermarkFromFile
+} from './video.js';

package/src/sdk/video.d.ts

@@ -0,0 +1,84 @@
+export interface VideoRemovalMeta {
+    status?: string;
+    denoiseBackend?: string;
+    actualDenoiseBackend?: string;
+    actualControls?: Record<string, unknown>;
+    pagePath?: string;
+    [key: string]: unknown;
+}
+
+export interface VideoFileProcessorContext {
+    outputPath?: string | null;
+    mimeType: string;
+    filePath: string;
+    pagePath?: string;
+    denoiseBackend?: string;
+    allowLowConfidence?: boolean;
+    timeoutMs?: number;
+    edgeDenoiseStrength?: number;
+    residualCleanupStrength?: number;
+    videoBitrate?: number;
+    adaptiveAlpha?: boolean;
+    alphaGain?: number;
+    alphaProfile?: string;
+}
+
+export interface VideoBufferProcessorContext extends Omit<VideoFileProcessorContext, 'filePath'> {
+    filePath?: string;
+}
+
+export interface VideoProcessorResult {
+    buffer?: Buffer | Uint8Array | ArrayBuffer;
+    meta?: VideoRemovalMeta | null;
+}
+
+export interface VideoFileRemovalOptions {
+    outputPath?: string | null;
+    mimeType?: string;
+    pagePath?: string;
+    denoiseBackend?: string;
+    allowLowConfidence?: boolean;
+    timeoutMs?: number;
+    edgeDenoiseStrength?: number;
+    residualCleanupStrength?: number;
+    videoBitrate?: number;
+    adaptiveAlpha?: boolean;
+    alphaGain?: number;
+    alphaProfile?: string;
+    processVideoFile?: (
+        inputPath: string,
+        context: VideoFileProcessorContext
+    ) => Promise<VideoProcessorResult> | VideoProcessorResult;
+}
+
+export interface VideoBufferRemovalOptions extends VideoBufferProcessorContext {
+    processVideoBuffer: (
+        inputBuffer: Buffer,
+        context: VideoBufferProcessorContext
+    ) => Promise<VideoProcessorResult> | VideoProcessorResult;
+}
+
+export interface VideoFileRemovalResult {
+    buffer: Buffer;
+    outputPath: string | null;
+    mimeType: string;
+    meta: VideoRemovalMeta | null;
+}
+
+export interface VideoBufferRemovalResult {
+    buffer: Buffer;
+    mimeType: string;
+    meta: VideoRemovalMeta | null;
+}
+
+export function inferVideoMimeTypeFromPath(filePath: string): string;
+export function isVideoMimeType(mimeType: string): boolean;
+export function removeVideoWatermarkFromFile(
+    inputPath: string,
+    options?: VideoFileRemovalOptions
+): Promise<VideoFileRemovalResult>;
+export function removeVideoWatermarkFromBuffer(
+    inputBuffer: Buffer | Uint8Array | ArrayBuffer,
+    options: VideoBufferRemovalOptions
+): Promise<VideoBufferRemovalResult>;
+

package/src/sdk/video.js

@@ -0,0 +1,263 @@
+import path from 'node:path';
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+
+const DEFAULT_VIDEO_DENOISE_BACKEND = 'allenk-fdncnn-browser-spike';
+const DEFAULT_VIDEO_TIMEOUT_MS = 6 * 60 * 1000;
+
+function normalizeBufferLike(value) {
+    if (Buffer.isBuffer(value)) return value;
+    if (value instanceof Uint8Array) return Buffer.from(value);
+    if (value instanceof ArrayBuffer) return Buffer.from(value);
+    throw new TypeError('Expected Buffer, Uint8Array, or ArrayBuffer');
+}
+
+function assertFunction(value, name) {
+    if (typeof value !== 'function') {
+        throw new TypeError(`${name} must be a function`);
+    }
+}
+
+function isHttpUrl(value) {
+    return /^https?:\/\//i.test(String(value || ''));
+}
+
+function resolveDefaultVideoPreviewPage() {
+    return path.resolve(process.cwd(), 'dist', 'video-preview.html');
+}
+
+async function assertReadableFile(filePath, label) {
+    try {
+        await access(filePath);
+    } catch (error) {
+        throw new Error(`${label} is unavailable: ${filePath}`, { cause: error });
+    }
+}
+
+export function inferVideoMimeTypeFromPath(filePath) {
+    const ext = path.extname(filePath || '').toLowerCase();
+    if (ext === '.mp4' || ext === '.m4v') return 'video/mp4';
+    if (ext === '.webm') return 'video/webm';
+    if (ext === '.mov') return 'video/quicktime';
+    return 'application/octet-stream';
+}
+
+export function isVideoMimeType(mimeType) {
+    return String(mimeType || '').toLowerCase().startsWith('video/');
+}
+
+async function setControlValue(page, selector, value) {
+    await page.evaluate(({ selector: targetSelector, value: targetValue }) => {
+        const control = document.querySelector(targetSelector);
+        if (!control) throw new Error(`Cannot find control: ${targetSelector}`);
+        control.value = String(targetValue);
+        control.dispatchEvent(new Event('input', { bubbles: true }));
+        control.dispatchEvent(new Event('change', { bubbles: true }));
+    }, { selector, value });
+}
+
+async function setCheckboxValue(page, selector, checked) {
+    await page.evaluate(({ selector: targetSelector, checked: targetChecked }) => {
+        const checkbox = document.querySelector(targetSelector);
+        if (!checkbox) throw new Error(`Cannot find control: ${targetSelector}`);
+        checkbox.checked = Boolean(targetChecked);
+        checkbox.dispatchEvent(new Event('input', { bubbles: true }));
+        checkbox.dispatchEvent(new Event('change', { bubbles: true }));
+    }, { selector, checked });
+}
+
+async function setNumericInputValue(page, selector, value) {
+    await page.evaluate(({ selector: targetSelector, value: targetValue }) => {
+        const input = document.querySelector(targetSelector);
+        if (!input) throw new Error(`Cannot find control: ${targetSelector}`);
+        if (input.hasAttribute('max') && Number(targetValue) > Number(input.getAttribute('max'))) {
+            input.setAttribute('max', String(targetValue));
+        }
+        input.value = String(targetValue);
+        input.dispatchEvent(new Event('input', { bubbles: true }));
+        input.dispatchEvent(new Event('change', { bubbles: true }));
+    }, { selector, value });
+}
+
+async function readDownloadBufferFromPage(page) {
+    const base64 = await page.evaluate(async () => {
+        const link = document.getElementById('downloadBtn');
+        if (!link?.href || link.getAttribute('aria-disabled') === 'true') {
+            throw new Error('Video export has no downloadable result');
+        }
+        const blob = await fetch(link.href).then((response) => response.blob());
+        const reader = new FileReader();
+        return await new Promise((resolve, reject) => {
+            reader.onerror = () => reject(reader.error);
+            reader.onload = () => {
+                const result = String(reader.result || '');
+                resolve(result.includes(',') ? result.split(',')[1] : result);
+            };
+            reader.readAsDataURL(blob);
+        });
+    });
+    return Buffer.from(base64, 'base64');
+}
+
+async function collectVideoControls(page) {
+    return page.evaluate(() => ({
+        denoiseBackend: document.getElementById('denoiseBackend')?.value || '',
+        edgeDenoiseStrength: Number(document.getElementById('edgeDenoiseStrength')?.value),
+        residualCleanupStrength: Number(document.getElementById('residualCleanup')?.value),
+        videoBitrateMbps: Number(document.getElementById('videoBitrateMbps')?.value),
+        allowLowConfidence: Boolean(document.getElementById('allowLowConfidence')?.checked)
+    }));
+}
+
+async function processVideoWithPreviewPage(inputPath, options = {}) {
+    const {
+        pagePath = resolveDefaultVideoPreviewPage(),
+        denoiseBackend = DEFAULT_VIDEO_DENOISE_BACKEND,
+        allowLowConfidence = false,
+        timeoutMs = DEFAULT_VIDEO_TIMEOUT_MS,
+        edgeDenoiseStrength,
+        residualCleanupStrength,
+        videoBitrate,
+        adaptiveAlpha = false,
+        alphaGain,
+        alphaProfile
+    } = options;
+
+    if (!isHttpUrl(pagePath)) {
+        await assertReadableFile(pagePath, 'Video preview page');
+    }
+
+    const { chromium } = await import('playwright').catch((error) => {
+        throw new Error('Video processing requires the optional "playwright" dependency', { cause: error });
+    });
+    const browser = await chromium.launch({ headless: true });
+    try {
+        const page = await browser.newPage();
+        page.setDefaultTimeout(timeoutMs);
+        await page.goto(isHttpUrl(pagePath) ? pagePath : pathToFileURL(pagePath).href);
+        await page.locator('#fileInput').setInputFiles(inputPath);
+        await setControlValue(page, '#denoiseBackend', denoiseBackend);
+
+        if (adaptiveAlpha) {
+            await setCheckboxValue(page, '#adaptiveAlpha', true);
+        }
+        if (allowLowConfidence) {
+            await page.evaluate(() => {
+                window.__gwrVideoOverrideAllowLowConfidence = true;
+            });
+            await setCheckboxValue(page, '#allowLowConfidence', true);
+        }
+        if (Number.isFinite(alphaGain) && alphaGain > 0) {
+            await setNumericInputValue(page, '#alphaGain', Math.max(0.25, Math.min(1.35, alphaGain)));
+        }
+        if (typeof alphaProfile === 'string' && alphaProfile) {
+            await page.evaluate((value) => {
+                window.__gwrVideoAlphaProfile = value;
+            }, alphaProfile);
+        }
+        if (Number.isFinite(edgeDenoiseStrength)) {
+            const value = Math.max(0, Math.min(3, edgeDenoiseStrength));
+            await page.evaluate((nextValue) => {
+                window.__gwrVideoOverrideEdgeDenoiseStrength = nextValue;
+            }, value);
+            await setNumericInputValue(page, '#edgeDenoiseStrength', value);
+        }
+        if (Number.isFinite(residualCleanupStrength)) {
+            const value = Math.max(0, Math.min(1.8, residualCleanupStrength));
+            await page.evaluate((nextValue) => {
+                window.__gwrVideoOverrideResidualCleanupStrength = nextValue;
+            }, value);
+            await setNumericInputValue(page, '#residualCleanup', value);
+        }
+        if (Number.isFinite(videoBitrate) && videoBitrate > 0) {
+            await setNumericInputValue(page, '#videoBitrateMbps', videoBitrate / 1000 / 1000);
+        }
+
+        await page.locator('#processBtn').click();
+        await page.waitForFunction(() => {
+            const status = document.getElementById('status');
+            return status?.dataset?.tone === 'success' || status?.dataset?.tone === 'error';
+        }, null, { timeout: timeoutMs });
+
+        const status = await page.locator('#status').textContent();
+        const tone = await page.locator('#status').getAttribute('data-tone');
+        if (tone !== 'success') {
+            throw new Error(status || 'Video export failed');
+        }
+
+        const controls = await collectVideoControls(page);
+        const buffer = await readDownloadBufferFromPage(page);
+        return {
+            buffer,
+            meta: {
+                status,
+                denoiseBackend,
+                actualDenoiseBackend: controls.denoiseBackend,
+                actualControls: controls,
+                pagePath
+            }
+        };
+    } finally {
+        await browser.close();
+    }
+}
+
+export async function removeVideoWatermarkFromFile(inputPath, options = {}) {
+    const {
+        outputPath = null,
+        mimeType = inferVideoMimeTypeFromPath(inputPath),
+        processVideoFile = null,
+        ...videoOptions
+    } = options;
+
+    if (processVideoFile !== null) {
+        assertFunction(processVideoFile, 'processVideoFile');
+        const customResult = await processVideoFile(inputPath, {
+            ...videoOptions,
+            outputPath,
+            mimeType,
+            filePath: inputPath
+        });
+        const buffer = customResult?.buffer
+            ? normalizeBufferLike(customResult.buffer)
+            : outputPath
+                ? await readFile(outputPath)
+                : null;
+        if (!buffer) {
+            throw new Error('processVideoFile must return a buffer or write outputPath');
+        }
+        if (outputPath && customResult?.buffer) {
+            await mkdir(path.dirname(outputPath), { recursive: true });
+            await writeFile(outputPath, buffer);
+        }
+        return {
+            buffer,
+            outputPath,
+            mimeType,
+            meta: customResult?.meta ?? null
+        };
+    }
+
+    const result = await processVideoWithPreviewPage(inputPath, videoOptions);
+    if (outputPath) {
+        await mkdir(path.dirname(outputPath), { recursive: true });
+        await writeFile(outputPath, result.buffer);
+    }
+    return {
+        buffer: result.buffer,
+        outputPath,
+        mimeType,
+        meta: result.meta
+    };
+}
+
+export async function removeVideoWatermarkFromBuffer(inputBuffer, options = {}) {
+    const { processVideoBuffer = null, ...videoOptions } = options;
+    assertFunction(processVideoBuffer, 'processVideoBuffer');
+    const result = await processVideoBuffer(normalizeBufferLike(inputBuffer), videoOptions);
+    return {
+        buffer: normalizeBufferLike(result?.buffer),
+        mimeType: videoOptions.mimeType || 'video/mp4',
+        meta: result?.meta ?? null
+    };
+}

package/src/shared/debugFileHandoff.js

@@ -0,0 +1,109 @@
+const DB_NAME = 'gwr-debug-file-handoff';
+const DB_VERSION = 1;
+const STORE_NAME = 'files';
+const LATEST_KEY = 'latest';
+
+const IMAGE_TYPES = new Set(['image/jpeg', 'image/png', 'image/webp']);
+const IMAGE_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.webp']);
+const VIDEO_EXTENSIONS = new Set(['.mp4', '.webm', '.mov', '.m4v']);
+
+function getFileExtension(file) {
+    const name = typeof file?.name === 'string' ? file.name.toLowerCase() : '';
+    const dotIndex = name.lastIndexOf('.');
+    return dotIndex >= 0 ? name.slice(dotIndex) : '';
+}
+
+export function getDebugFileKind(file) {
+    if (!file) return null;
+
+    const type = typeof file.type === 'string' ? file.type.toLowerCase() : '';
+    const extension = getFileExtension(file);
+
+    if (type.startsWith('video/') || VIDEO_EXTENSIONS.has(extension)) {
+        return 'video';
+    }
+    if (IMAGE_TYPES.has(type) || IMAGE_EXTENSIONS.has(extension)) {
+        return 'image';
+    }
+    return null;
+}
+
+export function pickDebugUploadFile(files) {
+    const list = Array.from(files || []).filter(Boolean);
+    return (
+        list.find((file) => getDebugFileKind(file) === 'video')
+        || list.find((file) => getDebugFileKind(file) === 'image')
+        || null
+    );
+}
+
+function openHandoffDb() {
+    return new Promise((resolve, reject) => {
+        const indexedDb = globalThis.indexedDB;
+        if (!indexedDb) {
+            reject(new Error('当前浏览器不支持本地文件暂存，请直接打开目标调试页后重新选择文件。'));
+            return;
+        }
+
+        const request = indexedDb.open(DB_NAME, DB_VERSION);
+        request.onupgradeneeded = () => {
+            const db = request.result;
+            if (!db.objectStoreNames.contains(STORE_NAME)) {
+                db.createObjectStore(STORE_NAME, { keyPath: 'id' });
+            }
+        };
+        request.onerror = () => reject(request.error || new Error('无法打开本地文件暂存。'));
+        request.onsuccess = () => resolve(request.result);
+    });
+}
+
+export async function saveDebugFileHandoff(file, targetKind = getDebugFileKind(file)) {
+    if (!file || !targetKind) {
+        throw new Error('不支持的文件类型。');
+    }
+
+    const record = {
+        id: LATEST_KEY,
+        kind: targetKind,
+        file,
+        name: file.name || '',
+        type: file.type || '',
+        size: Number.isFinite(file.size) ? file.size : 0,
+        updatedAt: Date.now()
+    };
+
+    const db = await openHandoffDb();
+    await new Promise((resolve, reject) => {
+        const transaction = db.transaction(STORE_NAME, 'readwrite');
+        transaction.objectStore(STORE_NAME).put(record);
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error || new Error('本地文件暂存失败。'));
+        transaction.onabort = () => reject(transaction.error || new Error('本地文件暂存已取消。'));
+    }).finally(() => db.close());
+    return record;
+}
+
+export async function consumeDebugFileHandoff(expectedKind = null) {
+    const db = await openHandoffDb();
+    let matchedRecord = null;
+
+    await new Promise((resolve, reject) => {
+        const transaction = db.transaction(STORE_NAME, 'readwrite');
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.get(LATEST_KEY);
+
+        request.onsuccess = () => {
+            const record = request.result || null;
+            if (record && (!expectedKind || record.kind === expectedKind)) {
+                matchedRecord = record;
+                store.delete(LATEST_KEY);
+            }
+        };
+        request.onerror = () => reject(request.error || new Error('读取本地文件暂存失败。'));
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error || new Error('读取本地文件暂存失败。'));
+        transaction.onabort = () => reject(transaction.error || new Error('读取本地文件暂存已取消。'));
+    }).finally(() => db.close());
+
+    return matchedRecord;
+}