@camstack/addon-webrtc-adaptive 0.1.7 → 0.1.9

package/dist/index.d.cts

@@ -0,0 +1,378 @@
+import { V as VideoCodec, L as Logger, F as FrameSource, a as VideoFrame, A as AudioFrame, E as EncodingParams } from './addon--i9xjbhN.cjs';
+export { b as AdaptiveController, c as AdaptiveControllerOptions, d as AdaptiveFfmpegSource, e as AdaptiveFfmpegSourceOptions, f as AdaptiveSession, g as AdaptiveSessionOptions, h as AdaptiveStreamServer, i as AdaptiveStreamServerOptions, j as AudioCodec, k as AudioMode, C as CameraConfig, l as FrameSourceFactory, m as LoggerLike, M as MediaFrame, Q as QualityProfile, n as QualityTier, S as SessionInfo, o as SessionStats, p as StreamStats, W as WebrtcAdaptiveAddon, q as asLogger, r as createDefaultProfiles, s as createNullLogger } from './addon--i9xjbhN.cjs';
+import { ChildProcess } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import '@camstack/types';
+
+/**
+ * NAL unit parsing utilities.
+ * Protocol-agnostic functions for working with Annex-B NAL units.
+ */
+
+/**
+ * Returns true if the buffer starts with an Annex-B start code (0x00000001 or 0x000001).
+ */
+declare function hasStartCodes(data: Buffer): boolean;
+/**
+ * Split Annex-B data into individual NAL unit payloads (without start codes).
+ * Works for both H.264 and H.265.
+ */
+declare function splitAnnexBToNals(annexB: Buffer): Buffer[];
+/**
+ * Prepend a 4-byte Annex-B start code to a NAL payload.
+ */
+declare function prependStartCode(nal: Buffer): Buffer;
+/**
+ * Join multiple NAL payloads (without start codes) into an Annex-B access unit.
+ */
+declare function joinNalsToAnnexB(...nals: Array<Buffer | null | undefined>): Buffer | undefined;
+/**
+ * Detect the actual video codec from raw NAL data.
+ * Some cameras report wrong codec (e.g. "H264" but send H.265 data).
+ * Analyzes the NAL header to determine the real codec.
+ *
+ * @param data - Raw video data (either Annex-B or length-prefixed)
+ * @returns Detected codec type or null if detection fails
+ */
+declare function detectVideoCodecFromNal(data: Buffer): VideoCodec | null;
+
+/**
+ * H.264/AVC utilities.
+ * AVCC to Annex-B conversion, SPS/PPS extraction, keyframe detection, RTP depacketization.
+ */
+/**
+ * Convert H.264 data from length-prefixed (AVCC) to Annex-B (start codes).
+ * If already Annex-B, returns as-is.
+ */
+declare function convertH264ToAnnexB(data: Buffer): Buffer;
+/**
+ * Check if an H.264 Annex-B access unit is a keyframe (IDR + SPS + PPS).
+ */
+declare function isH264KeyframeAnnexB(annexB: Buffer): boolean;
+/**
+ * Check if an H.264 Annex-B access unit contains an IDR slice.
+ */
+declare function isH264IdrAccessUnit(annexB: Buffer): boolean;
+/**
+ * Extract SPS and PPS from an H.264 Annex-B access unit.
+ */
+declare function extractH264ParamSets(annexB: Buffer): {
+    sps?: Buffer;
+    pps?: Buffer;
+    profileLevelId?: string;
+};
+/**
+ * H.264 RTP depacketizer (RFC 6184).
+ * Handles single NAL units, STAP-A aggregation, and FU-A/FU-B fragmentation.
+ * Returns complete NAL units in Annex-B format (with start codes).
+ */
+declare class H264RtpDepacketizer {
+    private fuNalHeader;
+    private fuParts;
+    private static parseRtpPayload;
+    reset(): void;
+    push(payload: Buffer): Buffer[];
+}
+
+/**
+ * H.265/HEVC utilities.
+ * HVCC to Annex-B conversion, VPS/SPS/PPS extraction, keyframe detection, RTP depacketization.
+ */
+/**
+ * Convert H.265 data from length-prefixed (HVCC) to Annex-B (start codes).
+ * If already Annex-B, returns as-is.
+ */
+declare function convertH265ToAnnexB(data: Buffer): Buffer;
+/**
+ * Get H.265 NAL unit type from a NAL payload (without start code).
+ */
+declare function getH265NalType(nalPayload: Buffer): number | null;
+/**
+ * Check if an H.265 NAL unit type is an IRAP (Intra Random Access Point) picture.
+ * IRAP types: BLA (16-18), IDR (19-20), CRA (21).
+ */
+declare function isH265Irap(nalType: number): boolean;
+/**
+ * Check if an H.265 Annex-B access unit is a keyframe (IRAP + VPS + SPS + PPS).
+ */
+declare function isH265KeyframeAnnexB(annexB: Buffer): boolean;
+/**
+ * Check if an H.265 Annex-B access unit contains an IRAP picture.
+ */
+declare function isH265IrapAccessUnit(annexB: Buffer): boolean;
+/**
+ * Extract VPS, SPS, and PPS from an H.265 Annex-B access unit.
+ */
+declare function extractH265ParamSets(annexB: Buffer): {
+    vps?: Buffer;
+    sps?: Buffer;
+    pps?: Buffer;
+};
+/**
+ * H.265 RTP depacketizer (RFC 7798).
+ * Handles single NAL units, AP aggregation, and FU fragmentation.
+ * Returns complete NAL units in Annex-B format (with start codes).
+ */
+declare class H265RtpDepacketizer {
+    private fuParts;
+    private static parseRtpPayload;
+    reset(): void;
+    push(payload: Buffer): Buffer[];
+}
+
+/**
+ * Stream fan-out utilities.
+ * Distribute a single source stream to multiple consumers with bounded queues.
+ */
+/**
+ * Async bounded queue with push/pull interface.
+ * When the queue is full, the oldest items are dropped (tail-drop).
+ */
+declare class AsyncBoundedQueue<T> {
+    private readonly maxItems;
+    private readonly queue;
+    private waiting;
+    private closed;
+    constructor(maxItems: number);
+    push(item: T): void;
+    close(): void;
+    next(): Promise<IteratorResult<T>>;
+    isClosed(): boolean;
+    size(): number;
+}
+interface StreamFanoutOptions<T> {
+    /** Maximum items per subscriber queue before tail-drop */
+    maxQueueItems: number;
+    /** Factory to create the source stream */
+    createSource: () => AsyncGenerator<T, void, unknown>;
+    /** Optional callback for each frame (e.g. for extracting metadata) */
+    onFrame?: (frame: T) => void;
+    /** Optional error handler */
+    onError?: (error: unknown) => void;
+}
+/**
+ * Fan-out a single async generator source to multiple subscribers.
+ * The source stream is started when start() is called and frames are
+ * distributed to all active subscriber queues.
+ */
+declare class StreamFanout<T> {
+    private readonly opts;
+    private readonly queues;
+    private source;
+    private running;
+    private pumpPromise;
+    constructor(opts: StreamFanoutOptions<T>);
+    /** Start pumping frames from the source to all subscribers. */
+    start(): void;
+    /**
+     * Create a subscriber async generator.
+     * Returns an async generator that yields frames from the shared source.
+     * The generator terminates when the source ends or unsubscribe is called.
+     */
+    subscribe(id: string): AsyncGenerator<T, void, unknown>;
+    /** Unsubscribe a specific subscriber. */
+    unsubscribe(id: string): void;
+    /** Stop the source and close all subscriber queues. */
+    stop(): Promise<void>;
+    /** Returns true if the fan-out is running. */
+    isRunning(): boolean;
+    /** Returns the number of active subscribers. */
+    subscriberCount(): number;
+}
+
+/**
+ * FFmpeg process lifecycle management.
+ * Spawn and manage FFmpeg processes with proper cleanup.
+ */
+
+interface FfmpegProcessOptions {
+    /** FFmpeg binary path (default: "ffmpeg") */
+    ffmpegPath?: string;
+    /** FFmpeg arguments */
+    args: string[];
+    /** Logger instance */
+    logger?: Logger;
+    /** Label for log messages */
+    label?: string;
+    /** Additional stdio configuration (e.g. ["pipe"] for pipe:3) */
+    extraStdio?: Array<"pipe" | "ignore" | "inherit">;
+    /** Callback when process exits */
+    onExit?: (code: number | null, signal: string | null) => void;
+    /** Callback for stderr output */
+    onStderr?: (data: string) => void;
+}
+/**
+ * Managed FFmpeg process with proper lifecycle handling.
+ */
+declare class FfmpegProcess {
+    private readonly options;
+    private process;
+    private killed;
+    private readonly logger;
+    private readonly label;
+    constructor(options: FfmpegProcessOptions);
+    /** Spawn the FFmpeg process. Returns stdin writable stream. */
+    start(): NodeJS.WritableStream | null;
+    /** Get a specific stdio stream by fd index (e.g. 3 for pipe:3). */
+    getStdio(fd: number): NodeJS.ReadableStream | NodeJS.WritableStream | null;
+    /** Get the underlying ChildProcess. */
+    getProcess(): ChildProcess | null;
+    /** Kill the FFmpeg process gracefully (SIGTERM then SIGKILL after timeout). */
+    kill(timeoutMs?: number): Promise<void>;
+    /** Check if the process is running. */
+    isRunning(): boolean;
+}
+
+/**
+ * Frame source adapters.
+ * Convert various input patterns (EventEmitter, push callbacks) into FrameSource async generators.
+ */
+
+/**
+ * Convert an EventEmitter-based source into a FrameSource async generator.
+ *
+ * @param emitter - The event emitter that fires video/audio frames
+ * @param videoEvent - Event name for video frames (default: "videoFrame")
+ * @param audioEvent - Event name for audio frames (default: "audioFrame")
+ */
+declare function fromEventEmitter(emitter: EventEmitter, videoEvent?: string, audioEvent?: string): FrameSource;
+/**
+ * Create a push-based frame source.
+ * Returns a FrameSource async generator and push functions to deliver frames.
+ */
+declare function fromPushCallback(): {
+    source: FrameSource;
+    pushVideo: (frame: VideoFrame) => void;
+    pushAudio: (frame: AudioFrame) => void;
+    close: () => void;
+};
+/**
+ * Create a FrameSource from a raw async generator of { audio, data, codec, videoType, ... } frames.
+ * This is the format used by reolink-baichuan-js's createNativeStream().
+ */
+declare function fromNativeStream(native: AsyncGenerator<{
+    audio: boolean;
+    data: Buffer;
+    codec: string | null;
+    sampleRate: number | null;
+    microseconds: number | null;
+    videoType?: string;
+    isKeyframe?: boolean;
+}, void, unknown>): FrameSource;
+
+/**
+ * Adaptive RTSP relay — transcodes an RTSP source via ffmpeg and outputs
+ * a local RTSP stream that can be registered in go2rtc for WebRTC delivery.
+ *
+ * This avoids werift's SRTP/DTLS issues by letting go2rtc handle the
+ * browser-facing WebRTC connection while we control the transcoding.
+ *
+ * Pipeline: Camera RTSP → ffmpeg (adaptive params) → RTSP localhost → go2rtc → WHEP → Browser
+ */
+
+interface AdaptiveRtspRelayOptions {
+    /** RTSP source URL (camera or upstream go2rtc). */
+    rtspUrl: string;
+    /** Local RTSP output URL (e.g. rtsp://127.0.0.1:8554/adaptive_ingresso_main). */
+    rtspOutputUrl: string;
+    /** Initial encoding parameters. */
+    initialParams: EncodingParams;
+    /** FFmpeg binary path (default: "ffmpeg"). */
+    ffmpegPath?: string;
+    /** Logger. */
+    logger?: Logger;
+    /** Label for logging. */
+    label?: string;
+}
+declare class AdaptiveRtspRelay {
+    private readonly rtspUrl;
+    private readonly rtspOutputUrl;
+    private readonly ffmpegPath;
+    private readonly logger;
+    private readonly label;
+    private currentParams;
+    private proc;
+    private closed;
+    constructor(options: AdaptiveRtspRelayOptions);
+    getParams(): Readonly<EncodingParams>;
+    /** Start the ffmpeg relay. */
+    start(): void;
+    /** Hot-swap encoding parameters by restarting ffmpeg. */
+    updateParams(params: Partial<EncodingParams>): Promise<void>;
+    /** Stop the relay. */
+    stop(): Promise<void>;
+    /** Check if ffmpeg is running. */
+    isRunning(): boolean;
+    private spawnFfmpeg;
+    private killFfmpeg;
+}
+
+/**
+ * SharedSession — single RTCPeerConnection with multiple dynamic video tracks.
+ *
+ * One connection per client. Tracks are added/removed via data channel messages.
+ * Each track corresponds to one camera's ffmpeg source.
+ *
+ * Protocol (data channel JSON messages):
+ *
+ * Client → Server:
+ *   { type: "addTrack", cameraName: string, trackId: string }
+ *   { type: "removeTrack", trackId: string }
+ *   { type: "answer", sdp: string }
+ *
+ * Server → Client:
+ *   { type: "offer", sdp: string }
+ *   { type: "trackReady", trackId: string, mid: string }
+ *   { type: "trackRemoved", trackId: string }
+ *   { type: "error", message: string }
+ */
+
+interface SharedSessionOptions {
+    iceConfig?: {
+        stunServers?: string[];
+        turnServers?: Array<{
+            urls: string;
+            username?: string;
+            credential?: string;
+        }>;
+        portRange?: [number, number];
+        additionalHostAddresses?: string[];
+    };
+    /** Called when the server needs to attach a camera source for a track. */
+    onTrackRequested: (cameraName: string) => FrameSource | null;
+    /** Called when a track is removed. */
+    onTrackReleased?: (cameraName: string) => void;
+    /** Called when intercom audio is received from the client for a camera. */
+    onIntercomAudio?: (cameraName: string, data: Buffer) => void;
+    logger: Logger;
+}
+declare class SharedSession {
+    private readonly options;
+    private readonly logger;
+    private readonly iceConfig;
+    private readonly onTrackRequested;
+    private readonly onTrackReleased;
+    private pc;
+    private dataChannel;
+    private readonly activeTracks;
+    private closed;
+    private negotiating;
+    constructor(options: SharedSessionOptions);
+    /** Create the initial SDP offer (with data channel, no media tracks yet). */
+    createOffer(): Promise<string>;
+    /** Handle the client's SDP answer. */
+    handleAnswer(sdpAnswer: string): Promise<void>;
+    /** Close the shared session and all tracks. */
+    close(): Promise<void>;
+    private handleDataChannelMessage;
+    private handleAddTrack;
+    private handleRemoveTrack;
+    private handleRenegotiationAnswer;
+    private renegotiate;
+    private startFeeding;
+    private sendDC;
+    get isConnected(): boolean;
+    get trackCount(): number;
+}
+
+export { AdaptiveRtspRelay, type AdaptiveRtspRelayOptions, AsyncBoundedQueue, AudioFrame, EncodingParams, FfmpegProcess, type FfmpegProcessOptions, FrameSource, H264RtpDepacketizer, H265RtpDepacketizer, SharedSession, type SharedSessionOptions, StreamFanout, type StreamFanoutOptions, VideoCodec, Logger as WebRtcLogger, VideoFrame as WebRtcVideoFrame, convertH264ToAnnexB, convertH265ToAnnexB, detectVideoCodecFromNal, extractH264ParamSets, extractH265ParamSets, fromEventEmitter, fromNativeStream, fromPushCallback, getH265NalType, hasStartCodes, isH264IdrAccessUnit, isH264KeyframeAnnexB, isH265Irap, isH265IrapAccessUnit, isH265KeyframeAnnexB, joinNalsToAnnexB, prependStartCode, splitAnnexBToNals };