node-av 6.2.0-beta.9 → 7.0.0-beta.1

package/dist/api/rtp-stream.d.ts

@@ -25,6 +25,10 @@ export interface RTPStreamOptions {
     /**
      * Callback invoked when the stream is closed or encounters an error.
      *
+     * Called once per started session. On an error the stream has already been
+     * stopped and its resources (including the input connection) released.
+     * Exceptions thrown by the callback are logged and do not propagate.
+     *
      * @param error - Optional error if stream closed due to an error
      */
     onClose?: (error?: Error) => void;
@@ -68,6 +72,9 @@ export interface RTPStreamOptions {
         width?: number;
         height?: number;
         bitrate?: number;
+        dumpExtra?: boolean;
+        /** Transcode even when the source codec is one of `supportedVideoCodecs`. */
+        transcode?: boolean;
         encoderOptions?: EncoderOptions['options'];
     };
     /**
@@ -144,6 +151,7 @@ export declare class RTPStream {
     private videoDecoder?;
     private videoFilter?;
     private videoEncoder?;
+    private videoBitstreamFilter?;
     private audioDecoder?;
     private audioFilter?;
     private audioEncoder?;
@@ -152,11 +160,11 @@ export declare class RTPStream {
     private signal?;
     private supportedVideoCodecs;
     private supportedAudioCodecs;
-    private videoKeyframeRequested;
     private abortHandler?;
     private stopRequested;
     private stopPromise?;
     private startAbort?;
+    private stopSignal;
     /**
      * @param input - Media input URL or pre-opened Demuxer
      *
@@ -211,6 +219,10 @@ export declare class RTPStream {
     /**
      * Check if the stream is active.
      *
+     * Stays true while a requested stop is still unwinding: the pipeline reports
+     * itself stopped as soon as stop() is called, but its packets keep flowing
+     * and its native resources stay open until completion settles.
+     *
      * @returns True if the stream is active, false otherwise
      */
     get isStreamActive(): boolean;
@@ -238,9 +250,9 @@ export declare class RTPStream {
      *
      * Used to answer receiver feedback (e.g. a WebRTC PLI) so a receiver that
      * missed the stream start or lost packets can resync without waiting for the
-     * next scheduled GOP keyframe. Currently effective for frame-source inputs
-     * ({@link MediaFrameSource}); for demuxer inputs the encoder's regular GOP
-     * cadence applies.
+     * next scheduled GOP keyframe. Effective whenever the video is encoded, from
+     * frame sources and from a transcoded URL or {@link Demuxer} input; a stream
+     * passed through keeps the source's keyframes.
      *
      * @example
      * ```typescript
@@ -250,20 +262,6 @@ export declare class RTPStream {
      * ```
      */
     requestVideoKeyframe(): void;
-    /**
-     * Pass video frames through, forcing a keyframe when one was requested.
-     *
-     * Sets `pictType = I` on the next frame after {@link requestVideoKeyframe};
-     * combined with the encoder's `forced-idr` option this produces an IDR the
-     * receiver can resync on.
-     *
-     * @param src - The user-provided video frame source
-     *
-     * @yields {Frame | null} The unchanged frames (with pictType forced when requested)
-     *
-     * @internal
-     */
-    private wrapVideoSource;
     /**
      * Start streaming media to RTP packets.
      *
@@ -311,32 +309,38 @@ export declare class RTPStream {
      */
     private throwIfStopRequested;
     /**
-     * Cap the video bitrate on the encoder context.
+     * Wire the pipeline completion to the onClose/error callbacks.
      *
-     * Applies a VBV rate cap (maxrate + a 1s buffer) WITHOUT setting a target
-     * bitrate, so the encoder keeps its default constant-quality mode but can
-     * never exceed the negotiated ceiling. Setting the bitrate as an ABR target
-     * instead would push a normally-lighter stream UP to fill it, overshooting
-     * on bursts.
+     * On success invokes `onClose()`; on error stops the stream and invokes
+     * `onClose(error)`. Either way `onClose` runs exactly once and the detached
+     * chain never rejects. Runs in the background (not awaited).
      *
-     * @param ctx - Encoder codec context
+     * @param completion - The pipeline completion promise
      *
-     * @param bitrate - Maximum bitrate in bits per second, or undefined
+     * @internal
+     */
+    private attachCompletion;
+    /**
+     * Invoke the owner's onClose callback.
+     *
+     * The completion chain runs detached, so an exception from the callback
+     * could only surface as an unhandled rejection - it is logged instead.
+     *
+     * @param error - Pipeline error, or undefined for a clean end
      *
      * @internal
      */
-    private applyBitrate;
+    private emitClose;
     /**
-     * Wire the pipeline completion to the onClose/error callbacks.
+     * Whether a pipeline rejection was caused by an intentional shutdown.
      *
-     * On success invokes `onClose()`; on error stops the stream and invokes
-     * `onClose(error)`. Runs in the background (not awaited).
+     * @param error - The pipeline rejection reason
      *
-     * @param completion - The pipeline completion promise
+     * @returns True when stop() is in flight or the owner's signal aborted
      *
      * @internal
      */
-    private attachCompletion;
+    private isDeliberateStop;
     /**
      * Set up encoders and RTP outputs for a pre-composited frame source and start
      * encoding. No demuxer or decoder is involved - the provided frames are encoded
@@ -384,7 +388,8 @@ export declare class RTPStream {
      *
      * Stops the pipeline, closes output, and releases all FFmpeg resources.
      * Safe to call multiple times. After stopping, you can call start() again
-     * to restart the stream.
+     * to restart the stream. Resolves even if the pipeline had failed; that
+     * error is reported through `onClose(error)`.
      *
      * @example
      * ```typescript
@@ -414,6 +419,22 @@ export declare class RTPStream {
      * @internal
      */
     private isAudioCodecSupported;
+    /**
+     * Find the encoder for a target video codec, on the device when it works there.
+     *
+     * @param target - Codec ID, or the name of a specific encoder to use as it is
+     *
+     * @param size - The output size, when known before the first frame
+     *
+     * @param size.width - Width
+     *
+     * @param size.height - Height
+     *
+     * @returns The encoder, or null if none exists
+     *
+     * @internal
+     */
+    private findVideoEncoder;
     /**
      * Check if the given video codec is supported.
      *