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

package/src/decoder/imageUtils.ts

@@ -1,275 +0,0 @@
-import { instantiate } from '@assemblyscript/loader';
-import { getAddon } from '@camera.ui/rust-decoder';
-import { readFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import type { ASUtil } from '@assemblyscript/loader';
-import type { Logger } from '@camera.ui/common/logger';
-import type { GpuImageProcessorInstance } from '@camera.ui/rust-decoder';
-import type { CameraFrameWorkerDecoder, DecoderFormat, ImageOptions, ImageOutputFormat } from '@camera.ui/types';
-import type { instantiate as instantiateWasm } from './wasm/build/decoder.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-export type WASMModule = ASUtil & Record<string, unknown> & Awaited<ReturnType<typeof instantiateWasm>>;
-
-enum WASMImageFormat {
-  NONE = 0,
-  GRAY = 1,
-  RGB = 2,
-  RGBA = 3,
-}
-
-enum WASMInputFormat {
-  YUV = 1,
-  RGB = 2,
-  RGBA = 3,
-  GRAY = 4,
-}
-
-enum RUSTInputFormat {
-  GRAY = 1,
-  RGB = 3,
-  RGBA = 4,
-  NV12 = 12,
-}
-
-export class ImageUtils {
-  public decoder: CameraFrameWorkerDecoder;
-
-  private logger: Logger;
-  private initiated = false;
-
-  private wasmExports?: WASMModule;
-  private rustAddon = getAddon();
-  private gpuImageProcessor?: GpuImageProcessorInstance;
-
-  constructor(decoder: CameraFrameWorkerDecoder, logger: Logger) {
-    this.decoder = decoder;
-    this.logger = logger;
-
-    const gpuBackends = this.rustAddon?.getGpuBackends() ?? [];
-    if (this.decoder === 'rust' || this.decoder === 'gpu') {
-      if (!this.rustAddon) {
-        this.logger.warn('Rust decoder not available, falling back to WASM');
-        this.decoder = 'wasm';
-      } else if (this.decoder === 'gpu' && gpuBackends.length === 0) {
-        this.logger.warn('No GPU backends available, falling back to Rust');
-        this.decoder = 'rust';
-      }
-    }
-  }
-
-  public async initiate(): Promise<void> {
-    if (this.initiated) {
-      return;
-    }
-
-    this.initiated = true;
-
-    if (this.decoder === 'gpu') {
-      const backends = this.rustAddon!.getGpuBackends();
-      this.logger.log('Available GPU backends:', backends.join(', '));
-      this.gpuImageProcessor = new this.rustAddon!.GpuImageProcessor();
-      await this.gpuImageProcessor.initialize('auto');
-    }
-
-    if (this.decoder === 'wasm') {
-      const wasmModule = await instantiate(readFileSync(resolve(__dirname, './wasm/build/decoder.wasm')), {
-        console: {
-          log: (messagePtr: number) => {
-            this.logger.debug(this.wasmExports!.__getString(messagePtr));
-          },
-        },
-        env: {
-          abort: (msgPtr: number, filePtr: number, line: number, column: number) => {
-            const msg = this.wasmExports!.__getString(msgPtr);
-            const file = this.wasmExports!.__getString(filePtr);
-            this.logger.error(`Abort called at ${file}:${line}:${column}`, msg);
-          },
-        },
-      });
-
-      this.wasmExports = wasmModule.exports as WASMModule;
-    }
-  }
-
-  public processImage(
-    imageData: Buffer | Uint8Array,
-    inputWidth: number,
-    inputHeight: number,
-    inputFormat: DecoderFormat | 'rgba' | 'gray',
-    options: ImageOptions,
-  ): Promise<Uint8Array> {
-    if (!this.initiated) {
-      throw new Error('ImageUtils not initiated');
-    }
-
-    if (this.decoder === 'wasm') {
-      return this.processImageWASM(imageData, inputWidth, inputHeight, inputFormat, options);
-    } else if (this.decoder === 'gpu' && this.gpuImageProcessor?.initialized) {
-      return this.processImageGpu(imageData, inputWidth, inputHeight, inputFormat, options);
-    } else {
-      return this.processImageRust(imageData, inputWidth, inputHeight, inputFormat, options);
-    }
-  }
-
-  private async processImageRust(
-    imageData: Buffer | Uint8Array,
-    inputWidth: number,
-    inputHeight: number,
-    inputFormat: DecoderFormat | 'rgba' | 'gray',
-    options: ImageOptions,
-  ): Promise<Uint8Array> {
-    if (!this.rustAddon) {
-      throw new Error('Rust addon not available');
-    }
-
-    const channels = options.format?.to === 'gray' ? 1 : options.format?.to === 'rgba' ? 4 : 3;
-
-    const cropTop = options.crop && options.crop.top > 0 ? options.crop.top : 0;
-    const cropLeft = options.crop && options.crop.left > 0 ? options.crop.left : 0;
-    const cropWidth = options.crop && options.crop.width > 0 ? options.crop.width : 0;
-    const cropHeight = options.crop && options.crop.height > 0 ? options.crop.height : 0;
-
-    const resizeWidth = options.resize && options.resize.width > 0 ? options.resize.width : 0;
-    const resizeHeight = options.resize && options.resize.height > 0 ? options.resize.height : 0;
-
-    const blurRadius = 0; // not used
-
-    return this.rustAddon.processImage(imageData, inputWidth, inputHeight, channels, cropTop, cropLeft, cropWidth, cropHeight, resizeWidth, resizeHeight, blurRadius);
-  }
-
-  private async processImageGpu(
-    imageData: Buffer | Uint8Array,
-    inputWidth: number,
-    inputHeight: number,
-    inputFormat: DecoderFormat | 'rgba' | 'gray',
-    options: ImageOptions,
-  ): Promise<Uint8Array> {
-    if (!this.rustAddon) {
-      throw new Error('Rust addon not available');
-    }
-
-    if (!this.gpuImageProcessor?.initialized) {
-      throw new Error('GPU Image Processor not initialized');
-    }
-
-    const frame = Buffer.isBuffer(imageData) ? imageData : Buffer.from(imageData);
-
-    return this.gpuImageProcessor.processImage(frame, {
-      inputWidth,
-      inputHeight,
-      inputFormat: this.mapRustInputFormat(inputFormat),
-      cropTop: options.crop?.top,
-      cropLeft: options.crop?.left,
-      cropWidth: options.crop?.width,
-      cropHeight: options.crop?.height,
-      resizeWidth: options.resize?.width,
-      resizeHeight: options.resize?.height,
-      outputFormat: options.format?.to === 'gray' ? 1 : options.format?.to === 'rgba' ? 4 : 3,
-    });
-  }
-
-  private async processImageWASM(
-    imageData: Buffer | Uint8Array,
-    inputWidth: number,
-    inputHeight: number,
-    inputFormat: DecoderFormat | 'rgba' | 'gray',
-    options: ImageOptions,
-  ): Promise<Uint8Array> {
-    if (!this.wasmExports) {
-      throw new Error('WASM module not initialized');
-    }
-
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const { processImage, __newArray, __getUint8Array, __pin, __unpin, __collect, Uint8Array_ID } = this.wasmExports;
-
-    const inputPtr = __pin(__newArray(Uint8Array_ID.value, imageData));
-
-    const inputFormatEnum = this.mapWASMInputFormat(inputFormat);
-    const formatEnum = options.format ? this.mapImageFormat(options.format.to) : WASMImageFormat.NONE;
-
-    const cropTop = options.crop && options.crop.top > 0 ? options.crop.top : 0;
-    const cropLeft = options.crop && options.crop.left > 0 ? options.crop.left : 0;
-    const cropWidth = options.crop && options.crop.width > 0 ? options.crop.width : 0;
-    const cropHeight = options.crop && options.crop.height > 0 ? options.crop.height : 0;
-
-    const resizeWidth = options.resize && options.resize.width > 0 ? options.resize.width : 0;
-    const resizeHeight = options.resize && options.resize.height > 0 ? options.resize.height : 0;
-
-    const reconvertRGBToYUV = 0;
-    const blurRadius = 0; // not used
-
-    const outputPtr = processImage(
-      inputPtr as any,
-      inputWidth,
-      inputHeight,
-      formatEnum,
-      cropTop,
-      cropLeft,
-      cropWidth,
-      cropHeight,
-      resizeWidth,
-      resizeHeight,
-      blurRadius,
-      inputFormatEnum,
-      reconvertRGBToYUV,
-    );
-
-    // Retrieve the processed image data
-    const processedImage = __getUint8Array(outputPtr as any).slice();
-
-    // Clean up WASM memory
-    __unpin(inputPtr);
-    __collect();
-
-    return processedImage;
-  }
-
-  private mapWASMInputFormat(inputFormat: DecoderFormat | 'rgba' | 'gray'): WASMInputFormat {
-    switch (inputFormat) {
-      case 'yuv420p':
-      case 'nv12':
-        return WASMInputFormat.YUV;
-      case 'rgb24':
-        return WASMInputFormat.RGB;
-      case 'rgba':
-        return WASMInputFormat.RGBA;
-      case 'gray':
-        return WASMInputFormat.GRAY;
-      default:
-        return WASMInputFormat.GRAY;
-    }
-  }
-
-  private mapRustInputFormat(inputFormat: DecoderFormat | 'rgba' | 'gray'): RUSTInputFormat {
-    switch (inputFormat) {
-      case 'gray':
-        return RUSTInputFormat.GRAY;
-      case 'rgb24':
-        return RUSTInputFormat.RGB;
-      case 'rgba':
-        return RUSTInputFormat.RGBA;
-      case 'nv12':
-        return RUSTInputFormat.NV12;
-      default:
-        return RUSTInputFormat.GRAY;
-    }
-  }
-
-  private mapImageFormat(format: ImageOutputFormat): WASMImageFormat {
-    switch (format) {
-      case 'gray':
-        return WASMImageFormat.GRAY;
-      case 'rgb':
-        return WASMImageFormat.RGB;
-      case 'rgba':
-        return WASMImageFormat.RGBA;
-      default:
-        return WASMImageFormat.NONE;
-    }
-  }
-}

package/src/decoder/manager.ts

@@ -1,251 +0,0 @@
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { Worker } from 'node:worker_threads';
-
-import type { Logger } from '@camera.ui/common';
-import type { CameraFrameWorkerDecoder, DecoderFormat, ImageOptions } from '@camera.ui/types';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-export class ImageProcessorManager {
-  private worker: Worker | null = null;
-  private logger: Logger;
-  private isInitialized = false;
-  private isInitializing = false;
-  private pendingRequests = new Map<number, { resolve: (result: Uint8Array) => void; reject: (error: Error) => void }>();
-  private nextRequestId = 0;
-  private decoder: CameraFrameWorkerDecoder;
-
-  constructor(decoder: CameraFrameWorkerDecoder, logger: Logger) {
-    this.decoder = decoder;
-    this.logger = logger;
-  }
-
-  public async initialize(): Promise<void> {
-    if (this.isInitialized) {
-      return;
-    }
-
-    if (this.isInitializing) {
-      return this.waitForInitialization();
-    }
-
-    this.isInitializing = true;
-
-    try {
-      await this.startWorker();
-      this.isInitialized = true;
-      this.isInitializing = false;
-      this.logger.trace('Image processor worker initialized');
-    } catch (error) {
-      this.isInitializing = false;
-      throw error;
-    }
-  }
-
-  public async processImage(
-    imageData: Buffer | Uint8Array,
-    inputWidth: number,
-    inputHeight: number,
-    inputFormat: DecoderFormat | 'rgba' | 'gray',
-    options: ImageOptions,
-  ): Promise<Uint8Array> {
-    if (!this.isInitialized) {
-      await this.initialize();
-    }
-
-    if (!this.worker) {
-      throw new Error('Worker not initialized');
-    }
-
-    const requestId = this.nextRequestId++;
-
-    return new Promise<Uint8Array>((resolve, reject) => {
-      this.pendingRequests.set(requestId, { resolve, reject });
-
-      try {
-        // Convert Buffer to Uint8Array for transferring
-        // const data = Buffer.isBuffer(imageData) ? new Uint8Array(imageData.buffer, imageData.byteOffset, imageData.byteLength) : imageData;
-
-        let dataToSend;
-        if (Buffer.isBuffer(imageData)) {
-          // Eine Kopie des Puffers erstellen, damit der ursprüngliche intakt bleibt
-          dataToSend = new Uint8Array(imageData.buffer.slice(0), imageData.byteOffset, imageData.byteLength);
-        } else {
-          // Auch für Uint8Array eine Kopie erstellen
-          dataToSend = new Uint8Array(imageData.buffer.slice(0));
-        }
-
-        // Send the processing request to the worker
-        this.worker!.postMessage(
-          {
-            type: 'process',
-            id: requestId,
-            imageData: dataToSend,
-            inputWidth,
-            inputHeight,
-            inputFormat,
-            options,
-          },
-          [dataToSend.buffer],
-        );
-      } catch (error) {
-        this.pendingRequests.delete(requestId);
-        reject(error instanceof Error ? error : new Error(String(error)));
-      }
-    });
-  }
-
-  public shutdown(): void {
-    if (this.worker) {
-      // Reject all pending requests
-      for (const [, { reject }] of this.pendingRequests) {
-        reject(new Error('Worker was terminated'));
-      }
-      this.pendingRequests.clear();
-
-      this.worker.terminate();
-      this.worker = null;
-      this.isInitialized = false;
-    }
-  }
-
-  private async startWorker(): Promise<void> {
-    return new Promise<void>((_resolve, _reject) => {
-      try {
-        const workerPath = resolve(__dirname, './worker.js');
-        this.worker = new Worker(workerPath, {
-          workerData: { decoder: this.decoder },
-        });
-
-        // Setup message handler
-        this.worker.on('message', (message) => {
-          if (message.type === 'log') {
-            this.handleLogMessage(message);
-            return;
-          }
-
-          if (message.type === 'initialized') {
-            _resolve();
-            return;
-          }
-
-          if (message.type === 'error' && message.id === undefined) {
-            _reject(new Error(message.error));
-            return;
-          }
-
-          if (message.type === 'result' || message.type === 'error') {
-            this.handleProcessResult(message);
-            return;
-          }
-
-          this.logger.warn('Unknown message from worker:', message);
-        });
-
-        // Setup error handler
-        this.worker.on('error', (error) => {
-          this.logger.error('Worker error:', error);
-
-          // Reject all pending requests
-          for (const [, { reject }] of this.pendingRequests) {
-            reject(error);
-          }
-          this.pendingRequests.clear();
-
-          this.isInitialized = false;
-          this.worker = null;
-
-          _reject(error);
-        });
-
-        // Handle worker exit
-        this.worker.on('exit', (code) => {
-          if (code !== 0) {
-            this.logger.error(`Worker stopped with exit code ${code}`);
-
-            // Reject all pending requests if not already handled
-            for (const [, { reject }] of this.pendingRequests) {
-              reject(new Error(`Worker stopped with exit code ${code}`));
-            }
-            this.pendingRequests.clear();
-          }
-
-          this.isInitialized = false;
-          this.worker = null;
-        });
-
-        // Send initialization message
-        this.worker.postMessage({ type: 'init', decoder: this.decoder });
-      } catch (error) {
-        this.logger.error('Failed to start worker:', error);
-        _reject(error);
-      }
-    });
-  }
-
-  private handleProcessResult(message: any): void {
-    const { id, type, data, error } = message;
-    const request = this.pendingRequests.get(id);
-
-    if (!request) {
-      this.logger.warn(`Received result for unknown request ${id}`);
-      return;
-    }
-
-    this.pendingRequests.delete(id);
-
-    if (type === 'result') {
-      request.resolve(data);
-    } else if (type === 'error') {
-      request.reject(new Error(error));
-    }
-  }
-
-  private handleLogMessage(message: any): void {
-    const { level, message: logMessage } = message;
-
-    switch (level) {
-      case 'info':
-        this.logger.log(logMessage);
-        break;
-      case 'debug':
-        this.logger.debug(logMessage);
-        break;
-      case 'error':
-        this.logger.error(logMessage);
-        break;
-      case 'warn':
-        this.logger.warn(logMessage);
-        break;
-      case 'trace':
-        this.logger.trace?.(logMessage);
-        break;
-      default:
-        this.logger.log(logMessage);
-    }
-  }
-
-  private async waitForInitialization(): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      const checkInterval = setInterval(() => {
-        if (this.isInitialized) {
-          clearInterval(checkInterval);
-          resolve();
-        } else if (!this.isInitializing) {
-          clearInterval(checkInterval);
-          reject(new Error('Initialization failed'));
-        }
-      }, 100);
-
-      // Timeout after 30 seconds
-      setTimeout(() => {
-        if (!this.isInitialized) {
-          clearInterval(checkInterval);
-          reject(new Error('Initialization timed out'));
-        }
-      }, 30000);
-    });
-  }
-}