@camera.ui/server 0.0.49 → 0.0.50-internal.0

package/dist/server/src/decoder/child.js

@@ -0,0 +1,749 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+process.title = process.argv[2] ?? 'camera.ui - Frame Worker';
+import { Logger, SignalHandler, sleep } from '@camera.ui/common';
+import { ClientInstance } from '@camera.ui/rpc-client';
+import { rpc } from '@camera.ui/rpc-common';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { NamespaceManager } from '../rpc/namespaces.js';
+import { ImageUtils } from './imageUtils.js';
+import { createSingleConnectionServer } from './utils.js';
+const PIXEL_FORMAT = 'yuv420p';
+const METADATA_REGEX = /s:\s*(\d+x\d+)/;
+class FFmpegStream {
+    worker;
+    frameSize;
+    width;
+    height;
+    // Process Management
+    ffmpegProcess;
+    activeViewers = 0;
+    ffmpegHwOptions;
+    server;
+    socket;
+    // State
+    streamActive = false;
+    metadata;
+    isShuttingDown = false;
+    streamStartTimeout = 60000;
+    initializationPromise = null;
+    // Reconnection Logic
+    reconnectCount = 0;
+    // Frame Queue Management
+    frameBuffer = [];
+    lastFrame = null;
+    queueConsumers = new Set();
+    frameProcessingActive = false;
+    bufferDurationMs = 5000;
+    // Health Check
+    healthCheckInterval;
+    lastFrameTimestamp = 0;
+    healthCheckTime = 5000;
+    maxFrameTime = 15000;
+    // Consumer management
+    nextConsumerId = 0;
+    get bytesPerPixel() {
+        switch (this.pixelFormat) {
+            case 'yuv420p':
+            case 'nv12':
+                return 1.5;
+            case 'rgb24':
+                return 3;
+        }
+    }
+    get pixelFormat() {
+        if (this.worker.imageUtils.decoder === 'gpu') {
+            return 'nv12';
+        }
+        else {
+            return PIXEL_FORMAT;
+        }
+    }
+    constructor(worker) {
+        this.worker = worker;
+        const [width, height] = worker.config.resolution.split('x').map(Number);
+        this.width = width;
+        this.height = height;
+        this.frameSize = width * height * this.bytesPerPixel;
+    }
+    async initialize() {
+        if (this.initializationPromise) {
+            return this.initializationPromise;
+        }
+        if (this.streamActive) {
+            return;
+        }
+        try {
+            this.initializationPromise = this.startStreamProcess();
+            await this.initializationPromise;
+        }
+        finally {
+            this.initializationPromise = null;
+        }
+    }
+    close() {
+        if (!this.streamActive) {
+            return;
+        }
+        this.worker.logger.trace('Closing FFmpeg stream');
+        this.cleanupResources();
+    }
+    cleanup() {
+        this.isShuttingDown = true;
+        this.cleanupResources();
+    }
+    registerViewer() {
+        this.activeViewers++;
+        const consumer = new FrameConsumer(this.nextConsumerId++, this);
+        this.queueConsumers.add(consumer);
+        return consumer;
+    }
+    unregisterViewer(consumer) {
+        this.queueConsumers.delete(consumer);
+        this.activeViewers--;
+        if (this.activeViewers <= 0) {
+            this.activeViewers = 0;
+            this.close();
+        }
+    }
+    getNextFrame(timestamp) {
+        if (!this.lastFrame) {
+            return null;
+        }
+        if (this.lastFrame.timestamp <= timestamp) {
+            return null;
+        }
+        return {
+            data: Buffer.from(this.lastFrame.data),
+            timestamp: this.lastFrame.timestamp,
+            metadata: this.lastFrame.metadata,
+        };
+    }
+    getFrameByTimestamp(timestamp, maxDifference = 0) {
+        if (this.frameBuffer.length === 0) {
+            return undefined;
+        }
+        // Quick boundary checks
+        const firstFrame = this.frameBuffer[0];
+        const lastFrame = this.frameBuffer[this.frameBuffer.length - 1];
+        // Check if timestamp is outside our buffer range (plus maxDifference)
+        if (timestamp < firstFrame.timestamp - maxDifference || timestamp > lastFrame.timestamp + maxDifference) {
+            return undefined;
+        }
+        // Binary search for closest frame
+        let left = 0;
+        let right = this.frameBuffer.length - 1;
+        while (left <= right) {
+            const mid = Math.floor((left + right) / 2);
+            const frame = this.frameBuffer[mid];
+            const diff = frame.timestamp - timestamp;
+            // Exact match
+            if (diff === 0) {
+                return frame;
+            }
+            if (diff < 0) {
+                left = mid + 1;
+            }
+            else {
+                right = mid - 1;
+            }
+        }
+        // If we need exact match only
+        if (maxDifference === 0) {
+            return undefined;
+        }
+        // Find closest frame within maxDifference
+        // After binary search, 'left' points to the insertion point
+        // Check frames around this point
+        const candidates = [this.frameBuffer[Math.max(0, left - 1)], this.frameBuffer[Math.min(this.frameBuffer.length - 1, left)]];
+        let bestMatch;
+        let smallestDiff = Infinity;
+        for (const frame of candidates) {
+            const diff = Math.abs(frame.timestamp - timestamp);
+            if (diff <= maxDifference && diff < smallestDiff) {
+                smallestDiff = diff;
+                bestMatch = frame;
+            }
+        }
+        if (bestMatch) {
+            return bestMatch;
+        }
+        return undefined;
+    }
+    async startStreamProcess() {
+        try {
+            await this.launchStream();
+            this.reconnectCount = 0;
+        }
+        catch (error) {
+            if (this.isShuttingDown || this.activeViewers === 0) {
+                return;
+            }
+            this.reconnectCount = this.reconnectCount < 10 ? this.reconnectCount + 1 : 10;
+            const delay = this.calculateReconnectDelay();
+            this.worker.logger.warn(`Connection failed, retrying in ${delay / 1000}s`);
+            this.worker.logger.debug('Error:', error.message);
+            await sleep(delay);
+            this.worker.logger.debug('Retrying connection...');
+            return this.startStreamProcess();
+        }
+    }
+    async launchStream() {
+        if (this.activeViewers === 0) {
+            this.worker.logger.debug('No active consumers, not starting stream');
+            return;
+        }
+        this.cleanupResources();
+        this.server = await createSingleConnectionServer('127.0.0.1', {
+            noDelay: true,
+            // keepAlive: true,
+            highWaterMark: this.frameSize * 10,
+        });
+        const ffmpegArguments = await this.prepareFfmpegArguments(this.server.serverUrl);
+        this.worker.logger.trace('Starting FFmpeg with args:', this.worker.config.ffmpegPath, ffmpegArguments.join(' '));
+        this.ffmpegProcess = spawn(this.worker.config.ffmpegPath, ffmpegArguments, {
+            stdio: ['ignore', 'ignore', 'pipe'],
+        });
+        this.ffmpegProcess.once('exit', async () => {
+            if (this.activeViewers > 0 && !this.isShuttingDown) {
+                this.cleanupResources();
+                this.worker.logger.warn('FFmpeg process exited unexpectedly, restarting in 10 seconds...');
+                await sleep(10000);
+                this.initialize();
+            }
+            else {
+                this.worker.logger.debug('FFmpeg process exited');
+            }
+        });
+        try {
+            this.socket = await this.server.connectionPromise;
+            this.metadata = await this.extractMetadata();
+            this.ffmpegProcess.stderr?.destroy();
+            this.streamActive = true;
+            this.startFrameProcessing();
+            this.startHealthCheck();
+        }
+        catch (error) {
+            this.cleanupResources();
+            throw error;
+        }
+    }
+    startHealthCheck() {
+        clearInterval(this.healthCheckInterval);
+        this.healthCheckInterval = setInterval(() => {
+            if (!this.streamActive || this.activeViewers === 0) {
+                return;
+            }
+            const now = Date.now();
+            const timeSinceLastFrame = now - this.lastFrameTimestamp;
+            // If no frames for 30 seconds and we have active viewers, restart
+            if (this.lastFrameTimestamp > 0 && timeSinceLastFrame > this.maxFrameTime && this.activeViewers > 0) {
+                this.worker.logger.warn(`No frames received in ${timeSinceLastFrame / 1000}s! This may be due to a network issue, FFmpeg failure or high load on the system.`);
+                this.worker.logger.log('Restarting...');
+                this.cleanupResources();
+                this.initialize();
+            }
+        }, this.healthCheckTime);
+    }
+    async startFrameProcessing() {
+        if (this.frameProcessingActive || !this.socket || !this.metadata) {
+            return;
+        }
+        let firstChunkReceived = false;
+        let firstFrameReceived = false;
+        this.frameProcessingActive = true;
+        const metadata = this.metadata;
+        let buffer = Buffer.alloc(0);
+        let lastBufferSize = 0;
+        try {
+            for await (const chunk of this.socket) {
+                if (!this.frameProcessingActive) {
+                    break;
+                }
+                if (!chunk.length) {
+                    this.worker.logger.warn('Received empty chunk from FFmpeg');
+                    continue;
+                }
+                if (buffer.length > metadata.frameSize * 10) {
+                    this.worker.logger.warn(`Buffer growing: ${buffer.length} bytes (${(buffer.length / metadata.frameSize).toFixed(2)} frames)`);
+                }
+                if (!firstChunkReceived) {
+                    this.worker.logger.trace('First chunk received');
+                    firstChunkReceived = true;
+                }
+                buffer = Buffer.concat([buffer, chunk]);
+                while (buffer.length >= metadata.frameSize) {
+                    const frameData = buffer.subarray(0, metadata.frameSize);
+                    buffer = buffer.subarray(metadata.frameSize);
+                    if (lastBufferSize === buffer.length && buffer.length > 0) {
+                        this.worker.logger.warn(`Possible issue: Buffer size not changing: ${buffer.length} bytes`);
+                        // buffer = Buffer.alloc(0);
+                        break;
+                    }
+                    lastBufferSize = buffer.length;
+                    if (!firstFrameReceived) {
+                        this.worker.logger.trace('First frame received');
+                        firstFrameReceived = true;
+                    }
+                    this.addFrameToQueue(frameData, this.metadata);
+                }
+            }
+        }
+        catch (error) {
+            this.worker.logger.error('Error in frame processing:', error);
+        }
+        finally {
+            this.frameProcessingActive = false;
+        }
+    }
+    addFrameToQueue(frameData, metadata) {
+        const timestamp = Date.now();
+        this.lastFrameTimestamp = timestamp;
+        const newFrame = {
+            data: frameData,
+            timestamp,
+            metadata,
+        };
+        this.frameBuffer.push(newFrame);
+        this.lastFrame = newFrame;
+        this.cleanupOldFrames();
+        // Notify all consumers that a new frame is available
+        for (const consumer of this.queueConsumers) {
+            consumer.notifyNewFrame();
+        }
+    }
+    cleanupOldFrames() {
+        const currentTime = Date.now();
+        const bufferThreshold = currentTime - this.bufferDurationMs;
+        while (this.frameBuffer.length > 1 && this.frameBuffer[0].timestamp < bufferThreshold) {
+            this.frameBuffer.shift();
+        }
+    }
+    async extractMetadata() {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                cleanup();
+                reject(new Error('FFmpeg stream start timeout'));
+            }, this.streamStartTimeout);
+            const onData = (data) => {
+                const metadata = this.parseMetadataFromStderr(data);
+                if (metadata) {
+                    this.worker.logger.debug('Metadata received:', metadata);
+                    cleanup();
+                    resolve(metadata);
+                }
+            };
+            const cleanup = () => {
+                clearTimeout(timeout);
+                this.ffmpegProcess?.stderr?.removeListener('data', onData);
+            };
+            this.ffmpegProcess?.stderr?.on('data', onData);
+        });
+    }
+    calculateReconnectDelay() {
+        if (this.reconnectCount === 10) {
+            return 60000;
+        }
+        else {
+            return 10000;
+        }
+    }
+    parseMetadataFromStderr(data) {
+        const stderrText = data.toString();
+        if (!stderrText) {
+            return;
+        }
+        const match = METADATA_REGEX.exec(stderrText);
+        if (!match?.[1]) {
+            return;
+        }
+        const [originalWidth, originalHeight] = match[1].split('x').map((v) => parseInt(v, 10));
+        const frameDataSize = this.width * this.height * this.bytesPerPixel;
+        const metadata = {
+            format: this.worker.imageUtils.decoder === 'gpu' ? 'nv12' : 'yuv420p',
+            frameSize: frameDataSize,
+            width: this.width,
+            height: this.height,
+            origHeight: originalHeight,
+            origWidth: originalWidth,
+        };
+        return metadata;
+    }
+    async prepareFfmpegArguments(serverUrl) {
+        if (!this.ffmpegHwOptions) {
+            const coreManager = await this.coreManagerProxy();
+            this.ffmpegHwOptions = (await coreManager.getHwaccelInfo({
+                targetCodec: 'h264',
+                keepOnHardware: true,
+                pixelFormat: this.pixelFormat,
+                scale: {
+                    width: this.width,
+                    height: this.height,
+                },
+            }))[0];
+        }
+        const filterChain = ['showinfo=checksum=0', ...this.ffmpegHwOptions.hwaccelFilters];
+        if (this.worker.config.fps > 0) {
+            filterChain.push(`fps=fps=${this.worker.config.fps}`);
+        }
+        return [
+            '-hide_banner',
+            ...this.ffmpegHwOptions.hwaccelArgs,
+            '-fflags',
+            '+discardcorrupt+flush_packets+nobuffer',
+            '-flags',
+            'low_delay',
+            '-analyzeduration',
+            '0',
+            '-probesize',
+            '500000',
+            '-reorder_queue_size',
+            '0',
+            '-user_agent',
+            'camera.ui/frameworker',
+            '-timeout',
+            '5000000',
+            '-rtsp_transport',
+            'tcp',
+            '-re',
+            '-i',
+            this.worker.config.cameraSource,
+            ...this.ffmpegHwOptions.hwDeviceArgs,
+            '-fps_mode',
+            'cfr',
+            '-vf',
+            filterChain.join(','),
+            '-an',
+            '-dn',
+            '-sn',
+            '-f',
+            'rawvideo',
+            `${serverUrl}?tcp_nodelay=1`,
+        ];
+    }
+    cleanupResources() {
+        this.streamActive = false;
+        this.metadata = undefined;
+        this.frameProcessingActive = false;
+        clearInterval(this.healthCheckInterval);
+        this.healthCheckInterval = undefined;
+        this.server?.terminate();
+        this.server = undefined;
+        this.ffmpegProcess?.stderr?.removeAllListeners();
+        this.ffmpegProcess?.stderr?.destroy();
+        this.ffmpegProcess?.removeAllListeners();
+        this.ffmpegProcess?.kill('SIGKILL');
+        this.ffmpegProcess = undefined;
+    }
+    async coreManagerProxy() {
+        return await this.worker.createRPCProxy(this.worker.namespaces.coreManagerRpc);
+    }
+}
+class FrameConsumer {
+    id;
+    stream;
+    lastFrameTimestamp = 0;
+    resolveNewFrame = null;
+    constructor(id, stream) {
+        this.id = id;
+        this.stream = stream;
+    }
+    notifyNewFrame() {
+        if (this.resolveNewFrame) {
+            const resolve = this.resolveNewFrame;
+            this.resolveNewFrame = null;
+            resolve();
+        }
+    }
+    waitForNewFrame() {
+        return new Promise((resolve) => {
+            this.resolveNewFrame = resolve;
+        });
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                while (true) {
+                    const frame = this.stream.getNextFrame(this.lastFrameTimestamp);
+                    if (frame) {
+                        this.lastFrameTimestamp = frame.timestamp;
+                        return { value: frame, done: false };
+                    }
+                    if (!this.stream.streamActive) {
+                        return { value: undefined, done: true };
+                    }
+                    // Wait for notification of new frame
+                    await this.waitForNewFrame();
+                }
+            },
+        };
+    }
+}
+class FrameWorkerChild extends ClientInstance {
+    config;
+    namespaces;
+    logger;
+    imageUtils;
+    signalHandler;
+    ffmpegStream;
+    stopped = false;
+    constructor() {
+        super('service', {
+            endpoints: process.env.PROXY_ENDPOINTS.split(','),
+            auth: {
+                user: process.env.PROXY_USER,
+                password: process.env.PROXY_PASSWORD,
+            },
+            tls: {
+                cert: process.env.PROXY_CERT,
+                key: process.env.PROXY_KEY,
+                ca: process.env.PROXY_CA,
+            },
+            metadata: {
+                id: NamespaceManager.frameWorkerNamespaces(process.env.CAMERA_ID).frameWorkerChild,
+                name: 'Frame Worker',
+            },
+            connect: {
+                waitForServer: true,
+            },
+            reconnect: {
+                enabled: true,
+            },
+            bundledConnection: false,
+        });
+        this.namespaces = {
+            ...NamespaceManager.frameWorkerNamespaces(process.env.CAMERA_ID),
+            ...NamespaceManager.coreManagerNamespaces(),
+        };
+        this.config = {
+            cameraId: process.env.CAMERA_ID,
+            cameraName: process.env.CAMERA_NAME,
+            cameraSource: process.env.CAMERA_SOURCE,
+            ffmpegPath: process.env.FFMPEG_PATH,
+            auth: { user: process.env.PROXY_USER, password: process.env.PROXY_PASSWORD },
+            proxyEndpoints: process.env.PROXY_ENDPOINTS.split(','),
+            fps: parseInt(process.env.FPS),
+            resolution: process.env.RESOLUTION,
+            decoder: process.env.DECODER,
+        };
+        delete process.env.PROXY_USER;
+        delete process.env.PROXY_PASSWORD;
+        delete process.env.PROXY_ENDPOINTS;
+        delete process.env.PROXY_CERT;
+        delete process.env.PROXY_KEY;
+        delete process.env.PROXY_CA;
+        const loggerOptions = {
+            prefix: 'Frame Worker',
+            suffix: this.config.cameraName,
+            disableTimestamps: process.env.LOGGER_DISABLE_TIMESTAMPS === '1',
+            debugEnabled: process.env.LOGGER_LEVEL === 'debug' || process.env.LOGGER_LEVEL === 'trace',
+            traceEnabled: process.env.LOGGER_LEVEL === 'trace',
+        };
+        this.logger = new Logger(loggerOptions);
+        this.imageUtils = new ImageUtils(this.config.decoder, this.logger);
+        this.ffmpegStream = new FFmpegStream(this);
+        this.signalHandler = new SignalHandler({
+            displayName: '[Signal]',
+            timeoutDuration: 1000,
+            logger: this.logger,
+            closeFunction: this.close.bind(this),
+        });
+        this.start();
+    }
+    async onStart() {
+        await this.imageUtils.initiate();
+        await this.registerRPCHandler(this.namespaces.frameWorkerChildRpc, this);
+        this.sendMessage({ message: 'started', data: {} });
+    }
+    onBeforeStop() {
+        return this.close();
+    }
+    async onStop() { }
+    async *generateFrames(options) {
+        let consumer;
+        try {
+            consumer = this.ffmpegStream.registerViewer();
+            await this.ffmpegStream.initialize();
+            if (!this.ffmpegStream.metadata) {
+                throw new Error('Stream metadata not available');
+            }
+            const metadata = this.ffmpegStream.metadata;
+            // Use the async iterator from the consumer to get frames
+            for await (const { data: frameData, timestamp } of consumer) {
+                options = this.validateOptions(metadata, options);
+                if (options) {
+                    const processedFrame = await this.processFrame(frameData, metadata.width, metadata.height, metadata.format, options);
+                    yield {
+                        data: processedFrame.image,
+                        metadata,
+                        timestamp,
+                        info: processedFrame.info,
+                    };
+                }
+                else {
+                    const info = this.getImageInformation(metadata.width, metadata.height, metadata.format);
+                    yield {
+                        data: frameData,
+                        metadata,
+                        timestamp,
+                        info,
+                    };
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error('Error in frame generation:', error);
+        }
+        finally {
+            if (consumer) {
+                this.ffmpegStream.unregisterViewer(consumer);
+            }
+        }
+    }
+    async getPrebufferedFrame(timestamp, options, maxDifference = 500) {
+        const prebufferedFrame = this.ffmpegStream.getFrameByTimestamp(timestamp, maxDifference);
+        if (!prebufferedFrame) {
+            this.logger.debug(`No prebuffered frame found for timestamp ${timestamp}`);
+            return;
+        }
+        const validatedOptions = options && this.validateOptions(prebufferedFrame.metadata, options);
+        if (validatedOptions) {
+            const processedFrame = await this.processFrame(prebufferedFrame.data, prebufferedFrame.metadata.width, prebufferedFrame.metadata.height, prebufferedFrame.metadata.format, validatedOptions);
+            return { data: processedFrame.image, metadata: prebufferedFrame.metadata, timestamp: prebufferedFrame.timestamp, info: processedFrame.info };
+        }
+        else {
+            const info = this.getImageInformation(prebufferedFrame.metadata.width, prebufferedFrame.metadata.height, prebufferedFrame.metadata.format);
+            return { data: prebufferedFrame.data, metadata: prebufferedFrame.metadata, timestamp: prebufferedFrame.timestamp, info };
+        }
+    }
+    async processFrame(frame, width, height, format, options) {
+        const newFrame = Buffer.isBuffer(frame) ? new Uint8Array(frame, frame.byteOffset, frame.byteLength) : frame;
+        const info = this.getImageInformation(width, height, format, options);
+        const image = await this.imageUtils.processImage(newFrame, width, height, format, options);
+        return {
+            image,
+            info,
+        };
+    }
+    validateOptions(metadata, options = {}) {
+        const validated = {};
+        // Format conversion
+        const metadataFormat = metadata.format === 'rgb24' ? 'rgb' : metadata.format;
+        if (options.format?.to && options.format.to !== metadataFormat) {
+            validated.format = options.format;
+        }
+        // Cropping
+        if (options.crop) {
+            const left = options.crop.left || 0;
+            const top = options.crop.top || 0;
+            // Validate crop parameters
+            if (left >= metadata.width || top >= metadata.height) {
+                return undefined;
+            }
+            const width = Math.min(options.crop.width ?? metadata.width, metadata.width - left);
+            const height = Math.min(options.crop.height ?? metadata.height, metadata.height - top);
+            if (width <= 0 || height <= 0) {
+                return undefined;
+            }
+            // Skip full frame "crops"
+            if (left === 0 && top === 0 && width === metadata.width && height === metadata.height) {
+                // No need to include this crop as it's the full frame
+            }
+            else {
+                validated.crop = {
+                    left,
+                    top,
+                    width,
+                    height,
+                };
+            }
+        }
+        // Resizing
+        if (options.resize) {
+            let targetWidth = options.resize.width;
+            let targetHeight = options.resize.height;
+            // Handle negative values (which mean "use original")
+            if (targetWidth < 0)
+                targetWidth = metadata.width;
+            if (targetHeight < 0)
+                targetHeight = metadata.height;
+            // Calculate missing dimension if only one is provided
+            if (targetWidth > 0 && targetHeight === 0) {
+                targetHeight = Math.round((targetWidth * metadata.height) / metadata.width);
+            }
+            else if (targetHeight > 0 && targetWidth === 0) {
+                targetWidth = Math.round((targetHeight * metadata.width) / metadata.height);
+            }
+            // Skip if no resize needed
+            if ((targetWidth === 0 && targetHeight === 0) || (targetWidth === metadata.width && targetHeight === metadata.height)) {
+                // Skip as it's the same as original
+            }
+            else {
+                validated.resize = {
+                    width: targetWidth,
+                    height: targetHeight,
+                };
+            }
+        }
+        // Return undefined if no transformations are needed
+        return Object.keys(validated).length > 0 ? validated : undefined;
+    }
+    getImageInformation(inputWidth, inputHeight, inputFormat, options) {
+        // Calculate output width
+        const width = options?.resize?.width ?? (options?.crop ? Math.min(options.crop.width + (options.crop.left || 0), inputWidth - (options.crop.left || 0)) : inputWidth);
+        // Calculate output height
+        const height = options?.resize?.height ?? (options?.crop ? Math.min(options.crop.height + (options.crop.top || 0), inputHeight - (options.crop.top || 0)) : inputHeight);
+        // Determine output format
+        let format = options?.format?.to ?? inputFormat;
+        format = format === 'rgb24' ? 'rgb' : format;
+        // Calculate channels based on format
+        const channels = format === 'rgba' ? 4 : format === 'rgb' ? 3 : format === 'gray' ? 1 : 1.5;
+        return {
+            width,
+            height,
+            channels,
+            format,
+        };
+    }
+    sendMessage(message) {
+        this.sendToServer(message);
+    }
+    async close() {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        this.ffmpegStream.cleanup();
+        await this.stop();
+    }
+}
+__decorate([
+    rpc({ public: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Object)
+], FrameWorkerChild.prototype, "generateFrames", null);
+__decorate([
+    rpc({ public: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Object, Object]),
+    __metadata("design:returntype", Promise)
+], FrameWorkerChild.prototype, "getPrebufferedFrame", null);
+__decorate([
+    rpc({ public: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Number, String, Object]),
+    __metadata("design:returntype", Promise)
+], FrameWorkerChild.prototype, "processFrame", null);
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    new FrameWorkerChild();
+}
+//# sourceMappingURL=child.js.map