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

package/src/decoder/test/child.ts

@@ -1,117 +0,0 @@
-import { DEFAULT_FFMPEG_ARGS, FFmpegStream } from './ffmpeg.js';
-
-import type { FfmpegArgs, ImageOptions } from '@camera.ui/types';
-import type { ImageUtils } from '../../../polyglot/node/decoder/imageUtils.js';
-import type { FFmpegStreamConfig } from './ffmpeg.js';
-
-export class FrameWorkerChild {
-  private ffmpegStream: FFmpegStream;
-
-  constructor(
-    private config: FFmpegStreamConfig,
-    private imageUtils: ImageUtils, // Replace with your ImageUtils type
-    private ffmpegArgs: FfmpegArgs = DEFAULT_FFMPEG_ARGS,
-  ) {
-    this.imageUtils = imageUtils;
-    this.ffmpegStream = new FFmpegStream(config, ffmpegArgs);
-
-    // Error handling
-    this.ffmpegStream.on('error', async (error) => {
-      console.error('FFmpeg Error:', error);
-
-      // Versuche FFmpeg neu zu starten
-      try {
-        await this.ffmpegStream.restart();
-      } catch (restartError) {
-        console.error('Failed to restart FFmpeg:', restartError);
-      }
-    });
-  }
-
-  async *generateFrames(options?: ImageOptions): AsyncIterableIterator<{
-    data: Uint8Array;
-    timestamp: number;
-  }> {
-    this.ffmpegStream.registerConsumer();
-
-    try {
-      if (!this.ffmpegStream.isRunning) {
-        await this.ffmpegStream.start();
-      }
-
-      const [width, height] = this.config.resolution.split('x').map(Number);
-
-      // Listener außerhalb der while-Schleife definieren
-      const framePromise = () =>
-        new Promise<{ data: Buffer; timestamp: number; release: () => void }>((resolve) => {
-          this.ffmpegStream.once('frame', resolve);
-        });
-
-      while (true) {
-        const frame = await framePromise();
-
-        try {
-          if (options) {
-            const processedData = await this.imageUtils.processImage(frame.data, width, height, 'yuv420p', options);
-            yield { data: processedData, timestamp: frame.timestamp };
-          } else {
-            yield { data: frame.data, timestamp: frame.timestamp };
-          }
-        } finally {
-          // Buffer nach Verwendung zurückgeben
-          frame.release();
-        }
-      }
-    } finally {
-      this.ffmpegStream.unregisterConsumer();
-    }
-  }
-
-  /**
-   * Start FFmpeg process manually
-   */
-  async start(): Promise<void> {
-    await this.ffmpegStream.start();
-  }
-
-  /**
-   * Stop FFmpeg process manually
-   */
-  async stop(): Promise<void> {
-    await this.ffmpegStream.stop();
-  }
-
-  /**
-   * Restart FFmpeg process manually
-   */
-  async restart(): Promise<void> {
-    await this.ffmpegStream.restart();
-  }
-
-  /**
-   * Update FFmpeg configuration
-   * This will restart the FFmpeg process if it's running
-   */
-  async updateConfig(config: Partial<FFmpegStreamConfig>): Promise<void> {
-    const wasRunning = this.ffmpegStream.isRunning;
-
-    if (wasRunning) {
-      await this.stop();
-    }
-
-    // Create new FFmpegStream with updated config
-    this.config = { ...this.config, ...config };
-    this.ffmpegStream = new FFmpegStream(this.config, this.ffmpegArgs);
-
-    if (wasRunning) {
-      await this.start();
-    }
-  }
-
-  /**
-   * Check if FFmpeg process is running
-   */
-  isRunning(): boolean {
-    return this.ffmpegStream.isRunning;
-  }
-}

package/src/decoder/test/ffmpeg.ts

