node-av-lgpl 0.0.0 → 7.1.0-beta.1

package/dist/api/utilities/scheduler.d.ts

@@ -0,0 +1,138 @@
+import { Muxer } from '../muxer.js';
+import type { Frame, Packet } from '../../lib/index.js';
+import type { BitStreamFilterAPI } from '../bitstream-filter.js';
+import type { Encoder } from '../encoder.js';
+import type { FilterAPI } from '../filter.js';
+export interface SchedulableComponent<TItem = Packet | Frame> {
+    sendToQueue(item: TItem | null): Promise<void>;
+    pipeTo(target: FilterAPI | Encoder | BitStreamFilterAPI | Muxer, streamIndex?: number): any;
+}
+/**
+ * Pipeline scheduler for chaining components.
+ *
+ * Allows piping between components (Decoder → Filter → Encoder → Output).
+ */
+export declare class Scheduler<TSend = Packet | Frame> {
+    private firstComponent;
+    /** @internal */
+    lastComponent: SchedulableComponent<any>;
+    /**
+     * @param firstComponent - First component in the pipeline
+     *
+     * @param lastComponent - Last component in the pipeline (defaults to firstComponent)
+     *
+     * @internal
+     */
+    constructor(firstComponent: SchedulableComponent<TSend>, lastComponent?: SchedulableComponent<any>);
+    /**
+     * Pipe output to a filter component.
+     *
+     * @param target - Filter to receive frames
+     *
+     * @returns Scheduler for continued chaining
+     *
+     * @example
+     * ```typescript
+     * decoder.pipeTo(filter1).pipeTo(filter2)
+     * ```
+     */
+    pipeTo(target: FilterAPI): Scheduler<TSend>;
+    /**
+     * Pipe output to an encoder component.
+     *
+     * @param target - Encoder to receive frames
+     *
+     * @returns Scheduler for continued chaining
+     *
+     * @example
+     * ```typescript
+     * decoder.pipeTo(filter).pipeTo(encoder)
+     * ```
+     */
+    pipeTo(target: Encoder): Scheduler<TSend>;
+    /**
+     * Pipe output to a bitstream filter component.
+     *
+     * @param target - BitStreamFilter to receive packets
+     *
+     * @returns Scheduler for continued chaining
+     *
+     * @example
+     * ```typescript
+     * decoder.pipeTo(encoder).pipeTo(bsf).pipeTo(output, 0)
+     * ```
+     */
+    pipeTo(target: BitStreamFilterAPI): Scheduler<TSend>;
+    /**
+     * Pipe output to a muxer (final stage).
+     *
+     * @param output - Muxer to write to
+     *
+     * @param streamIndex - Stream index in output
+     *
+     * @returns Control interface without pipeTo
+     *
+     * @example
+     * ```typescript
+     * const control = decoder
+     *   .pipeTo(encoder)
+     *   .pipeTo(output, 0);
+     *
+     * await control.send(packet);
+     * ```
+     */
+    pipeTo(output: Muxer, streamIndex: number): SchedulerControl<TSend>;
+    /**
+     * Send an item into the pipeline or flush.
+     *
+     * When item is provided, queues it for processing through the pipeline.
+     * When null is provided, triggers flush sequence through all components.
+     *
+     * @param item - Packet or Frame to process, or null to flush
+     *
+     * @example
+     * ```typescript
+     * // Send packet for processing
+     * await scheduler.send(packet);
+     *
+     * // Flush pipeline
+     * await scheduler.send(null);
+     * ```
+     */
+    send(item: TSend | null): Promise<void>;
+}
+/**
+ * Control interface for completed pipelines.
+ *
+ * Provides control methods without pipeTo() - this is the final
+ * stage after piping to Muxer.
+ *
+ * @template TSend - The input type flowing through the pipeline
+ */
+export declare class SchedulerControl<TSend = Packet | Frame> {
+    private firstComponent;
+    /**
+     * @param firstComponent - First component in the pipeline
+     *
+     * @internal
+     */
+    constructor(firstComponent: SchedulableComponent<TSend>);
+    /**
+     * Send an item into the pipeline or flush.
+     *
+     * When item is provided, queues it for processing through the pipeline.
+     * When null is provided, triggers flush sequence through all components.
+     *
+     * @param item - Packet or Frame to process, or null to flush
+     *
+     * @example
+     * ```typescript
+     * // Send packet for processing
+     * await control.send(packet);
+     *
+     * // Flush pipeline
+     * await control.send(null);
+     * ```
+     */
+    send(item: TSend | null): Promise<void>;
+}

