node-av 6.1.1 → 6.2.0-beta.10

package/dist/api/rtp-stream.js

@@ -1,10 +1,10 @@
 import { isRtcp, RtpPacket } from 'werift';
-import { AV_HWDEVICE_TYPE_NONE } from '../constants/constants.js';
+import { AV_HWDEVICE_TYPE_NONE, AV_PICTURE_TYPE_I, AV_PIX_FMT_YUV420P, AV_SAMPLE_FMT_FLTP } from '../constants/constants.js';
 import { FF_ENCODER_LIBOPUS, FF_ENCODER_LIBX264, FF_ENCODER_LIBX265 } from '../constants/encoders.js';
 import { Codec } from '../lib/codec.js';
-import { avChannelLayoutDefault } from '../lib/utilities.js';
+import { Rational } from '../lib/rational.js';
+import { avChannelLayoutDefault, avGetPixFmtName } from '../lib/utilities.js';
 import { MAX_PACKET_SIZE } from './constants.js';
-import { pickSupportedLayout, pickSupportedRate, pickSupportedSampleFormat } from './utilities/codec-format.js';
 import { Decoder } from './decoder.js';
 import { Demuxer } from './demuxer.js';
 import { Encoder } from './encoder.js';
@@ -13,6 +13,49 @@ import { FilterAPI } from './filter.js';
 import { HardwareContext } from './hardware.js';
 import { Muxer } from './muxer.js';
 import { pipeline } from './pipeline.js';