@@ -1,371 +0,0 @@
-import { ChildProcess, spawn } from 'node:child_process';
-import { Transform } from 'node:stream';
-
-import type { TransformCallback, TransformOptions } from 'node:stream';
-
-export type CameraFrameWorkerDecoder = 'pillow' | 'wasm' | 'rust';
-
-export type CameraFrameWorkerResolution =
-  | '3840x2160'
-  | '3072x1728'
-  | '2560x1440'
-  | '1920x1080'
-  | '1440x1080'
-  | '1280x720'
-  | '960x540'
-  | '640x480'
-  | '640x360'
-  | '320x240'
-  | '320x180';
-
-export interface FFmpegStreamConfig {
-  frameWorkerId: string;
-  cameraId: string;
-  cameraName: string;
-  ffmpegPath: string;
-  auth: { user: string; password: string };
-  proxyEndpoints: string[];
-  fps: number;
-  resolution: CameraFrameWorkerResolution;
-  decoder: CameraFrameWorkerDecoder;
-}
-
-export interface FfmpegArgs {
-  codec: string;
-  hwaccel: string;
-  hwaccelArgs: string[];
-  hwaccelFilters: string[];
-  hwDeviceArgs: string[];
-  threads: string;
-}
-
-export type DecoderFormat = 'yuv' | 'rgb';
-
-export interface FrameMetadata {
-  format: DecoderFormat;
-  frameSize: number;
-  width: number;
-  origWidth: number;
-  height: number;
-  origHeight: number;
-}
-
-export const PIX_FMT: 'yuv420p' | 'rgb24' | 'nv12' = 'yuv420p';
-
-export const DEFAULT_FFMPEG_ARGS: FfmpegArgs = {
-  codec: 'h264',
-  hwaccel: 'auto',
-  hwaccelArgs: [],
-  hwaccelFilters: ['scale=640:360'],
-  hwDeviceArgs: [],
-  threads: '1',
-};
-
-const CAMERA_SOURCE = 'rtsp://localhost:2101/keller_fullhd?video';
-// const CAMERA_SOURCE = 'rtsp://192.168.178.76:554/11';
-
-export class FFmpegStream extends Transform {
-  public isRunning = false;
-
-  private readonly frameSize: number;
-  private readonly ringBuffer: Buffer;
-  private writePos = 0;
-  private readPos = 0;
-  private bytesInBuffer = 0;
-
-  // Neu: Frame Buffer Pool
-  private readonly frameBufferPool: Buffer[] = [];
-  private readonly poolSize = 4; // Anzahl der Buffer im Pool
-
-  private process?: ChildProcess;
-  private activeConsumers = 0;
-
-  private metadata?: FrameMetadata;
-
-  constructor(
-    private config: FFmpegStreamConfig,
-    private ffmpegArgs: FfmpegArgs = DEFAULT_FFMPEG_ARGS,
-    options: TransformOptions = {},
-  ) {
-    super({
-      ...options,
-      objectMode: false,
-      highWaterMark: 1024 * 1024, // 1MB chunks
-    });
-
-    const [width, height] = config.resolution.split('x').map(Number);
-    this.frameSize = width * height * this.getBytesPerPixel();
-
-    // Ring-Buffer für 4 Frames
-    this.ringBuffer = Buffer.allocUnsafe(this.frameSize * 4);
-
-    this.initializeBufferPool();
-  }
-
-  public async start(): Promise<void> {
-    if (this.isRunning) return;
-
-    const args = this.buildFfmpegArgs();
-
-    this.process = spawn('ffmpeg', args, {
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    this.isRunning = true;
-
-    // Pipe FFmpeg output to our transform stream
-    this.process.stdout?.pipe(this);
-    this.process.stderr?.on('data', this.parseFrameInfo.bind(this));
-
-    this.process.on('exit', (code) => {
-      if (code !== 0 && code !== null) {
-        this.emit('error', new Error(`FFmpeg process exited with code ${code}`));
-      }
-      this.isRunning = false;
-    });
-
-    this.metadata = await new Promise<FrameMetadata>((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error('FFmpeg stream start timeout'));
-      }, 10000);
-
-      this.once('metadata', (metadata: FrameMetadata) => {
-        this.process?.stderr?.removeAllListeners('data');
-        this.process?.stderr?.resume();
-        this.process?.stderr?.destroy();
-
-        clearTimeout(timeout);
-        resolve(metadata);
-      });
-    });
-
-    console.log('FFmpegStream metadata:', this.metadata);
-  }
-
-  public stop(): void {
-    if (!this.isRunning) return;
-
-    this.process?.kill('SIGKILL');
-
-    this.bytesInBuffer = 0;
-    this.readPos = 0;
-    this.writePos = 0;
-
-    // Neu: Leere den Buffer Pool beim Stoppen
-    this.frameBufferPool.length = 0;
-    this.initializeBufferPool();
-
-    this.isRunning = false;
-  }
-
-  public async restart(): Promise<void> {
-    this.stop();
-    // Warte kurz bevor Neustart
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    await this.start();
-  }
-
-  public registerConsumer(): void {
-    this.activeConsumers++;
-  }
-
-  public unregisterConsumer(): void {
-    this.activeConsumers--;
-    if (this.activeConsumers <= 0) {
-      this.activeConsumers = 0;
-      this.stop();
-    }
-  }
-
-  public _transform(chunk: Buffer, encoding: string, callback: TransformCallback): void {
-    if (!this.isRunning) {
-      return callback();
-    }
-
-    try {
-      // Direkt in den Ring-Buffer schreiben
-      if (this.writePos + chunk.length > this.ringBuffer.length) {
-        // Buffer wrapping
-        const firstPart = this.ringBuffer.length - this.writePos;
-        chunk.copy(this.ringBuffer, this.writePos, 0, firstPart);
-        chunk.copy(this.ringBuffer, 0, firstPart);
-        this.writePos = chunk.length - firstPart;
-      } else {
-        chunk.copy(this.ringBuffer, this.writePos);
-        this.writePos = (this.writePos + chunk.length) % this.ringBuffer.length;
-      }
-
-      this.bytesInBuffer += chunk.length;
-
-      // Komplette Frames emittieren
-      while (this.bytesInBuffer >= this.frameSize) {
-        // Frame aus Pool holen statt neu zu allozieren
-        const frame = this.getFrameBuffer();
-
-        if (this.readPos + this.frameSize > this.ringBuffer.length) {
-          // Frame wrapped around buffer end
-          const firstPart = this.ringBuffer.length - this.readPos;
-          this.ringBuffer.copy(frame, 0, this.readPos, this.ringBuffer.length);
-          this.ringBuffer.copy(frame, firstPart, 0, this.frameSize - firstPart);
-        } else {
-          this.ringBuffer.copy(frame, 0, this.readPos, this.readPos + this.frameSize);
-        }
-
-        this.readPos = (this.readPos + this.frameSize) % this.ringBuffer.length;
-        this.bytesInBuffer -= this.frameSize;
-
-        // Frame emittieren
-        this.emit('frame', {
-          data: frame,
-          timestamp: Date.now(),
-          // Neu: Callback zum Zurückgeben des Buffers
-          release: () => this.releaseFrameBuffer(frame),
-        });
-      }
-
-      callback();
-    } catch (error) {
-      callback(error as Error);
-    }
-  }
-
-  public _flush(callback: TransformCallback): void {
-    this.bytesInBuffer = 0;
-    this.readPos = 0;
-    this.writePos = 0;
-
-    // Neu: Buffer Pool leeren
-    this.frameBufferPool.length = 0;
-    this.initializeBufferPool();
-
-    callback();
-  }
-
-  private parseFrameInfo(data: Buffer): FrameMetadata | undefined {
-    const stderr = data.toString();
-    if (!stderr) {
-      return;
-    }
-
-    const patterns: Record<string, RegExp> = {
-      s: /s:\s*(\d+x\d+)/,
-    };
-
-    const matches = Object.entries(patterns).reduce(
-      (acc, [key, pattern]) => {
-        const match = stderr.match(pattern);
-        if (match) {
-          acc[key] = match[1];
-        }
-        return acc;
-      },
-      {} as Record<string, string>,
-    );
-
-    if (!matches.s) {
-      return;
-    }
-
-    const [width, height] = matches.s.split('x').map((v) => parseInt(v, 10));
-    const [cameraWidth, cameraHeight] = this.config.resolution.split('x').map((v) => parseInt(v, 10));
-    const format: DecoderFormat = PIX_FMT === 'yuv420p' ? 'yuv' : 'rgb';
-    const bytesPerPixel = format === 'yuv' ? 1.5 : 3; // YUV420P or RGB24
-    const frameSize = cameraWidth * cameraHeight * bytesPerPixel;
-
-    const metadata: FrameMetadata = {
-      format,
-      frameSize,
-      width: cameraWidth,
-      height: cameraHeight,
-      origHeight: height,
-      origWidth: width,
-    };
-
-    this.emit('metadata', metadata);
-  }
-
-  // Neue Methode: Initialisierung des Buffer Pools
-  private initializeBufferPool(): void {
-    for (let i = 0; i < this.poolSize; i++) {
-      this.frameBufferPool.push(Buffer.allocUnsafe(this.frameSize));
-    }
-  }
-
-  // Neue Methode: Buffer aus dem Pool holen
-  private getFrameBuffer(): Buffer {
-    const buffer = this.frameBufferPool.pop();
-    if (buffer) {
-      return buffer;
-    }
-    // Falls Pool leer, neuen Buffer erstellen
-    return Buffer.allocUnsafe(this.frameSize);
-  }
-
-  // Neue Methode: Buffer in den Pool zurückgeben
-  private releaseFrameBuffer(buffer: Buffer): void {
-    if (this.frameBufferPool.length < this.poolSize) {
-      this.frameBufferPool.push(buffer);
-    }
-  }
-
-  private buildFfmpegArgs(): string[] {
-    const filters: string[] = ['showinfo=checksum=0'];
-    const [width, height] = this.config.resolution.split('x');
-
-    this.ffmpegArgs.hwaccelFilters = this.ffmpegArgs.hwaccelFilters.map((filter) => {
-      if (filter.includes('scale')) {
-        filter = filter.replace('640', width).replace('360', height);
-      }
-      return filter;
-    });
-
-    filters.push(...this.ffmpegArgs.hwaccelFilters);
-
-    if (this.config.fps > 0) {
-      filters.push(`fps=fps=${this.config.fps}`);
-    }
-
-    return [
-      '-hide_banner',
-      '-err_detect',
-      'ignore_err',
-      ...this.ffmpegArgs.hwaccelArgs,
-      '-fflags',
-      '+discardcorrupt+flush_packets+nobuffer',
-      '-flags',
-      'low_delay',
-      '-probesize',
-      '500000',
-      '-analyzeduration',
-      '0',
-      '-user_agent',
-      'camera.ui/decoder',
-      '-avioflags',
-      'direct',
-      '-rtsp_transport',
-      'tcp',
-      '-i',
-      CAMERA_SOURCE,
-      '-vf',
-      filters.join(','),
-      '-f',
-      'rawvideo',
-      '-pix_fmt',
-      PIX_FMT,
-      '-an',
-      '-dn',
-      '-sn',
-      '-',
-    ];
-  }
-
-  private getBytesPerPixel(): number {
-    switch (PIX_FMT) {
-      case 'yuv420p':
-      case 'nv12':
-        return 1.5;
-      case 'rgb24':
-        return 3;
-    }
-  }
-}

