@camera.ui/server 0.0.70 → 0.0.71

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

@@ -1,748 +0,0 @@
-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,
-            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