@doedja/scenecut 1.0.0

package/dist/keyframes.cjs.js

@@ -0,0 +1,985 @@
+'use strict';
+
+var ffmpeg = require('fluent-ffmpeg');
+var ffmpegInstaller = require('@ffmpeg-installer/ffmpeg');
+var path = require('path');
+var fs = require('fs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var ffmpeg__namespace = /*#__PURE__*/_interopNamespaceDefault(ffmpeg);
+var ffmpegInstaller__namespace = /*#__PURE__*/_interopNamespaceDefault(ffmpegInstaller);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+
+/**
+ * Buffer Pool - Memory management for frame buffers
+ *
+ * Reuses TypedArray buffers to reduce memory allocation and GC pressure
+ */
+class BufferPool {
+    /**
+     * Create a new buffer pool
+     *
+     * @param maxPoolSize Maximum number of buffers to keep per size (default: 4)
+     */
+    constructor(maxPoolSize = 4) {
+        this.pool = new Map();
+        this.maxPoolSize = maxPoolSize;
+    }
+    /**
+     * Acquire a buffer of the specified size
+     *
+     * @param size Buffer size in bytes
+     * @returns Uint8Array buffer
+     */
+    acquire(size) {
+        const poolForSize = this.pool.get(size);
+        if (poolForSize && poolForSize.length > 0) {
+            const buffer = poolForSize.pop();
+            // Clear the buffer before reuse
+            buffer.fill(0);
+            return buffer;
+        }
+        // No buffer available, allocate new one
+        return new Uint8Array(size);
+    }
+    /**
+     * Release a buffer back to the pool
+     *
+     * @param buffer Buffer to release
+     */
+    release(buffer) {
+        const size = buffer.length;
+        let poolForSize = this.pool.get(size);
+        if (!poolForSize) {
+            poolForSize = [];
+            this.pool.set(size, poolForSize);
+        }
+        // Only keep buffer if pool not full
+        if (poolForSize.length < this.maxPoolSize) {
+            poolForSize.push(buffer);
+        }
+        // Otherwise, let it be garbage collected
+    }
+    /**
+     * Get pool statistics
+     */
+    getStats() {
+        const stats = [];
+        for (const [size, buffers] of this.pool.entries()) {
+            stats.push({
+                size,
+                count: buffers.length
+            });
+        }
+        return stats.sort((a, b) => b.size - a.size);
+    }
+    /**
+     * Clear all pooled buffers
+     */
+    clear() {
+        this.pool.clear();
+    }
+    /**
+     * Get total memory used by pooled buffers
+     */
+    getTotalMemory() {
+        let total = 0;
+        for (const [size, buffers] of this.pool.entries()) {
+            total += size * buffers.length;
+        }
+        return total;
+    }
+}
+
+/**
+ * Frame Buffer - Circular buffer for frame management
+ *
+ * Maintains a circular buffer of frames for efficient scene detection
+ * Typically only needs to hold 2 frames (previous and current)
+ */
+class FrameBuffer {
+    /**
+     * Create a new frame buffer
+     *
+     * @param maxFrames Maximum number of frames to buffer (default: 2)
+     * @param bufferPool Optional buffer pool for memory reuse
+     */
+    constructor(maxFrames = 2, bufferPool) {
+        this.currentIndex = 0;
+        this.maxFrames = maxFrames;
+        this.bufferPool = bufferPool || new BufferPool();
+        this.frames = new Array(maxFrames).fill(null);
+    }
+    /**
+     * Push a new frame into the buffer
+     *
+     * @param frame Frame to push
+     * @returns The frame that was evicted, if any
+     */
+    push(frame) {
+        const evictedFrame = this.frames[this.currentIndex];
+        // Release the evicted frame's buffer back to pool
+        if (evictedFrame) {
+            this.bufferPool.release(evictedFrame.data);
+        }
+        // Store the new frame
+        this.frames[this.currentIndex] = frame;
+        // Move to next position
+        this.currentIndex = (this.currentIndex + 1) % this.maxFrames;
+        return evictedFrame;
+    }
+    /**
+     * Get frame at specific offset from current position
+     *
+     * @param offset Offset from current position (0 = most recent, 1 = previous, etc.)
+     * @returns Frame or null if not available
+     */
+    get(offset = 0) {
+        if (offset < 0 || offset >= this.maxFrames) {
+            return null;
+        }
+        const index = (this.currentIndex - 1 - offset + this.maxFrames) % this.maxFrames;
+        return this.frames[index];
+    }
+    /**
+     * Get the most recent frame
+     */
+    getCurrent() {
+        return this.get(0);
+    }
+    /**
+     * Get the previous frame
+     */
+    getPrevious() {
+        return this.get(1);
+    }
+    /**
+     * Get both current and previous frames
+     *
+     * @returns [current, previous] or null if either is not available
+     */
+    getCurrentAndPrevious() {
+        const current = this.getCurrent();
+        const previous = this.getPrevious();
+        if (!current || !previous) {
+            return null;
+        }
+        return [current, previous];
+    }
+    /**
+     * Allocate a buffer for a new frame
+     *
+     * @param size Buffer size in bytes
+     * @returns Uint8Array buffer
+     */
+    allocateBuffer(size) {
+        return this.bufferPool.acquire(size);
+    }
+    /**
+     * Clear all frames from the buffer
+     */
+    clear() {
+        // Release all buffers back to pool
+        for (const frame of this.frames) {
+            if (frame) {
+                this.bufferPool.release(frame.data);
+            }
+        }
+        this.frames = new Array(this.maxFrames).fill(null);
+        this.currentIndex = 0;
+    }
+    /**
+     * Get the number of frames currently in the buffer
+     */
+    size() {
+        return this.frames.filter(f => f !== null).length;
+    }
+    /**
+     * Check if buffer is full
+     */
+    isFull() {
+        return this.size() === this.maxFrames;
+    }
+    /**
+     * Get buffer statistics
+     */
+    getStats() {
+        return {
+            maxFrames: this.maxFrames,
+            currentFrames: this.size(),
+            bufferPoolStats: this.bufferPool.getStats(),
+            totalPoolMemory: this.bufferPool.getTotalMemory()
+        };
+    }
+}
+
+/**
+ * FFmpeg Decoder - Extract frames from video files
+ *
+ * Uses fluent-ffmpeg to extract grayscale frames for scene detection
+ */
+// Set FFmpeg path from installer
+ffmpeg__namespace.setFfmpegPath(ffmpegInstaller__namespace.path);
+/**
+ * Ring Buffer - Fixed-size circular buffer for streaming data
+ * Eliminates repeated Buffer.concat() allocations and GC pressure
+ */
+class RingBuffer {
+    constructor(size = 8 * 1024 * 1024) {
+        this.writePos = 0;
+        this.readPos = 0;
+        this.availableBytes = 0;
+        this.buffer = Buffer.allocUnsafe(size);
+        this.capacity = size;
+    }
+    /**
+     * Write data to the ring buffer
+     */
+    write(chunk) {
+        const chunkSize = chunk.length;
+        if (chunkSize > this.capacity - this.availableBytes) {
+            throw new Error('RingBuffer overflow: chunk too large for available space');
+        }
+        // Write in two parts if wrapping around
+        const endSpace = this.capacity - this.writePos;
+        if (chunkSize <= endSpace) {
+            // No wrap-around needed
+            chunk.copy(this.buffer, this.writePos);
+            this.writePos += chunkSize;
+        }
+        else {
+            // Wrap-around: split write
+            chunk.copy(this.buffer, this.writePos, 0, endSpace);
+            chunk.copy(this.buffer, 0, endSpace, chunkSize);
+            this.writePos = chunkSize - endSpace;
+        }
+        // Wrap write position if at end
+        if (this.writePos >= this.capacity) {
+            this.writePos = 0;
+        }
+        this.availableBytes += chunkSize;
+    }
+    /**
+     * Read data from the ring buffer
+     */
+    read(size) {
+        if (size > this.availableBytes) {
+            throw new Error('RingBuffer underflow: not enough data available');
+        }
+        const result = Buffer.allocUnsafe(size);
+        const endSpace = this.capacity - this.readPos;
+        if (size <= endSpace) {
+            // No wrap-around needed
+            this.buffer.copy(result, 0, this.readPos, this.readPos + size);
+            this.readPos += size;
+        }
+        else {
+            // Wrap-around: split read
+            this.buffer.copy(result, 0, this.readPos, this.capacity);
+            this.buffer.copy(result, endSpace, 0, size - endSpace);
+            this.readPos = size - endSpace;
+        }
+        // Wrap read position if at end
+        if (this.readPos >= this.capacity) {
+            this.readPos = 0;
+        }
+        this.availableBytes -= size;
+        return result;
+    }
+    /**
+     * Get number of bytes available to read
+     */
+    available() {
+        return this.availableBytes;
+    }
+    /**
+     * Reset the ring buffer
+     */
+    reset() {
+        this.writePos = 0;
+        this.readPos = 0;
+        this.availableBytes = 0;
+    }
+}
+class FFmpegDecoder {
+    constructor(videoPath, options = {}) {
+        this.metadata = null;
+        this.videoPath = videoPath;
+        this.options = {
+            pixelFormat: options.pixelFormat || 'gray',
+            maxBufferFrames: options.maxBufferFrames || 2,
+            skipFrames: options.skipFrames || 0
+        };
+        this.frameBuffer = new FrameBuffer(this.options.maxBufferFrames);
+    }
+    /**
+     * Get video metadata
+     */
+    async getMetadata() {
+        if (this.metadata) {
+            return this.metadata;
+        }
+        return new Promise((resolve, reject) => {
+            ffmpeg__namespace.ffprobe(this.videoPath, (err, metadata) => {
+                if (err) {
+                    reject(new Error(`Failed to read video metadata: ${err.message}`));
+                    return;
+                }
+                const videoStream = metadata.streams.find(s => s.codec_type === 'video');
+                if (!videoStream) {
+                    reject(new Error('No video stream found'));
+                    return;
+                }
+                const fps = this.parseFps(videoStream.r_frame_rate || videoStream.avg_frame_rate || '30/1');
+                const duration = parseFloat(String(metadata.format.duration || 0));
+                const totalFrames = Math.floor(duration * fps);
+                this.metadata = {
+                    totalFrames,
+                    duration,
+                    fps,
+                    resolution: {
+                        width: videoStream.width || 0,
+                        height: videoStream.height || 0
+                    }
+                };
+                resolve(this.metadata);
+            });
+        });
+    }
+    /**
+     * Parse frame rate from FFmpeg format (e.g., "30000/1001")
+     */
+    parseFps(fpsString) {
+        const parts = fpsString.split('/');
+        if (parts.length === 2) {
+            return parseInt(parts[0]) / parseInt(parts[1]);
+        }
+        return parseFloat(fpsString);
+    }
+    /**
+     * Extract frames as grayscale data
+     *
+     * @param onFrame Callback for each frame
+     * @param onProgress Optional progress callback
+     */
+    async extractFrames(onFrame, onProgress) {
+        const metadata = await this.getMetadata();
+        const { width, height } = metadata.resolution;
+        return new Promise((resolve, reject) => {
+            let frameNumber = 0;
+            const ringBuffer = new RingBuffer(); // 8MB ring buffer
+            const frameSize = width * height; // Grayscale: 1 byte per pixel
+            const command = ffmpeg__namespace.default(this.videoPath)
+                .outputOptions([
+                '-f', 'image2pipe',
+                '-pix_fmt', 'gray',
+                '-vcodec', 'rawvideo'
+            ])
+                .on('error', (err) => {
+                reject(new Error(`FFmpeg error: ${err.message}`));
+            })
+                .on('end', () => {
+                resolve();
+            });
+            const stream = command.pipe();
+            stream.on('data', async (chunk) => {
+                // Write chunk to ring buffer (no allocation, no copying)
+                ringBuffer.write(chunk);
+                // Process complete frames
+                while (ringBuffer.available() >= frameSize) {
+                    const frameData = ringBuffer.read(frameSize);
+                    // Skip frames if requested
+                    if (this.options.skipFrames > 0 && frameNumber % (this.options.skipFrames + 1) !== 0) {
+                        frameNumber++;
+                        continue;
+                    }
+                    // Create RawFrame
+                    const frame = {
+                        data: new Uint8Array(frameData),
+                        width,
+                        height,
+                        stride: width,
+                        pts: frameNumber / metadata.fps,
+                        frameNumber
+                    };
+                    // Call callback
+                    try {
+                        await onFrame(frame);
+                    }
+                    catch (err) {
+                        stream.destroy();
+                        reject(err);
+                        return;
+                    }
+                    // Progress callback
+                    if (onProgress && frameNumber % 30 === 0) {
+                        onProgress(frameNumber, metadata.totalFrames);
+                    }
+                    frameNumber++;
+                }
+            });
+            stream.on('error', (err) => {
+                reject(new Error(`Stream error: ${err.message}`));
+            });
+        });
+    }
+    /**
+     * Extract a single frame at specific frame number
+     */
+    async extractFrame(frameNumber) {
+        const metadata = await this.getMetadata();
+        const { width, height } = metadata.resolution;
+        const timestamp = frameNumber / metadata.fps;
+        return new Promise((resolve, reject) => {
+            const ringBuffer = new RingBuffer();
+            const frameSize = width * height;
+            const command = ffmpeg__namespace.default(this.videoPath)
+                .seekInput(timestamp)
+                .outputOptions([
+                '-vframes', '1',
+                '-f', 'image2pipe',
+                '-pix_fmt', 'gray',
+                '-vcodec', 'rawvideo'
+            ])
+                .on('error', (err) => {
+                reject(new Error(`FFmpeg error: ${err.message}`));
+            });
+            const stream = command.pipe();
+            stream.on('data', (chunk) => {
+                ringBuffer.write(chunk);
+                if (ringBuffer.available() >= frameSize) {
+                    const frameData = ringBuffer.read(frameSize);
+                    const frame = {
+                        data: new Uint8Array(frameData),
+                        width,
+                        height,
+                        stride: width,
+                        pts: timestamp,
+                        frameNumber
+                    };
+                    resolve(frame);
+                }
+            });
+            stream.on('error', (err) => {
+                reject(new Error(`Stream error: ${err.message}`));
+            });
+        });
+    }
+    /**
+     * Get the frame buffer
+     */
+    getFrameBuffer() {
+        return this.frameBuffer;
+    }
+    /**
+     * Clean up resources
+     */
+    destroy() {
+        this.frameBuffer.clear();
+    }
+}
+
+/**
+ * WASM Bridge - Interface between JavaScript and WebAssembly
+ *
+ * This module handles:
+ * - Loading the WASM module
+ * - Memory allocation and management
+ * - Calling WASM functions
+ * - Data marshalling between JS and WASM
+ */
+class WasmBridge {
+    constructor() {
+        this.module = null;
+        this.initialized = false;
+        // Pre-allocated WASM buffers for frame processing
+        this.prevFramePtr = 0; // Raw previous frame
+        this.curFramePtr = 0; // Raw current frame
+        this.prevPaddedPtr = 0; // Padded previous frame
+        this.curPaddedPtr = 0; // Padded current frame
+        this.allocatedFrameSize = 0; // Size of raw frame buffers
+        this.allocatedPaddedSize = 0; // Size of padded frame buffers
+    }
+    /**
+     * Initialize the WASM module
+     */
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        try {
+            // Load the WASM module
+            const wasmPath = path__namespace.join(__dirname, '../dist/detection.wasm.js');
+            if (!fs__namespace.existsSync(wasmPath)) {
+                throw new Error(`WASM module not found at ${wasmPath}. ` +
+                    `Please run 'npm run build:wasm' to compile the WASM module.`);
+            }
+            // Dynamic import the WASM module
+            const createWasmModule = require(wasmPath);
+            this.module = await createWasmModule();
+            this.initialized = true;
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize WASM module: ${error}`);
+        }
+    }
+    /**
+     * Ensure the WASM module is initialized
+     */
+    ensureInitialized() {
+        if (!this.initialized || !this.module) {
+            throw new Error('WASM module not initialized. Call init() first.');
+        }
+    }
+    /**
+     * Pre-allocate WASM buffers for frame processing
+     * This eliminates per-frame allocation overhead and reduces memory copies
+     *
+     * @param width Frame width
+     * @param height Frame height
+     */
+    allocateBuffers(width, height) {
+        this.ensureInitialized();
+        const frameSize = width * height;
+        const paddedSize = this.module._calculate_padded_size(width, height);
+        // Allocate or re-allocate raw frame buffers if size changed
+        if (frameSize !== this.allocatedFrameSize) {
+            if (this.prevFramePtr)
+                this.module._free(this.prevFramePtr);
+            if (this.curFramePtr)
+                this.module._free(this.curFramePtr);
+            this.prevFramePtr = this.module._malloc(frameSize);
+            this.curFramePtr = this.module._malloc(frameSize);
+            this.allocatedFrameSize = frameSize;
+        }
+        // Allocate or re-allocate padded frame buffers if size changed
+        if (paddedSize !== this.allocatedPaddedSize) {
+            if (this.prevPaddedPtr)
+                this.module._free(this.prevPaddedPtr);
+            if (this.curPaddedPtr)
+                this.module._free(this.curPaddedPtr);
+            this.prevPaddedPtr = this.module._malloc(paddedSize);
+            this.curPaddedPtr = this.module._malloc(paddedSize);
+            this.allocatedPaddedSize = paddedSize;
+        }
+    }
+    /**
+     * Detect scene change between two frames
+     *
+     * Uses pre-allocated WASM buffers to eliminate per-frame allocation
+     * and reduce memory copies from 3 to 1 per frame.
+     *
+     * @param prevFrame Previous frame
+     * @param curFrame Current frame
+     * @param intraCount Number of consecutive non-scene-change frames
+     * @param fcode Motion search range parameter (default: 4 = 256 pixels)
+     * @returns true if scene change detected, false otherwise
+     */
+    detectSceneChange(prevFrame, curFrame, intraCount, fcode = 4) {
+        this.ensureInitialized();
+        // Validate inputs
+        if (prevFrame.width !== curFrame.width || prevFrame.height !== curFrame.height) {
+            throw new Error('Frame dimensions must match');
+        }
+        // Ensure buffers are allocated (should be done once at start)
+        if (!this.prevFramePtr || this.allocatedFrameSize !== prevFrame.data.length) {
+            this.allocateBuffers(prevFrame.width, prevFrame.height);
+        }
+        // Single copy: Raw frames -> WASM memory (eliminates 2 extra copies)
+        this.module.HEAPU8.set(prevFrame.data, this.prevFramePtr);
+        this.module.HEAPU8.set(curFrame.data, this.curFramePtr);
+        // Pad frames in-place in WASM (no copy back to JS)
+        this.module._pad_frame(this.prevFramePtr, this.prevPaddedPtr, prevFrame.width, prevFrame.height);
+        this.module._pad_frame(this.curFramePtr, this.curPaddedPtr, curFrame.width, curFrame.height);
+        // Run motion estimation on pre-padded buffers
+        const result = this.module._MEanalysis_js(this.prevPaddedPtr, this.curPaddedPtr, prevFrame.width, prevFrame.height, intraCount, fcode);
+        return result === 1;
+    }
+    /**
+     * Calculate required buffer size for a padded frame
+     *
+     * @param width Original frame width
+     * @param height Original frame height
+     * @returns Required buffer size in bytes
+     */
+    calculatePaddedSize(width, height) {
+        this.ensureInitialized();
+        return this.module._calculate_padded_size(width, height);
+    }
+    /**
+     * Get macroblock parameters for a given frame size
+     *
+     * @param width Frame width
+     * @param height Frame height
+     * @returns Macroblock parameters
+     */
+    getMBParam(width, height) {
+        const mb_width = Math.ceil(width / 16);
+        const mb_height = Math.ceil(height / 16);
+        const edge_size = 64;
+        return {
+            width,
+            height,
+            mb_width,
+            mb_height,
+            edged_width: 16 * mb_width + 2 * edge_size,
+            edged_height: 16 * mb_height + 2 * edge_size,
+            edge_size
+        };
+    }
+    /**
+     * Check if the WASM module is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Clean up resources
+     */
+    destroy() {
+        // Free pre-allocated WASM buffers
+        if (this.module) {
+            if (this.prevFramePtr)
+                this.module._free(this.prevFramePtr);
+            if (this.curFramePtr)
+                this.module._free(this.curFramePtr);
+            if (this.prevPaddedPtr)
+                this.module._free(this.prevPaddedPtr);
+            if (this.curPaddedPtr)
+                this.module._free(this.curPaddedPtr);
+        }
+        this.prevFramePtr = 0;
+        this.curFramePtr = 0;
+        this.prevPaddedPtr = 0;
+        this.curPaddedPtr = 0;
+        this.allocatedFrameSize = 0;
+        this.allocatedPaddedSize = 0;
+        this.module = null;
+        this.initialized = false;
+    }
+}
+
+/**
+ * Frame Processor - Utilities for frame preprocessing
+ */
+/**
+ * Format timestamp as timecode (HH:MM:SS.mmm)
+ */
+function formatTimecode(seconds) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = Math.floor(seconds % 60);
+    const ms = Math.floor((seconds % 1) * 1000);
+    return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}.${ms.toString().padStart(3, '0')}`;
+}
+/**
+ * Calculate macroblock parameters for frame dimensions
+ */
+function calculateMBParam(width, height) {
+    const mb_width = Math.ceil(width / 16);
+    const mb_height = Math.ceil(height / 16);
+    const edge_size = 64;
+    return {
+        width,
+        height,
+        mb_width,
+        mb_height,
+        edged_width: 16 * mb_width + 2 * edge_size,
+        edged_height: 16 * mb_height + 2 * edge_size,
+        edge_size
+    };
+}
+/**
+ * Check if frame dimensions are valid
+ */
+function validateFrameDimensions(width, height) {
+    if (width <= 0 || height <= 0) {
+        throw new Error(`Invalid frame dimensions: ${width}x${height}`);
+    }
+    if (width > 8192 || height > 8192) {
+        throw new Error(`Frame dimensions too large: ${width}x${height} (max: 8192x8192)`);
+    }
+}
+/**
+ * Calculate fcode from search range option
+ */
+function calculateFcode(searchRange, width, height) {
+    switch (searchRange) {
+        case 'small':
+            return 2; // 64 pixel range
+        case 'medium':
+            return 4; // 256 pixel range (default)
+        case 'large':
+            return 6; // 1024 pixel range
+        case 'auto':
+            // Auto-adjust based on resolution
+            const pixels = width * height;
+            if (pixels <= 720 * 480)
+                return 3; // SD: 128px
+            if (pixels <= 1920 * 1080)
+                return 4; // HD: 256px
+            return 5; // 4K+: 512px
+        default:
+            return 4;
+    }
+}
+/**
+ * Calculate adaptive thresholds based on sensitivity
+ */
+function calculateThresholds(sensitivity) {
+    switch (sensitivity) {
+        case 'low':
+            return { intraThresh: 3000, intraThresh2: 150 }; // Less sensitive
+        case 'medium':
+            return { intraThresh: 2000, intraThresh2: 90 }; // Default
+        case 'high':
+            return { intraThresh: 1000, intraThresh2: 50 }; // More sensitive
+        case 'custom':
+            // Will be overridden by customThresholds
+            return { intraThresh: 2000, intraThresh2: 90 };
+        default:
+            return { intraThresh: 2000, intraThresh2: 90 };
+    }
+}
+/**
+ * Validate frame data
+ */
+function validateFrame(frame) {
+    if (!frame.data || frame.data.length === 0) {
+        throw new Error('Frame data is empty');
+    }
+    const expectedSize = frame.width * frame.height;
+    if (frame.data.length < expectedSize) {
+        throw new Error(`Frame data size mismatch: expected at least ${expectedSize}, got ${frame.data.length}`);
+    }
+    validateFrameDimensions(frame.width, frame.height);
+}
+/**
+ * Calculate memory usage for frame
+ */
+function calculateFrameMemory(width, height) {
+    const mbParam = calculateMBParam(width, height);
+    return mbParam.edged_width * mbParam.edged_height;
+}
+/**
+ * Estimate processing time based on frame count and resolution
+ */
+function estimateProcessingTime(frameCount, width, height, targetFps = 60) {
+    // Rough estimate: higher resolution = slower
+    const resolutionFactor = (width * height) / (1920 * 1080);
+    const adjustedFps = targetFps / resolutionFactor;
+    return frameCount / adjustedFps;
+}
+
+/**
+ * Scene Detector - Main orchestrator for scene change detection
+ */
+class SceneDetector {
+    constructor(options = {}) {
+        // Set default options
+        this.options = {
+            sensitivity: options.sensitivity || 'medium',
+            customThresholds: options.customThresholds || { intraThresh: 2000, intraThresh2: 90 },
+            searchRange: options.searchRange || 'medium',
+            workers: options.workers || 1, // Multi-threading not implemented yet
+            progressive: options.progressive || { enabled: false, initialStep: 1, refinementSteps: [] },
+            temporalSmoothing: options.temporalSmoothing || { enabled: false, windowSize: 5, minConsecutive: 2 },
+            frameExtraction: options.frameExtraction || { pixelFormat: 'gray', maxBufferFrames: 2 },
+            onProgress: options.onProgress || (() => { }),
+            onScene: options.onScene || (() => { }),
+            format: options.format || 'json'
+        };
+        this.wasmBridge = new WasmBridge();
+        // Initialize detection state
+        this.state = {
+            intraCount: 1,
+            fcode: 4,
+            prevFrame: null,
+            curFrame: null
+        };
+    }
+    /**
+     * Detect scene changes in a video file
+     */
+    async detect(videoPath) {
+        // Initialize WASM module
+        await this.wasmBridge.init();
+        // Create decoder
+        const decoder = new FFmpegDecoder(videoPath, {
+            pixelFormat: this.options.frameExtraction.pixelFormat,
+            maxBufferFrames: this.options.frameExtraction.maxBufferFrames,
+            skipFrames: this.options.frameExtraction.skipFrames
+        });
+        // Get video metadata
+        const metadata = await decoder.getMetadata();
+        // Calculate fcode from search range
+        this.state.fcode = calculateFcode(this.options.searchRange, metadata.resolution.width, metadata.resolution.height);
+        // Pre-allocate WASM buffers (eliminates per-frame allocation overhead)
+        this.wasmBridge.allocateBuffers(metadata.resolution.width, metadata.resolution.height);
+        // Initialize scene list (frame 0 is always a scene change)
+        const scenes = [
+            {
+                frameNumber: 0,
+                timestamp: 0,
+                timecode: '00:00:00.000'
+            }
+        ];
+        // Processing statistics
+        const startTime = Date.now();
+        let processedFrames = 0;
+        // Process frames
+        await decoder.extractFrames(async (frame) => {
+            validateFrame(frame);
+            // Update current frame
+            this.state.curFrame = frame;
+            // Need at least 2 frames to detect scene change
+            if (this.state.prevFrame) {
+                const isSceneChange = this.wasmBridge.detectSceneChange(this.state.prevFrame, this.state.curFrame, this.state.intraCount, this.state.fcode);
+                if (isSceneChange) {
+                    const scene = {
+                        frameNumber: frame.frameNumber,
+                        timestamp: frame.pts,
+                        timecode: formatTimecode(frame.pts)
+                    };
+                    scenes.push(scene);
+                    // Call scene callback
+                    this.options.onScene(scene);
+                    // Reset intraCount
+                    this.state.intraCount = 1;
+                }
+                else {
+                    // Increment intraCount
+                    this.state.intraCount++;
+                }
+            }
+            // Move current frame to previous
+            this.state.prevFrame = this.state.curFrame;
+            processedFrames++;
+        }, (current, total) => {
+            // Progress callback
+            const progress = {
+                currentFrame: current,
+                totalFrames: total,
+                percent: Math.round((current / total) * 100)
+            };
+            // Calculate ETA
+            const elapsed = (Date.now() - startTime) / 1000;
+            const fps = current / elapsed;
+            const remaining = (total - current) / fps;
+            progress.eta = remaining;
+            this.options.onProgress(progress);
+        });
+        // Calculate statistics
+        const endTime = Date.now();
+        const processingTime = (endTime - startTime) / 1000;
+        const framesPerSecond = processedFrames / processingTime;
+        // Clean up
+        decoder.destroy();
+        return {
+            scenes,
+            metadata,
+            stats: {
+                processingTime,
+                framesPerSecond
+            }
+        };
+    }
+    /**
+     * Destroy the detector and clean up resources
+     */
+    destroy() {
+        this.wasmBridge.destroy();
+        this.state.prevFrame = null;
+        this.state.curFrame = null;
+    }
+}
+
+/**
+ * keyframes - Scene change detection for Node.js
+ *
+ * A JavaScript/TypeScript port of vapoursynth-wwxd using Xvid's motion estimation algorithm.
+ * Powered by WebAssembly for high performance.
+ */
+/**
+ * Detect scene changes in a video file (simple API)
+ *
+ * @param videoPath Path to video file
+ * @param options Detection options
+ * @returns Detection results with scene changes and metadata
+ *
+ * @example
+ * ```typescript
+ * import { detectSceneChanges } from 'keyframes';
+ *
+ * const results = await detectSceneChanges('input.mp4');
+ * console.log(`Found ${results.scenes.length} scenes`);
+ *
+ * results.scenes.forEach(scene => {
+ *   console.log(`Scene at ${scene.timecode}`);
+ * });
+ * ```
+ */
+async function detectSceneChanges(videoPath, options) {
+    const detector = new SceneDetector(options);
+    try {
+        const results = await detector.detect(videoPath);
+        return results;
+    }
+    finally {
+        detector.destroy();
+    }
+}
+/**
+ * Version information
+ */
+const version = '1.0.0';
+/**
+ * Library information
+ */
+const info = {
+    name: 'keyframes',
+    version: '1.0.0',
+    description: 'Scene change detection for Node.js using Xvid\'s motion estimation algorithm',
+    license: 'GPL-2.0',
+    repository: 'https://github.com/yourusername/keyframes',
+    author: '',
+    credits: {
+        original: 'vapoursynth-wwxd by dubhater (https://github.com/dubhater/vapoursynth-wwxd)',
+        algorithm: 'Xvid motion estimation (https://www.xvid.com)'
+    }
+};
+
+exports.BufferPool = BufferPool;
+exports.FFmpegDecoder = FFmpegDecoder;
+exports.FrameBuffer = FrameBuffer;
+exports.SceneDetector = SceneDetector;
+exports.WasmBridge = WasmBridge;
+exports.calculateFcode = calculateFcode;
+exports.calculateFrameMemory = calculateFrameMemory;
+exports.calculateMBParam = calculateMBParam;
+exports.calculateThresholds = calculateThresholds;
+exports.detectSceneChanges = detectSceneChanges;
+exports.estimateProcessingTime = estimateProcessingTime;
+exports.formatTimecode = formatTimecode;
+exports.info = info;
+exports.validateFrame = validateFrame;
+exports.validateFrameDimensions = validateFrameDimensions;
+exports.version = version;
+//# sourceMappingURL=keyframes.cjs.js.map