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

package/src/camera/session.ts

@@ -1,192 +0,0 @@
-import { sleep, Subscribed } from '@camera.ui/common/utils';
-import { RTSPClient } from '@camera.ui/rtsp/rtspClient';
-import { ReplaySubject } from 'rxjs';
-
-import type { CameraDeviceSource } from '@camera.ui/types';
-import type { CameraController } from './controller.js';
-
-export class Session {
-  readonly onStarted = new ReplaySubject<void>();
-  readonly onError = new ReplaySubject<Error>();
-  readonly onConnected = new ReplaySubject<void>();
-  readonly onCallEnded = new ReplaySubject<void>(1);
-
-  private client: RTSPClient;
-  private isStopped = false;
-  private hasEnded = false;
-
-  constructor(
-    private camera: CameraController,
-    private source: CameraDeviceSource,
-  ) {
-    this.client = new RTSPClient({ url: this.source.urls.rtsp.muted, readOnly: true });
-    this.bindConnection();
-  }
-
-  public async start() {
-    if (!this.camera.connected || this.isStopped) {
-      return;
-    }
-
-    this.hasEnded = false;
-    await this.client.start();
-  }
-
-  public async stop() {
-    this.isStopped = true;
-    await this.callEnded();
-  }
-
-  private bindConnection(): void {
-    this.client.onPlay.subscribe(this.onConnected);
-    this.client.onClose.subscribe((error) => {
-      if (error) {
-        this.callError(error);
-      } else {
-        this.callEnded();
-      }
-    });
-  }
-
-  private async callError(error: Error): Promise<void> {
-    this.onError.next(error);
-    await this.callEnded();
-  }
-
-  private async callEnded(): Promise<void> {
-    if (this.hasEnded) {
-      return;
-    }
-
-    this.hasEnded = true;
-
-    await this.client.close();
-    this.onCallEnded.next();
-  }
-}
-
-export class SessionController extends Subscribed {
-  private readonly sessions = new Map<string, Session>();
-  private killed = false;
-  private restartTimer = 60000;
-
-  constructor(private camera: CameraController) {
-    super();
-
-    this.setupEventListeners();
-  }
-
-  public start(sources: CameraDeviceSource[]): void {
-    if (!this.camera.connected) {
-      this.camera.logger.debug('Camera not connected, hot mode will not start');
-      this.stop();
-      return;
-    }
-
-    this.removeOrphanedSessions(sources);
-    this.createNewSessions(sources);
-  }
-
-  public stop(): void {
-    this.killed = true;
-    this.unsubscribe();
-    this.stopSessions();
-  }
-
-  private setupEventListeners(): void {
-    this.addSubscriptions(
-      this.camera.onPropertyChange('sources').subscribe(() => {
-        if (this.killed) {
-          return;
-        }
-        this.start(this.camera.sources);
-      }),
-
-      this.camera.onConnected.subscribe((connected) => {
-        if (connected) {
-          this.start(this.camera.sources);
-        } else {
-          this.stopSessions();
-        }
-      }),
-    );
-  }
-
-  private async startSession(source: CameraDeviceSource, session: Session): Promise<void> {
-    if (!this.canStartSession(source)) {
-      this.camera.logger.debug(`[${source.name}] Skipping hot mode start`);
-      return;
-    }
-
-    try {
-      this.camera.logger.debug(`[${source.name}] Starting hot mode...`);
-      await session.start();
-    } catch (error) {
-      this.camera.logger.debug(`[${source.name}] Failed to start hot mode:`, error.message);
-    }
-  }
-
-  private setupEventListener(source: CameraDeviceSource, session: Session): void {
-    this.addSubscriptions(
-      session.onConnected.subscribe(() => {
-        this.camera.logger.debug(`[${source.name}] Hot mode started`);
-      }),
-      session.onError.subscribe((error) => {
-        this.camera.logger.debug(`[${source.name}] Hot mode error:`, error.message);
-      }),
-      session.onCallEnded.subscribe(async () => {
-        this.camera.logger.debug(`[${source.name}] Hot mode stopped`);
-
-        if (!this.canStartSession(source)) {
-          return;
-        }
-
-        try {
-          await sleep(this.restartTimer);
-          await this.startSession(source, session);
-        } catch (error) {
-          this.camera.logger.debug(`[${source.name}] Failed to restart hot mode:`, error.message);
-        }
-      }),
-    );
-  }
-
-  private async removeOrphanedSessions(sources: CameraDeviceSource[]): Promise<void> {
-    for (const [id, session] of this.sessions.entries()) {
-      const source = sources.find((source) => source._id === id);
-      if (source && !this.canStartSession(source)) {
-        await session.stop();
-        this.sessions.delete(id);
-      }
-    }
-  }
-
-  private createNewSessions(sources: CameraDeviceSource[]): void {
-    for (const source of sources) {
-      if (source.role !== 'snapshot' && source.hotMode && !this.sessions.has(source._id)) {
-        const session = new Session(this.camera, source);
-        this.sessions.set(source._id, session);
-        this.setupEventListener(source, session);
-        this.startSession(source, session);
-      }
-    }
-  }
-
-  private stopSessions(): void {
-    for (const session of this.sessions.values()) {
-      session.stop();
-    }
-  }
-
-  private canStartSession(source: CameraDeviceSource): boolean {
-    const cameraSource = this.camera.sources.find((s) => s._id === source._id);
-    return (
-      !this.killed &&
-      this.camera.connected &&
-      cameraSource !== undefined &&
-      cameraSource.hotMode &&
-      cameraSource.role !== 'snapshot' &&
-      this.sessions.has(cameraSource._id)
-    );
-  }
-}