package/dist/api/utilities/scheduler.js

@@ -0,0 +1,98 @@
+import { Muxer } from '../muxer.js';
+/**
+ * Pipeline scheduler for chaining components.
+ *
+ * Allows piping between components (Decoder → Filter → Encoder → Output).
+ */
+export class Scheduler {
+    firstComponent;
+    /** @internal */
+    lastComponent;
+    /**
+     * @param firstComponent - First component in the pipeline
+     *
+     * @param lastComponent - Last component in the pipeline (defaults to firstComponent)
+     *
+     * @internal
+     */
+    constructor(firstComponent, lastComponent) {
+        this.firstComponent = firstComponent;
+        this.lastComponent = lastComponent ?? firstComponent;
+    }
+    pipeTo(target, streamIndex) {
+        if (typeof this.lastComponent.pipeTo === 'function') {
+            if (target instanceof Muxer) {
+                // Start the pipe task (encoder -> output)
+                this.lastComponent.pipeTo(target, streamIndex);
+                // Return control with correct firstComponent (not lastComponent!)
+                return new SchedulerControl(this.firstComponent);
+            }
+            else {
+                const resultScheduler = this.lastComponent.pipeTo(target);
+                // Keep the original firstComponent, update to new lastComponent
+                return new Scheduler(this.firstComponent, resultScheduler.lastComponent);
+            }
+        }
+        throw new Error('Last component does not support pipeTo');
+    }
+    /**
+     * Send an item into the pipeline or flush.
+     *
+     * When item is provided, queues it for processing through the pipeline.
+     * When null is provided, triggers flush sequence through all components.
+     *
+     * @param item - Packet or Frame to process, or null to flush
+     *
+     * @example
+     * ```typescript
+     * // Send packet for processing
+     * await scheduler.send(packet);
+     *
+     * // Flush pipeline
+     * await scheduler.send(null);
+     * ```
+     */
+    async send(item) {
+        await this.firstComponent.sendToQueue(item);
+    }
+}
+/**
+ * Control interface for completed pipelines.
+ *
+ * Provides control methods without pipeTo() - this is the final
+ * stage after piping to Muxer.
+ *
+ * @template TSend - The input type flowing through the pipeline
+ */
+export class SchedulerControl {
+    firstComponent;
+    /**
+     * @param firstComponent - First component in the pipeline
+     *
+     * @internal
+     */
+    constructor(firstComponent) {
+        this.firstComponent = firstComponent;
+    }
+    /**
+     * Send an item into the pipeline or flush.
+     *
+     * When item is provided, queues it for processing through the pipeline.
+     * When null is provided, triggers flush sequence through all components.
+     *
+     * @param item - Packet or Frame to process, or null to flush
+     *
+     * @example
+     * ```typescript
+     * // Send packet for processing
+     * await control.send(packet);
+     *
+     * // Flush pipeline
+     * await control.send(null);
+     * ```
+     */
+    async send(item) {
+        await this.firstComponent.sendToQueue(item);
+    }
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/api/utilities/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../../../src/api/utilities/scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAYpC;;;;GAIG;AACH,MAAM,OAAO,SAAS;IACZ,cAAc,CAA8B;IAEpD,gBAAgB;IAChB,aAAa,CAA4B;IAEzC;;;;;;OAMG;IACH,YAAY,cAA2C,EAAE,aAAyC;QAChG,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QACrC,IAAI,CAAC,aAAa,GAAG,aAAa,IAAI,cAAc,CAAC;IACvD,CAAC;IAgED,MAAM,CAAC,MAAwD,EAAE,WAAoB;QACnF,IAAI,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YACpD,IAAI,MAAM,YAAY,KAAK,EAAE,CAAC;gBAC5B,0CAA0C;gBAC1C,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;gBAC/C,kEAAkE;gBAClE,OAAO,IAAI,gBAAgB,CAAQ,IAAI,CAAC,cAAc,CAAC,CAAC;YAC1D,CAAC;iBAAM,CAAC;gBACN,MAAM,eAAe,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBAC1D,gEAAgE;gBAChE,OAAO,IAAI,SAAS,CAAQ,IAAI,CAAC,cAAc,EAAE,eAAe,CAAC,aAAa,CAAC,CAAC;YAClF,CAAC;QACH,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;IAC5D,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,IAAI,CAAC,IAAkB;QAC3B,MAAM,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,OAAO,gBAAgB;IACnB,cAAc,CAA8B;IAEpD;;;;OAIG;IACH,YAAY,cAA2C;QACrD,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACvC,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,IAAI,CAAC,IAAkB;QAC3B,MAAM,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;CACF"}

package/dist/api/utilities/streaming.d.ts

@@ -0,0 +1,186 @@
+import { FormatContext } from '../../lib/format-context.js';
+import type { AVCodecID } from '../../constants/index.js';
+import type { Muxer } from '../muxer.js';
+/**
+ * Streaming protocol utilities.
+ *
+ * Provides static methods for SDP generation, RTP URL building, and
+ * network streaming helpers for RTP/RTSP protocols.
+ *
+ * @example
+ * ```typescript
+ * import { StreamingUtils, Muxer } from 'node-av/api';
+ *
+ * // Create RTP outputs
+ * const videoOutput = await Muxer.open('rtp://127.0.0.1:5004');
+ * const audioOutput = await Muxer.open('rtp://127.0.0.1:5006');
+ *
+ * // Generate SDP for streaming
+ * const sdp = StreamingUtils.createSdp([videoOutput, audioOutput]);
+ * if (sdp) {
+ *   console.log('SDP for streaming:', sdp);
+ *   // Save to .sdp file or serve via RTSP server
+ * }
+ * ```
+ */
+export declare class StreamingUtils {
+    /**
+     * Create an SDP (Session Description Protocol) string from demuxer/muxer
+     *
+     * Generates an SDP description for RTP/RTSP streaming from one or more
+     * configured demuxer/muxer. The inputs/outputs should be configured with RTP
+     * format and have their streams set up before calling this method.
+     *
+     * @param contexts - Alternatively, array of FormatContext objects
+     *
+     * @returns SDP string if successful, null if failed
+     *
+     * @example
+     * ```typescript
+     * // Set up RTP outputs with streams
+     * const output1 = await Muxer.open('rtp://239.0.0.1:5004');
+     * await output1.addStream(encoder1);
+     *
+     * const output2 = await Muxer.open('rtp://239.0.0.1:5006');
+     * await output2.addStream(encoder2);
+     *
+     * // Generate SDP for multicast streaming
+     * const sdp = StreamingUtils.createSdp([output1.getFormatContext(), output2.getFormatContext()]);
+     * if (sdp) {
+     *   // Write to file for VLC or other players
+     *   await fs.writeFile('stream.sdp', sdp);
+     * }
+     * ```
+     */
+    static createSdp(contexts: FormatContext[]): string | null;
+    /**
+     * Generate SDP for RTP/SRTP input using FFmpeg's native SDP generator
+     *
+     * Creates an RFC-compliant SDP description using FFmpeg's internal logic.
+     * This ensures correct codec names, clock rates, and formatting for all codecs.
+     *
+     * @param configs - Array of stream configurations
+     *
+     * @param sessionName - Optional session name for the SDP (default: 'RTP Stream')
+     *
+     * @returns SDP string with proper rtpmap and optional crypto attributes
+     *
+     * @example
+     * ```typescript
+     * import { StreamingUtils } from 'node-av/api';
+     * import { AV_CODEC_ID_OPUS, AV_CODEC_ID_H264 } from 'node-av/constants';
+     *
+     * // Single audio stream with SRTP
+     * const sdp = StreamingUtils.createInputSDP([{
+     *   port: 5004,
+     *   codecId: AV_CODEC_ID_OPUS,
+     *   payloadType: 111,
+     *   clockRate: 48000,
+     *   channels: 2,
+     *   srtp: {
+     *     key: Buffer.alloc(16, 0x12),
+     *     salt: Buffer.alloc(14, 0x34)
+     *   }
+     * }]);
+     *
+     * // Multi-stream (video + audio)
+     * const sdp = StreamingUtils.createInputSDP([
+     *   { port: 5006, codecId: AV_CODEC_ID_H264, payloadType: 96, clockRate: 90000 },
+     *   { port: 5004, codecId: AV_CODEC_ID_OPUS, payloadType: 111, clockRate: 48000, channels: 2 }
+     * ], 'My Stream');
+     * ```
+     */
+    static createInputSDP(configs: {
+        port: number;
+        codecId: AVCodecID;
+        payloadType: number;
+        clockRate: number;
+        channels?: number;
+        fmtp?: string;
+        srtp?: {
+            key: Buffer;
+            salt: Buffer;
+            suite?: 'AES_CM_128_HMAC_SHA1_80' | 'AES_CM_256_HMAC_SHA1_80';
+        };
+    }[], sessionName?: string): string;
+    /**
+     * Validate if an output is configured for RTP streaming
+     *
+     * @param output - Muxer to check
+     *
+     * @returns true if configured for RTP
+     *
+     * @example
+     * ```typescript
+     * const output = await Muxer.open('rtp://127.0.0.1:5004');
+     * if (StreamingUtils.isRtpOutput(output)) {
+     *   const sdp = StreamingUtils.createSdpForOutput(output);
+     * }
+     * ```
+     */
+    static isRtpOutput(output: Muxer): boolean;
+    /**
+     * Build RTP URL from components
+     *
+     * Helper to construct RTP URLs with proper formatting.
+     *
+     * @param host - IP address or hostname
+     *
+     * @param port - Port number
+     *
+     * @param options - Additional options
+     *
+     * @param options.ttl - Time-to-live for multicast
+     *
+     * @param options.localrtpport - Local RTP port
+     *
+     * @param options.localrtcpport - Local RTCP port
+     *
+     * @param options.pkt_size - Packet size
+     *
+     * @returns Formatted RTP URL
+     *
+     * @example
+     * ```typescript
+     * // Unicast
+     * const url1 = StreamingUtils.buildRtpUrl('127.0.0.1', 5004);
+     * // 'rtp://127.0.0.1:5004'
+     *
+     * // Multicast
+     * const url2 = StreamingUtils.buildRtpUrl('239.0.0.1', 5004, { ttl: 64 });
+     * // 'rtp://239.0.0.1:5004?ttl=64'
+     * ```
+     */
+    static buildRtpUrl(host: string, port: number, options?: {
+        ttl?: number;
+        localrtpport?: number;
+        localrtcpport?: number;
+        pkt_size?: number;
+    }): string;
+    /**
+     * Extract all UDP ports from SDP content
+     *
+     * @param sdp - SDP content string
+     *
+     * @returns Array of port numbers (one per stream)
+     *
+     * @example
+     * ```typescript
+     * import { StreamingUtils } from 'node-av/api';
+     *
+     * const sdp = `v=0
+     * o=- 0 0 IN IP4 127.0.0.1
+     * s=Test Stream
+     * c=IN IP4 127.0.0.1
+     * t=0 0
+     * m=audio 5004 RTP/AVP 111
+     * a=rtpmap:111 OPUS/48000/2
+     * m=video 5006 RTP/AVP 96
+     * a=rtpmap:96 H264/90000`;
+     *
+     * const ports = StreamingUtils.extractPortsFromSDP(sdp);
+     * console.log(ports); // [5004, 5006]
+     * ```
+     */
+    static extractPortsFromSDP(sdp: string): number[];
+}