package/src/decoder/test/test.ts

@@ -1,182 +0,0 @@
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { FrameWorkerChild } from './child.js';
-
-import { Logger } from '@camera.ui/common';
-import { ImageUtils } from '../../../polyglot/node/decoder/imageUtils.js';
-import type { FFmpegStreamConfig } from './ffmpeg.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const config: FFmpegStreamConfig = {
-  auth: {
-    user: '',
-    password: '',
-  },
-  cameraId: '1',
-  cameraName: 'Test Camera',
-  decoder: 'rust',
-  ffmpegPath: resolve(__dirname, '../../../../../../../server/node_modules/@camera.ui/ffmpeg/binary/ffmpeg'),
-  fps: 0,
-  frameWorkerId: '1',
-  proxyEndpoints: [],
-  resolution: '640x360',
-};
-
-const logger = new Logger({
-  debugEnabled: true,
-  traceEnabled: true,
-  disablePrefix: true,
-  disableTimestamps: false,
-});
-
-const imageUtils = new ImageUtils(config.decoder, logger);
-
-class FPSMonitor {
-  private frameTimestamps: number[] = [];
-  private readonly windowSize: number;
-  private lastLogTime = 0;
-  private logInterval: number;
-
-  constructor(windowSize = 30, logInterval = 1000) {
-    this.windowSize = windowSize;
-    this.logInterval = logInterval;
-  }
-
-  addFrame(generatorId: number) {
-    const now = Date.now();
-    this.frameTimestamps.push(now);
-
-    while (this.frameTimestamps.length > this.windowSize) {
-      this.frameTimestamps.shift();
-    }
-
-    if (now - this.lastLogTime >= this.logInterval) {
-      this.logFPS(generatorId);
-      this.lastLogTime = now;
-    }
-  }
-
-  private logFPS(generatorId: number) {
-    if (this.frameTimestamps.length >= 2) {
-      const timeWindow = (this.frameTimestamps[this.frameTimestamps.length - 1] - this.frameTimestamps[0]) / 1000;
-      const fps = (this.frameTimestamps.length - 1) / timeWindow;
-      console.log(`Generator ${generatorId} - Average FPS: ${fps.toFixed(1)}`);
-    }
-  }
-}
-
-async function generator(id: number, worker: FrameWorkerChild) {
-  let frameCount = 0;
-  let lastTime = Date.now();
-  let fpsCounter = 0;
-
-  console.log(`Starting generator ${id}`);
-
-  try {
-    for await (const frame of worker.generateFrames()) {
-      frameCount++;
-      fpsCounter++;
-
-      // Alle Sekunde FPS ausgeben
-      const currentTime = Date.now();
-      if (currentTime - lastTime >= 1000) {
-        const fps = fpsCounter;
-        console.log(`${id}) Current FPS: ${fps}`);
-        fpsCounter = 0;
-        lastTime = currentTime;
-      }
-
-      console.log(`${id}) Frame timestamp=${frame.timestamp}, length=${frame.data.length}, frame=${frameCount}`);
-    }
-  } catch (error) {
-    console.error(`Generator ${id} error:`, error);
-  }
-}
-
-async function generator2(id: number, worker: FrameWorkerChild) {
-  let frameCount = 0;
-  const frameTimestamps: number[] = [];
-  const windowSize = 30; // Anzahl der Frames für den Durchschnitt
-
-  console.log(`Starting generator ${id}`);
-
-  try {
-    for await (const frame of worker.generateFrames({
-      crop: { left: 0, top: 0, width: 300, height: 300 },
-      resize: { width: 100, height: 100 },
-      format: { to: 'gray' },
-    })) {
-      frameCount++;
-      const now = Date.now();
-
-      // Füge aktuellen Timestamp hinzu
-      frameTimestamps.push(now);
-
-      // Entferne alte Timestamps außerhalb des Fensters
-      while (frameTimestamps.length > windowSize) {
-        frameTimestamps.shift();
-      }
-
-      // Berechne FPS über das Zeitfenster
-      if (frameTimestamps.length >= 2) {
-        const timeWindow = (frameTimestamps[frameTimestamps.length - 1] - frameTimestamps[0]) / 1000;
-        const fps = (frameTimestamps.length - 1) / timeWindow;
-
-        // Nur jede Sekunde ausgeben
-        if (frameCount % 10 === 0) {
-          console.log(`${id}) Average FPS: ${fps.toFixed(1)}, Current frame length: ${frame.data.length}`);
-        }
-      }
-
-      console.log(`${id}) Frame timestamp=${frame.timestamp}, length=${frame.data.length}, frame=${frameCount}`);
-    }
-  } catch (error) {
-    console.error(`Generator ${id} error:`, error);
-  }
-}
-
-async function generator3(id: number, worker: FrameWorkerChild, fpsMonitor: FPSMonitor) {
-  let frameCount = 0;
-  console.log(`Starting generator ${id}`);
-
-  try {
-    for await (const frame of worker.generateFrames()) {
-      frameCount++;
-      fpsMonitor.addFrame(id);
-      console.log(`${id}) Frame timestamp=${frame.timestamp}, length=${frame.data.length}, frame=${frameCount}`);
-    }
-  } catch (error) {
-    console.error(`Generator ${id} error:`, error);
-  }
-}
-
-async function test() {
-  try {
-    await imageUtils.initiate();
-
-    const worker = new FrameWorkerChild(config, imageUtils);
-
-    // Start beide Generatoren parallel
-    // await Promise.all([generator(1, worker), generator(2, worker)]);
-    // await generator2(1, worker);
-    await generator3(1, worker, new FPSMonitor());
-  } catch (error) {
-    logger.error('Error:', error);
-  }
-}
-
-// Process Event Handler für sauberes Beenden
-process.on('SIGINT', () => {
-  console.log('Received SIGINT. Cleaning up...');
-  process.exit(0);
-});
-
-process.on('SIGTERM', () => {
-  console.log('Received SIGTERM. Cleaning up...');
-  process.exit(0);
-});
-
-test().catch(logger.error);