package/src/camera/streaming/fmp4-session.ts

@@ -1,390 +0,0 @@
-import { FfmpegProcess, generateAudioStreamInfo, generateSdp, generateVideoStreamInfo, parseMp4Fragment, reservePorts, RtpSplitter } from '@camera.ui/common/camera';
-import { getCleanSdp, SubscribedPublic } from '@camera.ui/common/utils';
-import { RTSPClient } from '@camera.ui/rtsp/rtspClient';
-import { firstValueFrom, ReplaySubject, Subject } from 'rxjs';
-import { take, tap } from 'rxjs/operators';
-import { WebSocket } from 'ws';
-
-import type {
-  AudioStreamInfo,
-  CameraDeviceSource,
-  CameraInput,
-  FMP4ConnectionOptions,
-  FMP4Session as FMP4SessionInterface,
-  Fragment,
-  FragmentedFfmpegOptions,
-  LoggerService,
-  VideoStreamInfo,
-} from '@camera.ui/types';
-import type { CameraDevice } from '../device.js';
-
-export class FMP4Session extends SubscribedPublic implements FMP4SessionInterface {
-  readonly onStarted = new ReplaySubject<void>();
-  readonly onError = new ReplaySubject<Error>();
-  readonly onCallEnded = new ReplaySubject<void>(1);
-  readonly onFragment = new Subject<Fragment>();
-
-  readonly #audioSplitter = new RtpSplitter();
-  readonly #videoSplitter = new RtpSplitter();
-
-  #hasEnded = false;
-  #cameraDevice: CameraDevice;
-  #logger: LoggerService;
-  #source: CameraDeviceSource;
-
-  #client: RTSPClient;
-  #ws: WebSocket | null = null;
-
-  #ftypSegment?: Buffer;
-  #moovSegment?: Buffer;
-  #initSegment?: Buffer;
-
-  #logPrefix = '[fMP4]';
-
-  #initSegmentSubject = new ReplaySubject<Buffer>(1);
-
-  get initSegment(): Promise<Buffer> {
-    return firstValueFrom(this.#initSegmentSubject);
-  }
-
-  constructor(cameraDevice: CameraDevice, source: CameraInput, options?: FMP4ConnectionOptions) {
-    super();
-
-    this.#cameraDevice = cameraDevice;
-    this.#logger = cameraDevice.logger;
-    this.#source = this.#cameraDevice.sources.find((s) => s.name === source.name)!;
-
-    const url = options?.url ?? this.#source.generateRTSPUrl();
-
-    this.#client = new RTSPClient(
-      { url },
-      {
-        // log: (...args) => this.#logger.log(...args),
-        error: (...args) => this.#logger.error(...args),
-        // debug: (...args) => this.#logger.trace(...args),
-        warn: (...args) => this.#logger.warn(...args),
-      },
-    );
-  }
-
-  public startStream(): void {
-    if (this.#hasEnded) {
-      return;
-    }
-
-    const wsUrl = new URL(this.#source.urls.ws.mse);
-    this.#ws = new WebSocket(wsUrl.toString(), {
-      rejectUnauthorized: false,
-    });
-
-    this.#ws.binaryType = 'arraybuffer';
-
-    this.#ws.onopen = () => {
-      this.#ws?.send(
-        JSON.stringify({
-          type: 'mse',
-          value: {
-            value: 'avc1.640029,avc1.64002A,avc1.640033,hvc1.1.6.L153.B0,mp4a.40.2,mp4a.40.5,flac,opus',
-            fragmentMode: 'keyframe',
-          },
-        }),
-      );
-    };
-
-    this.#ws.onmessage = (event) => {
-      if (typeof event.data === 'string') {
-        const message = JSON.parse(event.data);
-        if (message.type === 'mse') {
-          this.#logger.debug(this.#logPrefix, 'Received codec info:', message.value);
-          this.onStarted.next();
-        } else if (message.type === 'error') {
-          this.#callError(new Error(message.value));
-        }
-      } else {
-        if (event.data instanceof ArrayBuffer) {
-          this.#handleFragment(Buffer.from(event.data));
-        } else if (Buffer.isBuffer(event.data)) {
-          this.#handleFragment(event.data);
-        } else {
-          event.data.forEach((fragment) => this.#handleFragment(fragment));
-        }
-      }
-    };
-
-    this.#ws.onerror = (error) => {
-      this.#callError(error.error);
-    };
-
-    this.#ws.onclose = () => {
-      this.#callEnded();
-    };
-  }
-
-  public async startTranscoding(ffmpegOptions: FragmentedFfmpegOptions): Promise<void> {
-    if (this.#hasEnded) {
-      return;
-    }
-
-    const transcodeAudioStream = ffmpegOptions.audio !== undefined && ffmpegOptions.audio.length > 0;
-    const transcodeVideoStream = ffmpegOptions.video !== undefined && ffmpegOptions.video.length > 0;
-
-    const loggerPrefix = ffmpegOptions?.logPrefix ? `[${ffmpegOptions.logPrefix}] ` : `[${this.#logPrefix}] `;
-
-    try {
-      if (!transcodeAudioStream && !transcodeVideoStream) {
-        throw new Error('No transcoding options provided! Can not start transcoding!');
-      }
-
-      await this.#client.start();
-
-      const audioTrack = this.#client.getAudioTrack();
-      const videoTrack = this.#client.getVideoTrack();
-
-      if (!audioTrack && !videoTrack) {
-        throw new Error('No audio or video tracks found! Can not start transcoding!');
-      }
-
-      await this.#audioSplitter.prepare('udp4');
-      await this.#videoSplitter.prepare('udp4');
-
-      if (!this.#audioSplitter.port || !this.#videoSplitter.port) {
-        throw new Error('No ports available for audio and video splitter! Can not start transcoding!');
-      }
-
-      const videoPort = await this.#reservePort(1);
-      const audioPort = await this.#reservePort(1);
-
-      const videoStreamInfos = videoTrack ? generateVideoStreamInfo([videoTrack.mediaSource]) : [];
-      const audioStreamInfos = audioTrack ? generateAudioStreamInfo([audioTrack.mediaSource]) : [];
-      const parsedSdp = generateSdp(videoStreamInfos, audioStreamInfos);
-
-      const audioStream: AudioStreamInfo | undefined = audioStreamInfos[0];
-      const videoStream: VideoStreamInfo | undefined = videoStreamInfos[0];
-
-      const audioInputArgs = audioStream ? ['-acodec', audioStream.ffmpegCodec] : [];
-      const videoInputArgs = videoStream ? ['-vcodec', videoStream.ffmpegCodec] : [];
-
-      const audioOutputArgs = audioTrack && transcodeAudioStream ? (ffmpegOptions.audio ?? ['-acodec', audioStream.ffmpegCodec]) : [];
-      const videoOutputArgs = videoTrack && transcodeVideoStream ? (ffmpegOptions.video ?? ['-vcodec', videoStream.ffmpegCodec]) : [];
-
-      const inputArgs = ffmpegOptions.input ?? [];
-
-      const inputSdp = getCleanSdp(parsedSdp, transcodeVideoStream, 'recvonly')
-        .replace(/m=audio \d+/, `m=audio ${audioPort}`)
-        .replace(/m=video \d+/, `m=video ${videoPort}`);
-
-      this.#logger.trace(loggerPrefix + 'Start transcoding with SDP:\n', inputSdp);
-
-      const ff = new FfmpegProcess({
-        ffmpegArgs: [
-          '-hide_banner',
-          '-protocol_whitelist',
-          'pipe,udp,rtp,file,crypto',
-          '-reorder_queue_size',
-          '0',
-          ...audioInputArgs,
-          ...videoInputArgs,
-          '-f',
-          'sdp',
-          ...inputArgs,
-          '-i',
-          'pipe:',
-          ...audioOutputArgs,
-          ...videoOutputArgs,
-          '-fflags',
-          '+genpts',
-          '-reset_timestamps',
-          '1',
-          '-movflags',
-          'frag_keyframe+empty_moov+default_base_moof',
-          '-f',
-          'mp4',
-          '-',
-        ],
-        ffmpegPath: ffmpegOptions.ffmpegPath,
-        startedCallback: () => {
-          this.onStarted.next();
-        },
-        bufferOptions: {
-          checkSize: (buffer: Buffer): number => {
-            if (buffer.length < 8) return 0;
-
-            const size = buffer.readUInt32BE(0);
-            if (size === 0 || size > buffer.length) return 0;
-
-            const boxType = buffer.toString('utf8', 4, 8);
-            if (boxType === 'moof') {
-              if (buffer.length < size + 8) return 0;
-
-              const nextSize = buffer.readUInt32BE(size);
-              const nextBoxType = buffer.toString('utf8', size + 4, size + 8);
-
-              if (nextBoxType === 'mdat') {
-                const totalSize = size + nextSize;
-                return buffer.length >= totalSize ? totalSize : 0;
-              }
-            }
-
-            return size;
-          },
-          onData: (data: Buffer) => {
-            this.#handleFragment(data, true);
-          },
-        },
-        exitCallback: (code, signal) => {
-          if (code !== 0 && code !== 255) {
-            this.#callError(new Error(`FFmpeg exited with code ${code} and signal ${signal}`));
-          } else {
-            this.#callEnded();
-          }
-        },
-        logLabel: loggerPrefix,
-        logger: {
-          error: (...args) => this.#logger.error(...args),
-          trace: () => {},
-          // trace: (...args) => this.#logger.trace(...args),
-        },
-      });
-
-      if (transcodeAudioStream) {
-        this.addSubscriptions(
-          this.#client.onAudioRtp
-            .pipe(
-              tap((rtp) => {
-                return this.#audioSplitter.send(rtp.serialize(), {
-                  port: audioPort,
-                  address: '127.0.0.1',
-                });
-              }),
-            )
-            .subscribe(),
-        );
-      }
-
-      if (transcodeVideoStream) {
-        this.addSubscriptions(
-          this.#client.onVideoRtp
-            .pipe(
-              tap((rtp) => {
-                return this.#videoSplitter.send(rtp.serialize(), {
-                  port: videoPort,
-                  address: '127.0.0.1',
-                });
-              }),
-            )
-            .subscribe(),
-        );
-      }
-
-      this.onCallEnded.pipe(take(1)).subscribe(() => ff.stop());
-
-      ff.writeStdin(inputSdp);
-    } catch (error: any) {
-      this.stop();
-      throw error;
-    }
-  }
-
-  public stop(): void {
-    this.#callEnded();
-  }
-
-  public async *fragments(abortSignal?: AbortSignal): AsyncGenerator<Fragment> {
-    let ended = false;
-
-    const fragmentPromise = () =>
-      new Promise<Fragment>((resolve, reject) => {
-        const subscription = this.onFragment.subscribe((fragment) => {
-          subscription.unsubscribe();
-          resolve(fragment);
-        });
-
-        // Cleanup subscription if session ends
-        this.onCallEnded.pipe(take(1)).subscribe(() => {
-          subscription.unsubscribe();
-          ended = true;
-          reject(new Error('Session ended'));
-        });
-
-        if (abortSignal) {
-          abortSignal.onabort = () => {
-            subscription.unsubscribe();
-            ended = true;
-            reject(new Error('Aborted'));
-          };
-
-          if (abortSignal.aborted) {
-            subscription.unsubscribe();
-            ended = true;
-            reject(new Error('Aborted'));
-          }
-        }
-      });
-
-    while (!this.#hasEnded && !abortSignal?.aborted && !ended) {
-      try {
-        yield await fragmentPromise();
-      } catch {
-        break;
-      }
-    }
-  }
-
-  async #reservePort(bufferPorts = 0): Promise<number> {
-    const ports = await reservePorts({ count: bufferPorts + 1 });
-    return ports[0];
-  }
-
-  #handleFragment(data: Buffer, isFFmpeg?: boolean): void {
-    const info = parseMp4Fragment(data, isFFmpeg);
-
-    // this.#logger.trace(this.#logPrefix, 'Received fragment:', info);
-
-    this.onFragment.next({ data, info });
-
-    let isInitSegment: Buffer | undefined = undefined;
-
-    if (info.isFtyp && info.isMoov) {
-      isInitSegment = data;
-    } else if (info.isFtyp) {
-      this.#ftypSegment = data;
-    } else if (info.isMoov) {
-      this.#moovSegment = data;
-    }
-
-    if (isInitSegment) {
-      this.#initSegment = isInitSegment;
-      this.#initSegmentSubject.next(isInitSegment);
-    }
-
-    if (!this.#initSegment && this.#ftypSegment && this.#moovSegment) {
-      this.#initSegment = Buffer.concat([this.#ftypSegment, this.#moovSegment]);
-      this.#initSegmentSubject.next(this.#initSegment);
-    }
-  }
-
-  #callError(error: Error): void {
-    this.onError.next(error);
-    this.#callEnded();
-  }
-
-  #callEnded(): void {
-    if (this.#hasEnded) {
-      return;
-    }
-
-    this.#initSegment = undefined;
-    this.#initSegmentSubject = new ReplaySubject<Buffer>(1);
-    this.#ftypSegment = undefined;
-    this.#moovSegment = undefined;
-
-    this.#hasEnded = true;
-
-    this.unsubscribe();
-
-    this.#ws?.close();
-    this.#ws = null;
-
-    this.onCallEnded.next();
-  }
-}