+import { pickSupportedLayout, pickSupportedPixelFormat, pickSupportedRate, pickSupportedSampleFormat } from './utilities/codec-format.js';
+/**
+ * Check whether a streaming-class input is a frame source (not a URL or Demuxer).
+ *
+ * @param input - The input passed to `create()`
+ *
+ * @returns True if `input` is a {@link MediaFrameSource}
+ *
+ * @internal
+ */
+export function isMediaFrameSource(input) {
+    return typeof input !== 'string' && !(input instanceof Demuxer);
+}
+/**
+ * Combine one or two pipeline controls behind a single {@link PipelineControl}.
+ *
+ * The frame-source path runs separate video/audio pipelines; this presents them
+ * as one control so `stop()`/`completion` work uniformly.
+ *
+ * @internal
+ */
+class CombinedPipelineControl {
+    controls;
+    constructor(controls) {
+        this.controls = controls;
+    }
+    stop() {
+        for (const control of this.controls) {
+            control.stop();
+        }
+    }
+    isStopped() {
+        return this.controls.every((control) => control.isStopped());
+    }
+    get completion() {
+        return Promise.all(this.controls.map((control) => control.completion)).then(() => undefined);
+    }
+    get progress() {
+        // Delegate to the first control (video when present) - a merged view is not
+        // meaningful across independently-clocked streams.
+        return this.controls[0]?.progress ?? { frames: 0, bytes: 0, time: 0, fps: 0, bitrate: 0, speed: 0, elapsed: 0 };
+    }
+}
 /**
  * Generic RTP streaming with automatic codec detection and transcoding.
  *
@@ -50,6 +93,7 @@ export class RTPStream {
     inputUrl;
     inputOptions;
     input;
+    source;
     videoOutput;
     audioOutput;
     hardwareContext;
@@ -60,9 +104,15 @@ export class RTPStream {
     audioFilter;
     audioEncoder;
     pipeline;
+    startPromise;
     signal;
     supportedVideoCodecs;
     supportedAudioCodecs;
+    videoKeyframeRequested = false;
+    abortHandler;
+    stopRequested = false;
+    stopPromise;
+    startAbort;
     /**
      * @param input - Media input URL or pre-opened Demuxer
      *
@@ -76,10 +126,14 @@ export class RTPStream {
         if (typeof input === 'string') {
             this.inputUrl = input;
         }
-        else {
+        else if (input instanceof Demuxer) {
             this.inputUrl = null;
             this.input = input;
         }
+        else {
+            this.inputUrl = null;
+            this.source = input;
+        }
         const inputUrl = this.inputUrl ?? '';
         this.inputOptions = {
             ...options.inputOptions,
@@ -111,9 +165,10 @@ export class RTPStream {
                 ssrc: options.video?.ssrc,
                 payloadType: options.video?.payloadType,
                 mtu: options.video?.mtu ?? MAX_PACKET_SIZE,
-                fps: options.video?.fps ?? 20,
+                fps: options.video?.fps,
                 width: options.video?.width,
                 height: options.video?.height,
+                bitrate: options.video?.bitrate,
                 encoderOptions: options.video?.encoderOptions ?? {},
             },
             audio: {
@@ -199,6 +254,47 @@ export class RTPStream {
     getInput() {
         return this.input;
     }
+    /**
+     * Request that the next encoded video frame is a keyframe.
+     *
+     * 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.
+     *
+     * @example
+     * ```typescript
+     * transceiver.sender.onPictureLossIndication.subscribe(() => {
+     *   stream.requestVideoKeyframe();
+     * });
+     * ```
+     */
+    requestVideoKeyframe() {
+        this.videoKeyframeRequested = true;
+    }
+    /**
+     * 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
+     */
+    async *wrapVideoSource(src) {
+        for await (const frame of src) {
+            if (frame && this.videoKeyframeRequested) {
+                this.videoKeyframeRequested = false;
+                frame.pictType = AV_PICTURE_TYPE_I;
+            }
+            yield frame;
+        }
+    }
     /**
      * Start streaming media to RTP packets.
      *
@@ -227,17 +323,55 @@ export class RTPStream {
      * ```
      */
     async start() {
+        // Idempotent: concurrent and repeated calls share a single startup (e.g.
+        // an explicit start() racing WebRTCStream.setOffer()'s automatic one).
+        this.startPromise ??= this.doStart().catch((error) => {
+            this.startPromise = undefined;
+            throw error;
+        });
+        await this.startPromise;
+    }
+    /**
+     * Perform the actual startup (see {@link start}).
+     *
+     * @internal
+     */
+    async doStart() {
+        // A start racing an in-flight stop() waits for the teardown to finish,
+        // otherwise it would build the pipeline on top of freed resources.
+        if (this.stopPromise) {
+            await this.stopPromise;
+        }
         if (this.pipeline) {
             return;
         }
         this.signal?.throwIfAborted();
-        this.signal?.addEventListener('abort', () => this.stop(), { once: true });
+        if (this.signal && !this.abortHandler) {
+            // Stop on abort. Keep a reference so stop() can detach the listener again,
+            // otherwise restarts would stack one listener per start(). Errors from the
+            // async stop() are swallowed here; they already surface via onClose(error).
+            this.abortHandler = () => {
+                this.abortHandler = undefined;
+                this.stop().catch(() => { });
+            };
+            this.signal.addEventListener('abort', this.abortHandler, { once: true });
+        }
+        // Lets stop() interrupt a startup that is blocked in the input open
+        // (an RTSP connect can take seconds).
+        this.startAbort = new AbortController();
+        // Frame-source path: encode pre-composited frames directly (no demuxer/decoder).
+        if (this.source) {
+            await this.startFromFrames();
+            return;
+        }
         if (!this.input) {
             if (!this.inputUrl) {
                 throw new Error('No input URL or Demuxer provided');
             }
-            this.input = await Demuxer.open(this.inputUrl, this.inputOptions);
+            const openSignal = this.signal ? AbortSignal.any([this.signal, this.startAbort.signal]) : this.startAbort.signal;
+            this.input = await Demuxer.open(this.inputUrl, { ...this.inputOptions, signal: openSignal });
         }
+        this.throwIfStopRequested();
         const videoStream = this.input.video();
         const audioStream = this.input.audio();
         // Setup video transcoding if needed
@@ -260,6 +394,21 @@ export class RTPStream {
             const needsScale = (this.options.video.width !== undefined && this.options.video.width !== currentWidth) ||
                 (this.options.video.height !== undefined && this.options.video.height !== currentHeight);
             const needsFps = this.options.video.fps !== undefined && isFinite(currentFps) && this.options.video.fps !== currentFps;
+            // Get first supported codec
+            const targetCodecId = this.options.supportedVideoCodecs[0];
+            if (!targetCodecId) {
+                throw new Error('No supported video codec specified for transcoding');
+            }
+            let encoderCodec = null;
+            if (typeof targetCodecId === 'string') {
+                encoderCodec = Codec.findEncoderByName(targetCodecId);
+            }
+            else {
+                encoderCodec = this.hardwareContext?.getEncoderCodec(targetCodecId) ?? Codec.findEncoder(targetCodecId);
+            }
+            if (!encoderCodec) {
+                throw new Error(`No encoder found for codec ID ${targetCodecId}`);
+            }
             // Create filter chain only if needed
             if (needsScale || needsFps) {
                 const filterChain = FilterPreset.chain(this.hardwareContext);
@@ -273,25 +422,26 @@ export class RTPStream {
                 if (needsFps) {
                     filterChain.filter('fps', { fps: this.options.video.fps });
                 }
+                // Software scaling leaves the graph output format unconstrained, so swscale keeps the
+                // source format on both sides of the scale. Packed formats like yuyv422 can't be scaled
+                // in place (yuyv422 -> yuyv422 fails with ENOSYS), and the encoder wouldn't accept them
+                // anyway. Pin the output to yuv420p so the graph negotiates a real conversion: it is the
+                // one format every browser/player can decode over WebRTC (unlike e.g. the 4:2:2 High
+                // profile that a least-loss pick would choose for a yuyv422 source). Fall back to a
+                // codec-supported format only if the encoder genuinely can't take yuv420p. Hardware chains
+                // negotiate their format through the frames context instead.
+                if (needsScale && !this.hardwareContext) {
+                    const formats = encoderCodec.pixelFormats;
+                    const targetFmt = !formats || formats.includes(AV_PIX_FMT_YUV420P) ? AV_PIX_FMT_YUV420P : pickSupportedPixelFormat(videoStream.codecpar.format, formats);
+                    const targetFmtName = avGetPixFmtName(targetFmt);
+                    if (targetFmtName) {
+                        filterChain.filter('format', { pix_fmts: targetFmtName });
+                    }
+                }
                 this.videoFilter = FilterAPI.create(filterChain.build(), {
                     hardware: this.hardwareContext,
                 });
             }
-            // Get first supported codec
-            const targetCodecId = this.options.supportedVideoCodecs[0];
-            if (!targetCodecId) {
-                throw new Error('No supported video codec specified for transcoding');
-            }
-            let encoderCodec = null;
-            if (typeof targetCodecId === 'string') {
-                encoderCodec = Codec.findEncoderByName(targetCodecId);
-            }
-            else {
-                encoderCodec = this.hardwareContext?.getEncoderCodec(targetCodecId) ?? Codec.findEncoder(targetCodecId);
-            }
-            if (!encoderCodec) {
-                throw new Error(`No encoder found for codec ID ${targetCodecId}`);
-            }
             let encoderOptions = {};
             if (encoderCodec.name === FF_ENCODER_LIBX264 || encoderCodec.name === FF_ENCODER_LIBX265) {
                 encoderOptions.preset = 'ultrafast';
@@ -301,60 +451,20 @@ export class RTPStream {
                 ...encoderOptions,
                 ...this.options.video.encoderOptions,
             };
+            const bitrate = this.options.video.bitrate;
             this.videoEncoder = await Encoder.create(encoderCodec, {
                 decoder: this.videoDecoder,
                 maxBFrames: 0,
                 options: encoderOptions,
+                configure: (ctx) => {
+                    this.applyBitrate(ctx, bitrate);
+                },
             });
-        }
-        // Initialize RTP sequence numbers and timestamps
-        let videoSequenceNumber = Math.floor(Math.random() * 0xffff);
-        let videoTimestamp = Math.floor(Math.random() * 0xffffffff) >>> 0; // unsigned 32-bit
-        let audioSequenceNumber = Math.floor(Math.random() * 0xffff);
-        // Calculate video timestamp increment
-        const videoStreamFps = videoStream ? videoStream.avgFrameRate.num / videoStream.avgFrameRate.den : 20;
-        let fps = this.options.video.fps ?? videoStreamFps;
-        if (!isFinite(fps) || fps <= 0 || isNaN(fps)) {
-            fps = 20; // Default to 20 FPS if invalid
-        }
-        const videoTimestampIncrement = 90000 / fps;
-        // Build RTP muxer options for video
-        const videoMuxerOptions = {};
-        if (this.options.video.ssrc !== undefined) {
-            videoMuxerOptions.ssrc = this.options.video.ssrc;
-        }
-        if (this.options.video.payloadType !== undefined) {
-            videoMuxerOptions.payload_type = this.options.video.payloadType;
+            this.throwIfStopRequested();
         }
         // Setup video output
-        this.videoOutput = await Muxer.open({
-            write: (buffer) => {
-                if (isRtcp(buffer)) {
-                    // Ignore RTCP packets
-                    return buffer.length;
-                }
-                const rtpPacket = RtpPacket.deSerialize(buffer);
-                // Fix sequence number - ensure continuous sequence
-                rtpPacket.header.sequenceNumber = videoSequenceNumber;
-                videoSequenceNumber = (videoSequenceNumber + 1) & 0xffff; // Wrap at 16-bit
-                // Fix timestamp - calculate based on FPS
-                // All packets in same frame have same timestamp (marker=false)
-                // Only increment timestamp when frame ends (marker=true)
-                rtpPacket.header.timestamp = videoTimestamp;
-                // Increment timestamp for next frame when current frame ends
-                if (rtpPacket.header.marker) {
-                    videoTimestamp = (videoTimestamp + videoTimestampIncrement) >>> 0; // Unsigned 32-bit wrap
-                }
-                this.options.onVideoPacket(rtpPacket);
-                return buffer.length;
-            },
-        }, {
-            input: this.input,
-            copyInitialNonkeyframes: true,
-            format: 'rtp',
-            maxPacketSize: this.options.video.mtu,
-            options: videoMuxerOptions,
-        });
+        this.videoOutput = await this.createVideoOutput();
+        this.throwIfStopRequested();
         // Setup audio if available and needs transcoding
         if (audioStream && !this.isAudioCodecSupported(audioStream.codecpar.codecId)) {
             this.audioDecoder = await Decoder.create(audioStream, {
@@ -401,50 +511,298 @@ export class RTPStream {
                 filter: this.audioFilter,
                 options: encoderOptions,
             });
+            this.throwIfStopRequested();
         }
         // Setup audio output if available
         if (audioStream) {
-            // Build RTP muxer options for audio
-            const audioMuxerOptions = {};
-            if (this.options.audio.ssrc !== undefined) {
-                audioMuxerOptions.ssrc = this.options.audio.ssrc;
-            }
-            if (this.options.audio.payloadType !== undefined) {
-                audioMuxerOptions.payload_type = this.options.audio.payloadType;
-            }
-            this.audioOutput = await Muxer.open({
-                write: (buffer) => {
-                    if (isRtcp(buffer)) {
-                        // Ignore RTCP packets
-                        return buffer.length;
-                    }
-                    const rtpPacket = RtpPacket.deSerialize(buffer);
-                    // Fix sequence number - ensure continuous sequence
-                    rtpPacket.header.sequenceNumber = audioSequenceNumber;
-                    audioSequenceNumber = (audioSequenceNumber + 1) & 0xffff; // Wrap at 16-bit
-                    this.options.onAudioPacket(rtpPacket);
-                    return buffer.length;
-                },
-            }, {
-                input: this.input,
-                copyInitialNonkeyframes: true,
-                format: 'rtp',
-                maxPacketSize: this.options.audio.mtu,
-                options: audioMuxerOptions,
-            });
+            this.audioOutput = await this.createAudioOutput();
+            this.throwIfStopRequested();
         }
         // Start pipeline in background (don't await)
-        this.runPipeline()
+        this.attachCompletion(this.runPipeline());
+    }
+    /**
+     * Abort an in-flight startup once stop() was requested.
+     *
+     * Checked after every await in the startup path: the resources created so
+     * far are all assigned to instance fields, so the stop() that is waiting on
+     * this startup tears them down the moment it unwinds.
+     *
+     * @throws {Error} If stop() was called while starting
+     *
+     * @internal
+     */
+    throwIfStopRequested() {
+        if (this.stopRequested) {
+            throw new Error('RTPStream stopped during start');
+        }
+    }
+    /**
+     * Cap the video bitrate on the encoder context.
+     *
+     * Sets the target bitrate together with a VBV cap (maxrate + a 1s buffer).
+     * Encoder.create() always seeds a default target bitrate (1 Mbps for video),
+     * so the target MUST be lowered along with the cap.
+     *
+     * @param ctx - Encoder codec context
+     *
+     * @param bitrate - Maximum bitrate in bits per second, or undefined
+     *
+     * @internal
+     */
+    applyBitrate(ctx, bitrate) {
+        if (!bitrate || bitrate <= 0) {
+            return;
+        }
+        const rate = Math.round(bitrate);
+        ctx.bitRate = BigInt(rate);
+        ctx.rcMaxRate = BigInt(rate);
+        ctx.rcBufferSize = rate;
+    }
+    /**
+     * Wire the pipeline completion to the onClose/error callbacks.
+     *
+     * On success invokes `onClose()`; on error stops the stream and invokes
+     * `onClose(error)`. Runs in the background (not awaited).
+     *
+     * @param completion - The pipeline completion promise
+     *
+     * @internal
+     */
+    attachCompletion(completion) {
+        completion
             .then(() => {
             // Pipeline completed successfully
             this.options.onClose?.();
         })
             .catch(async (error) => {
+            // A stop() in flight or an aborted signal means the owner is tearing
+            // the stream down - the pipeline unwinding with an AbortError (or an
+            // interrupted FFmpeg call) is the expected shutdown path, not a failure.
+            if (this.isDeliberateStop(error)) {
+                await this.stop().catch(() => { });
+                this.options.onClose?.();
+                return;
+            }
             console.error('[RTPStream] Pipeline error:', error);
             await this.stop();
             this.options.onClose?.(error);
         });
     }
+    /**
+     * Whether a pipeline rejection was caused by an intentional shutdown.
+     *
+     * @param error - The pipeline rejection reason
+     *
+     * @returns True when stop() is in flight or the owner's signal aborted
+     *
+     * @internal
+     */
+    isDeliberateStop(error) {
+        return this.stopRequested || this.stopPromise !== undefined || this.signal?.aborted === true || (error instanceof Error && error.name === 'AbortError');
+    }
+    /**
+     * 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
+     * straight to RTP. Video and audio (whichever are present) run as separate
+     * pipelines combined behind a single control.
+     *
+     * @throws {Error} If the source has neither video nor audio frames
+     *
+     * @internal
+     */
+    async startFromFrames() {
+        const source = this.source;
+        if (!source.video && !source.audio) {
+            throw new Error('Frame source must provide video and/or audio frames');
+        }
+        const controls = [];
+        const opts = this.signal ? { signal: this.signal } : undefined;
+        // Video
+        if (source.video) {
+            if (this.options.hardware === 'auto') {
+                this.hardwareContext = HardwareContext.auto();
+            }
+            else if (this.options.hardware.deviceType !== AV_HWDEVICE_TYPE_NONE) {
+                this.hardwareContext = HardwareContext.create(this.options.hardware.deviceType, this.options.hardware.device, this.options.hardware.options);
+            }
+            const targetCodecId = this.options.supportedVideoCodecs[0] ?? FF_ENCODER_LIBX264;
+            let encoderCodec = null;
+            if (typeof targetCodecId === 'string') {
+                encoderCodec = Codec.findEncoderByName(targetCodecId);
+            }
+            else {
+                encoderCodec = this.hardwareContext?.getEncoderCodec(targetCodecId) ?? Codec.findEncoder(targetCodecId);
+            }
+            if (!encoderCodec) {
+                throw new Error(`No encoder found for video codec ${String(targetCodecId)}`);
+            }
+            let encoderOptions = {};
+            if (encoderCodec.name === FF_ENCODER_LIBX264 || encoderCodec.name === FF_ENCODER_LIBX265) {
+                encoderOptions.preset = 'ultrafast';
+                encoderOptions.tune = 'zerolatency';
+                // Make a requested keyframe (frame.pictType = I) an actual IDR, so a
+                // receiver that missed the stream start can resync (PLI handling).
+                encoderOptions['forced-idr'] = true;
+            }
+            encoderOptions = { ...encoderOptions, ...this.options.video.encoderOptions };
+            let fps = this.options.video.fps ?? 20;
+            if (!isFinite(fps) || fps <= 0 || isNaN(fps)) {
+                fps = 20;
+            }
+            // No decoder/filter: the encoder adopts width/height/pixelFormat/timeBase
+            // from the first composited frame. Set the framerate explicitly, otherwise
+            // the encoder infers it from the frame timebase (often a fine-grained tick
+            // like 1/12800), which makes x264 pick an absurd level (huge MB rate) that
+            // browsers can't decode over WebRTC. Bound the GOP to ~2s: live receivers
+            // that join (or lose) mid-stream must get a keyframe quickly - the x264
+            // default of 250 frames leaves them waiting for many seconds.
+            const bitrate = this.options.video.bitrate;
+            this.videoEncoder = await Encoder.create(encoderCodec, {
+                maxBFrames: 0,
+                options: encoderOptions,
+                configure: (ctx) => {
+                    ctx.framerate = new Rational(Math.round(fps), 1);
+                    ctx.gopSize = Math.max(1, Math.round(fps * 2));
+                    this.applyBitrate(ctx, bitrate);
+                },
+            });
+            this.videoOutput = await this.createVideoOutput();
+            this.throwIfStopRequested();
+            controls.push(pipeline(this.wrapVideoSource(source.video), this.videoEncoder, this.videoOutput, opts));
+        }
+        // Audio
+        if (source.audio) {
+            const targetCodecId = this.options.supportedAudioCodecs[0] ?? FF_ENCODER_LIBOPUS;
+            let encoderCodec = null;
+            if (typeof targetCodecId === 'string') {
+                encoderCodec = Codec.findEncoderByName(targetCodecId);
+            }
+            else {
+                encoderCodec = Codec.findEncoder(targetCodecId);
+            }
+            if (!encoderCodec) {
+                throw new Error(`No encoder found for audio codec ${String(targetCodecId)}`);
+            }
+            // There is no input stream to derive formats from - resample to the desired
+            // (or codec-preferred) sample format/rate/layout via an aformat filter.
+            const desiredSampleFormat = this.options.audio?.sampleFormat ?? AV_SAMPLE_FMT_FLTP;
+            const desiredSampleRate = this.options.audio?.sampleRate ?? 48000;
+            const desiredChannels = this.options.audio?.channels ?? 2;
+            const targetSampleFormat = this.selectSampleFormat(encoderCodec, desiredSampleFormat);
+            const targetSampleRate = this.selectSampleRate(encoderCodec, desiredSampleRate);
+            const channelLayoutStr = this.selectChannelLayout(encoderCodec, desiredChannels);
+            this.audioFilter = FilterAPI.create(FilterPreset.chain().aformat(targetSampleFormat, targetSampleRate, channelLayoutStr).build());
+            let encoderOptions = {};
+            if (encoderCodec.name === FF_ENCODER_LIBOPUS) {
+                encoderOptions.application = 'lowdelay';
+                encoderOptions.frame_duration = 20;
+            }
+            encoderOptions = { ...encoderOptions, ...this.options.audio.encoderOptions };
+            this.audioEncoder = await Encoder.create(encoderCodec, {
+                filter: this.audioFilter,
+                options: encoderOptions,
+            });
+            this.audioOutput = await this.createAudioOutput();
+            this.throwIfStopRequested();
+            controls.push(pipeline(source.audio, this.audioFilter, this.audioEncoder, this.audioOutput, opts));
+        }
+        this.pipeline = new CombinedPipelineControl(controls);
+        this.attachCompletion(this.pipeline.completion);
+    }
+    /**
+     * Create the RTP video output muxer.
+     *
+     * Rewrites RTP sequence numbers (continuous) and rebases the PTS-derived
+     * timestamps (90 kHz) onto a random initial value in the write callback, then
+     * forwards each packet to `onVideoPacket`. Uses `this.input` when present
+     * (demuxer path) and no input for the frame-source path.
+     *
+     * @returns The configured video muxer
+     *
+     * @internal
+     */
+    async createVideoOutput() {
+        let videoSequenceNumber = Math.floor(Math.random() * 0xffff);
+        const videoTimestampBase = Math.floor(Math.random() * 0xffffffff) >>> 0; // unsigned 32-bit
+        let videoTimestampOffset;
+        const videoMuxerOptions = {};
+        if (this.options.video.ssrc !== undefined) {
+            videoMuxerOptions.ssrc = this.options.video.ssrc;
+        }
+        if (this.options.video.payloadType !== undefined) {
+            videoMuxerOptions.payload_type = this.options.video.payloadType;
+        }
+        return await Muxer.open({
+            write: (buffer) => {
+                if (isRtcp(buffer)) {
+                    // Ignore RTCP packets
+                    return buffer.length;
+                }
+                const rtpPacket = RtpPacket.deSerialize(buffer);
+                // Fix sequence number - ensure continuous sequence
+                rtpPacket.header.sequenceNumber = videoSequenceNumber;
+                videoSequenceNumber = (videoSequenceNumber + 1) & 0xffff; // Wrap at 16-bit
+                // Rebase the timestamp onto our own random initial value. FFmpeg's RTP
+                // muxer derives it from the packet PTS in the 90 kHz clock (plus its own
+                // random base), so the deltas carry the real presentation times -
+                // including B-frame reordering and VFR cadence. Only the base is swapped;
+                // modular uint32 arithmetic keeps wrap-around intact, and packets of the
+                // same frame keep sharing a timestamp.
+                videoTimestampOffset ??= (videoTimestampBase - rtpPacket.header.timestamp) >>> 0;
+                rtpPacket.header.timestamp = (rtpPacket.header.timestamp + videoTimestampOffset) >>> 0;
+                this.options.onVideoPacket(rtpPacket);
+                return buffer.length;
+            },
+        }, {
+            input: this.input,
+            copyInitialNonkeyframes: true,
+            format: 'rtp',
+            maxPacketSize: this.options.video.mtu,
+            options: videoMuxerOptions,
+        });
+    }
+    /**
+     * Create the RTP audio output muxer.
+     *
+     * Rewrites RTP sequence numbers (continuous) in the write callback and forwards
+     * each packet to `onAudioPacket`. Uses `this.input` when present (demuxer path)
+     * and no input for the frame-source path.
+     *
+     * @returns The configured audio muxer
+     *
+     * @internal
+     */
+    async createAudioOutput() {
+        let audioSequenceNumber = Math.floor(Math.random() * 0xffff);
+        const audioMuxerOptions = {};
+        if (this.options.audio.ssrc !== undefined) {
+            audioMuxerOptions.ssrc = this.options.audio.ssrc;
+        }
+        if (this.options.audio.payloadType !== undefined) {
+            audioMuxerOptions.payload_type = this.options.audio.payloadType;
+        }
+        return await Muxer.open({
+            write: (buffer) => {
+                if (isRtcp(buffer)) {
+                    // Ignore RTCP packets
+                    return buffer.length;
+                }
+                const rtpPacket = RtpPacket.deSerialize(buffer);
+                // Fix sequence number - ensure continuous sequence
+                rtpPacket.header.sequenceNumber = audioSequenceNumber;
+                audioSequenceNumber = (audioSequenceNumber + 1) & 0xffff; // Wrap at 16-bit
+                this.options.onAudioPacket(rtpPacket);
+                return buffer.length;
+            },
+        }, {
+            input: this.input,
+            copyInitialNonkeyframes: true,
+            format: 'rtp',
+            maxPacketSize: this.options.audio.mtu,
+            options: audioMuxerOptions,
+        });
+    }
     /**
      * Run the streaming pipeline until completion or stopped.
      *
@@ -501,33 +859,83 @@ export class RTPStream {
      * ```
      */
     async stop() {
-        // Stop pipeline if running and wait for completion
-        if (this.pipeline && !this.pipeline.isStopped()) {
-            this.pipeline.stop();
-            await this.pipeline.completion;
-            this.pipeline = undefined;
-        }
-        // Close all resources
-        await this.videoOutput?.close();
-        this.videoOutput = undefined;
-        await this.audioOutput?.close();
-        this.audioOutput = undefined;
-        this.videoEncoder?.close();
-        this.videoEncoder = undefined;
-        this.videoFilter?.close();
-        this.videoFilter = undefined;
-        this.videoDecoder?.close();
-        this.videoDecoder = undefined;
-        this.audioEncoder?.close();
-        this.audioEncoder = undefined;
-        this.audioFilter?.close();
-        this.audioFilter = undefined;
-        this.audioDecoder?.close();
-        this.audioDecoder = undefined;
-        this.hardwareContext?.dispose();
-        this.hardwareContext = undefined;
-        await this.input?.close();
-        this.input = undefined;
+        // Memoized: concurrent stop() calls share one teardown instead of
+        // double-closing native resources.
+        this.stopPromise ??= this.doStop().finally(() => {
+            this.stopPromise = undefined;
+        });
+        await this.stopPromise;
+    }
+    /**
+     * Perform the actual teardown (see {@link stop}).
+     *
+     * @internal
+     */
+    async doStop() {
+        // An in-flight start() must unwind before teardown - otherwise it would
+        // keep building the pipeline on top of freed resources and leave an
+        // orphaned transcode running forever. The flag makes doStart() bail at its
+        // next checkpoint, the abort unblocks a startup stuck in the input open.
+        this.stopRequested = true;
+        this.startAbort?.abort();
+        this.startAbort = undefined;
+        const inflightStart = this.startPromise;
+        // Allow a fresh start() after stopping.
+        this.startPromise = undefined;
+        if (inflightStart) {
+            try {
+                await inflightStart;
+            }
+            catch {
+                // Aborted or failed startup - resources are torn down below either way.
+            }
+        }
+        try {
+            // Detach the abort listener so it cannot fire for a torn-down session and
+            // does not accumulate across start()/stop() cycles.
+            if (this.abortHandler) {
+                this.signal?.removeEventListener('abort', this.abortHandler);
+                this.abortHandler = undefined;
+            }
+            // Stop pipeline if running and wait for completion. pipeline.stop() interrupts
+            // the source demuxer's read (frame-source pipelines unwind via iterator.return
+            // instead). Swallow a rejected completion here - the error is already surfaced
+            // to the caller via the onClose(error) path; we just need cleanup to proceed.
+            if (this.pipeline && !this.pipeline.isStopped()) {
+                this.pipeline.stop();
+                try {
+                    await this.pipeline.completion;
+                }
+                catch {
+                    // Pipeline errored - proceed with teardown regardless.
+                }
+                this.pipeline = undefined;
+            }
+            // Close all resources
+            await this.videoOutput?.close();
+            this.videoOutput = undefined;
+            await this.audioOutput?.close();
+            this.audioOutput = undefined;
+            this.videoEncoder?.close();
+            this.videoEncoder = undefined;
+            this.videoFilter?.close();
+            this.videoFilter = undefined;
+            this.videoDecoder?.close();
+            this.videoDecoder = undefined;
+            this.audioEncoder?.close();
+            this.audioEncoder = undefined;
+            this.audioFilter?.close();
+            this.audioFilter = undefined;
+            this.audioDecoder?.close();
+            this.audioDecoder = undefined;
+            this.hardwareContext?.dispose();
+            this.hardwareContext = undefined;
+            await this.input?.close();
+            this.input = undefined;
+        }
+        finally {
+            this.stopRequested = false;
+        }
     }
     /**
      * Check if the given audio codec is supported.