package/src/decoder/types.ts

@@ -1,27 +0,0 @@
-import type { AuthConfig } from '@camera.ui/rpc-common';
-import type { CameraFrameWorkerDecoder, CameraFrameWorkerResolution, DecoderFormat, FrameBuffer, FrameData, ImageOptions } from '@camera.ui/types';
-
-export type PixelFormat = 'yuv420p' | 'rgb24' | 'nv12';
-
-export interface BaseFrameWorkerConfig {
-  cameraId: string;
-  cameraName: string;
-  cameraSource: string;
-  ffmpegPath: string;
-  auth: AuthConfig;
-  proxyEndpoints: string[];
-  fps: number;
-  resolution: CameraFrameWorkerResolution;
-  decoder: CameraFrameWorkerDecoder;
-}
-
-export interface WorkerToMainMessage {
-  message: 'started';
-  data: Record<string, any>;
-}
-
-export interface FrameWorkerInterface {
-  generateFrames(options?: ImageOptions): AsyncGenerator<FrameData>;
-  processFrame(frame: Buffer | Uint8Array, width: number, height: number, format: DecoderFormat | 'rgba' | 'gray', options: ImageOptions): Promise<FrameBuffer>;
-  getPrebufferedFrame(timestamp: number, options?: ImageOptions, maxDifference?: number): Promise<FrameData | undefined>;
-}