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

package/dist/api/encoder.js

@@ -51,18 +51,19 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 /* eslint-disable @stylistic/indent-binary-ops */
-import { AV_CHANNEL_ORDER_UNSPEC, AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, AV_CODEC_CAP_PARAM_CHANGE, AV_CODEC_FLAG_COPY_OPAQUE, AV_CODEC_FLAG_FRAME_DURATION, AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX, AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, AV_NOPTS_VALUE, AV_PICTURE_TYPE_NONE, AV_PIX_FMT_NONE, AV_PKT_FLAG_TRUSTED, AVCHROMA_LOC_UNSPECIFIED, AVERROR_EAGAIN, AVERROR_ENCODER_NOT_FOUND, AVERROR_EOF, AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_VIDEO, EOF, SWS_BILINEAR, } from '../constants/constants.js';
+import { AV_CHANNEL_ORDER_UNSPEC, AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, AV_CODEC_CAP_PARAM_CHANGE, AV_CODEC_FLAG_COPY_OPAQUE, AV_CODEC_FLAG_FRAME_DURATION, AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX, AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, AV_LOG_WARNING, AV_NOPTS_VALUE, AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_NONE, AV_PIX_FMT_NONE, AV_PKT_FLAG_TRUSTED, AV_ROUND_NEAR_INF, AVCHROMA_LOC_UNSPECIFIED, AVERROR_EAGAIN, AVERROR_ENCODER_NOT_FOUND, AVERROR_EOF, AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_VIDEO, EOF, SWS_BILINEAR, } from '../constants/constants.js';
 import { CodecContext } from '../lib/codec-context.js';
 import { Codec } from '../lib/codec.js';
 import { Dictionary } from '../lib/dictionary.js';
 import { FFmpegError } from '../lib/error.js';
 import { Frame } from '../lib/frame.js';
+import { Log } from '../lib/log.js';
 import { Packet } from '../lib/packet.js';
 import { Rational } from '../lib/rational.js';
 import { SoftwareResampleContext } from '../lib/software-resample-context.js';
 import { SoftwareScaleContext } from '../lib/software-scale-context.js';
-import { avChannelLayoutDefault, avGetPixFmtName, avGetSampleFmtName, avRescaleQ } from '../lib/utilities.js';
-import { AudioFrameBuffer } from './audio-frame-buffer.js';
+import { avChannelLayoutDefault, avGetPixFmtName, avGetSampleFmtName, avRescaleQ, avRescaleRnd } from '../lib/utilities.js';
+import { assertAudioFrameBufferOptions, AudioFrameBuffer } from './audio-frame-buffer.js';
 import { FRAME_THREAD_QUEUE_SIZE, PACKET_THREAD_QUEUE_SIZE } from './constants.js';
 import { AsyncQueue } from './utilities/async-queue.js';
 import { pickSupportedLayout, pickSupportedPixelFormat, pickSupportedRate, pickSupportedSampleFormat } from './utilities/codec-format.js';
@@ -87,6 +88,30 @@ const BITRATE_FIELDS = ['bitRate', 'rcMinRate', 'rcMaxRate', 'rcBufferSize'];
 function normalizeBitrate(value) {
     return typeof value === 'string' ? parseBitrate(value) : BigInt(value);
 }
+/**
+ * Highest rate taken as a frame rate, above it a rate is a stream clock.
+ *
+ * @internal
+ */
+const MAX_FRAME_RATE = 240;
+/**
+ * Frame rate declared when nothing knows the rate, FFmpeg CLI's default.
+ *
+ * @internal
+ */
+const FALLBACK_FRAME_RATE = 25;
+/**
+ * Whether a rate is a plausible frame rate rather than a stream clock.
+ *
+ * @param rate - The rate
+ *
+ * @returns True for a positive rate up to {@link MAX_FRAME_RATE}
+ *
+ * @internal
+ */
+function isFrameRate(rate) {
+    return rate.num > 0 && rate.den > 0 && rate.num / rate.den <= MAX_FRAME_RATE;
+}
 /**
  * High-level encoder for audio and video streams.
  *
@@ -159,7 +184,7 @@ export class Encoder {
     audioResampler;
     resampledFrame;
     resampleChangesRate = false;
-    resampledPts = 0n;
+    resampleInputRate = 0;
     audioInputLayout;
     autoFormat;
     videoScaler;
@@ -167,6 +192,9 @@ export class Encoder {
     videoTargetFormat;
     supportsParamChange;
     encoderChannels;
+    nextVideoPts;
+    droppedKeyframe = false;
+    keyframeRequested = false;
     // Worker pattern for push-based processing
     inputQueue;
     outputQueue;
@@ -213,6 +241,8 @@ export class Encoder {
      *
      * @throws {Error} If encoder not found
      *
+     * @throws {RangeError} If an audioFrameBuffer option is out of range
+     *
      * @example
      * ```typescript
      * // From decoder stream info
@@ -251,6 +281,8 @@ export class Encoder {
      * @see {@link createSync} For synchronous version
      */
     static async create(encoderCodec, options = {}) {
+        // Copied: defaults (e.g. bitrate) are filled in below
+        options = { ...options };
         let codec = null;
         if (encoderCodec instanceof Codec) {
             codec = encoderCodec;
@@ -264,6 +296,9 @@ export class Encoder {
         if (!codec) {
             throw new FFmpegError(AVERROR_ENCODER_NOT_FOUND);
         }
+        if (options.audioFrameBuffer) {
+            assertAudioFrameBufferOptions(options.audioFrameBuffer);
+        }
         // Allocate codec context
         const codecContext = new CodecContext();
         codecContext.allocContext3(codec);
@@ -274,14 +309,15 @@ export class Encoder {
         if (options.maxBFrames !== undefined) {
             codecContext.maxBFrames = options.maxBFrames;
         }
-        // Apply common options with codec-type-specific defaults
-        if (options.bitrate === undefined) {
-            // Set codec-type-specific default bitrate
-            const isAudio = codec.type === AVMEDIA_TYPE_AUDIO;
-            options.bitrate = isAudio ? 128_000 : 1_000_000;
+        // Audio bitrate is left to the codec's default like FFmpeg CLI does: it
+        // depends on codec, channels and rate (AAC 69k per mono channel, G.726 32k),
+        // and some codecs only open at specific rates (G.723.1: 6.3k/5.3k)
+        if (options.bitrate === undefined && codec.type !== AVMEDIA_TYPE_AUDIO) {
+            options.bitrate = 1_000_000;
+        }
+        if (options.bitrate !== undefined) {
+            codecContext.bitRate = typeof options.bitrate === 'string' ? parseBitrate(options.bitrate) : BigInt(options.bitrate);
         }
-        const bitrate = typeof options.bitrate === 'string' ? parseBitrate(options.bitrate) : BigInt(options.bitrate);
-        codecContext.bitRate = bitrate;
         if (options.minRate !== undefined) {
             const minRate = typeof options.minRate === 'string' ? parseBitrate(options.minRate) : BigInt(options.minRate);
             codecContext.rcMinRate = minRate;
@@ -330,6 +366,8 @@ export class Encoder {
      *
      * @throws {FFmpegError} If codec allocation fails
      *
+     * @throws {RangeError} If an audioFrameBuffer option is out of range
+     *
      * @example
      * ```typescript
      * // From decoder stream info
@@ -368,6 +406,8 @@ export class Encoder {
      * @see {@link create} For async version
      */
     static createSync(encoderCodec, options = {}) {
+        // Copied: defaults (e.g. bitrate) are filled in below
+        options = { ...options };
         let codec = null;
         if (encoderCodec instanceof Codec) {
             codec = encoderCodec;
@@ -381,17 +421,18 @@ export class Encoder {
         if (!codec) {
             throw new FFmpegError(AVERROR_ENCODER_NOT_FOUND);
         }
+        if (options.audioFrameBuffer) {
+            assertAudioFrameBufferOptions(options.audioFrameBuffer);
+        }
         // Allocate codec context
         const codecContext = new CodecContext();
         codecContext.allocContext3(codec);
-        // Apply common options with codec-type-specific defaults
-        if (options.bitrate === undefined) {
-            // Set codec-type-specific default bitrate
-            const isAudio = codec.type === AVMEDIA_TYPE_AUDIO;
-            options.bitrate = isAudio ? 128_000 : 1_000_000;
-        }
-        const bitrate = typeof options.bitrate === 'string' ? parseBitrate(options.bitrate) : BigInt(options.bitrate);
-        codecContext.bitRate = bitrate;
+        if (options.bitrate === undefined && codec.type !== AVMEDIA_TYPE_AUDIO) {
+            options.bitrate = 1_000_000;
+        }
+        if (options.bitrate !== undefined) {
+            codecContext.bitRate = typeof options.bitrate === 'string' ? parseBitrate(options.bitrate) : BigInt(options.bitrate);
+        }
         if (options.gopSize !== undefined) {
             codecContext.gopSize = options.gopSize;
         }
@@ -706,6 +747,24 @@ export class Encoder {
     isReady() {
         return this.initialized && !this.isClosed;
     }
+    /**
+     * Encode the next frame as a keyframe.
+     *
+     * Answers receiver feedback such as an RTCP PLI, so a receiver that lost
+     * packets resyncs on the next frame instead of waiting for the next GOP.
+     * Set the encoder's `forced-idr` option where it has one, otherwise some
+     * encoders (libx264, NVENC, QSV, AMF) emit an I frame that is not an IDR.
+     *
+     * @example
+     * ```typescript
+     * sender.onPictureLossIndication.subscribe(() => {
+     *   encoder.requestKeyframe();
+     * });
+     * ```
+     */
+    requestKeyframe() {
+        this.keyframeRequested = true;
+    }
     /**
      * Send a frame to the encoder.
      *
@@ -717,6 +776,10 @@ export class Encoder {
      * **Important**: This method only SENDS the frame to the encoder.
      * You must call {@link receive} separately (potentially multiple times) to get encoded packets.
      *
+     * Like FFmpeg CLI, a video frame whose timestamp lands on the previous frame's
+     * in the encoder time base moves to the next tick, and one that lies entirely
+     * before it is dropped, since encoders need strictly increasing timestamps.
+     *
      * Direct mapping to avcodec_send_frame().
      *
      * @param frame - Raw frame to send to encoder, or null to flush
@@ -780,8 +843,11 @@ export class Encoder {
         }
         // Convert to the codec's format first (audio resample / video pixfmt).
         const input = this.audioResampler ? this.resampleAudio(frame) : this.videoScaler ? this.scaleVideo(frame) : frame;
-        // Prepare frame for encoding (set quality, validate channel count)
-        this.prepareFrameForEncoding(input);
+        // Prepare frame for encoding (timestamps, quality, channel count); a video
+        // frame that falls behind the previous one is dropped
+        if (!this.prepareFrameForEncoding(input)) {
+            return;
+        }
         const encode = async (newFrame) => {
             const sendRet = await this.codecContext.sendFrame(newFrame);
             if (sendRet < 0 && sendRet !== AVERROR_EOF) {
@@ -809,6 +875,10 @@ export class Encoder {
      * **Important**: This method only SENDS the frame to the encoder.
      * You must call {@link receiveSync} separately (potentially multiple times) to get encoded packets.
      *
+     * Like FFmpeg CLI, a video frame whose timestamp lands on the previous frame's
+     * in the encoder time base moves to the next tick, and one that lies entirely
+     * before it is dropped, since encoders need strictly increasing timestamps.
+     *
      * Direct mapping to avcodec_send_frame().
      *
      * @param frame - Raw frame to send to encoder, or null to flush
@@ -855,8 +925,9 @@ export class Encoder {
         }
         // Convert to the codec's format first (audio resample / video pixfmt).
         const input = this.audioResampler ? this.resampleAudio(frame) : this.videoScaler ? this.scaleVideo(frame) : frame;
-        // Prepare frame for encoding (set quality, validate channel count)
-        this.prepareFrameForEncoding(input);
+        if (!this.prepareFrameForEncoding(input)) {
+            return;
+        }
         const encode = (newFrame) => {
             const sendRet = this.codecContext.sendFrameSync(newFrame);
             if (sendRet < 0 && sendRet !== AVERROR_EOF) {
@@ -1503,12 +1574,18 @@ export class Encoder {
         }
         // Clear previous packet data
         this.packet.unref();
-        if (this.audioFrameBuffer?.hasFrame()) {
+        // Skip frames the codec rejects (e.g. aac "Input contains (near) NaN/+-Inf"). Pulling a single
+        // frame per call would leave the rest in the FIFO while every encode() adds more.
+        while (this.audioFrameBuffer?.hasFrame()) {
             const env_9 = { stack: [], error: void 0, hasError: false };
             try {
                 const bufferedFrame = __addDisposableResource(env_9, await this.audioFrameBuffer.pull(), false);
-                if (bufferedFrame) {
-                    await this.codecContext.sendFrame(bufferedFrame);
+                if (!bufferedFrame) {
+                    break;
+                }
+                const sendRet = await this.codecContext.sendFrame(bufferedFrame);
+                if (sendRet >= 0 || sendRet === AVERROR_EAGAIN) {
+                    break;
                 }
             }
             catch (e_9) {
@@ -1608,12 +1685,17 @@ export class Encoder {
         }
         // Clear previous packet data
         this.packet.unref();
-        if (this.audioFrameBuffer?.hasFrame()) {
+        // Skip frames the codec rejects, see receive()
+        while (this.audioFrameBuffer?.hasFrame()) {
             const env_10 = { stack: [], error: void 0, hasError: false };
             try {
                 const bufferedFrame = __addDisposableResource(env_10, this.audioFrameBuffer.pullSync(), false);
-                if (bufferedFrame) {
-                    this.codecContext.sendFrameSync(bufferedFrame);
+                if (!bufferedFrame) {
+                    break;
+                }
+                const sendRet = this.codecContext.sendFrameSync(bufferedFrame);
+                if (sendRet >= 0 || sendRet === AVERROR_EAGAIN) {
+                    break;
                 }
             }
             catch (e_10) {
@@ -1714,7 +1796,6 @@ export class Encoder {
         this.outputQueue.close();
         this.inputQueue.clear();
         this.outputQueue.clear();
-        this.packet.free();
         this.audioFrameBuffer?.[Symbol.dispose]();
         this.audioFrameBuffer = undefined;
         this.audioResampler?.[Symbol.dispose]();
@@ -1726,6 +1807,7 @@ export class Encoder {
         this.scaledFrame?.free();
         this.scaledFrame = undefined;
         this.codecContext.freeContext();
+        this.packet.free();
         this.initialized = false;
     }
     /**
@@ -1778,8 +1860,6 @@ export class Encoder {
                         this.initializePromise ??= this.initialize(frame);
                     }
                     await this.initializePromise;
-                    // Prepare frame for encoding (set quality, validate channel count)
-                    this.prepareFrameForEncoding(frame);
                     await this.encode(frame);
                     // Receive packets
                     while (!this.outputQueue.isClosed) {
@@ -1891,6 +1971,58 @@ export class Encoder {
         }
         applyContextOptions(this.codecContext, resolved);
     }
+    /**
+     * Set the frame rate and time base of a video encoder from its first frame.
+     *
+     * Shared by both initialize variants.
+     *
+     * @param frame - First frame to encode
+     *
+     * @internal
+     */
+    setupVideoTiming(frame) {
+        // Get framerate from filter if available, otherwise from decoder
+        // This matches FFmpeg CLI behavior where encoder gets frame_rate_filter from FrameData
+        const filterFrameRate = this.options.filter?.frameRate;
+        if (filterFrameRate) {
+            this.codecContext.framerate = new Rational(filterFrameRate.num, filterFrameRate.den);
+        }
+        // If no filter framerate, try to get from decoder stream
+        if ((!this.codecContext.framerate || this.codecContext.framerate.num === 0) && this.options.decoder) {
+            const decoderCtx = this.options.decoder.getCodecContext();
+            if (decoderCtx?.framerate && decoderCtx.framerate.num > 0) {
+                this.codecContext.framerate = decoderCtx.framerate;
+            }
+            else {
+                // The bitstream carries no rate (e.g. MJPEG, or an H.264 camera without
+                // VUI timing): guess it from the stream like FFmpeg CLI does. A stream
+                // probed too briefly to see two frames (RTPStream reads with
+                // analyzeduration 0) offers only its clock as rate (e.g. 90000/1).
+                const guessed = this.options.decoder.getGuessedFrameRate();
+                if (isFrameRate(guessed)) {
+                    this.codecContext.framerate = new Rational(guessed.num, guessed.den);
+                }
+            }
+        }
+        // FFmpeg CLI sets encoder time_base to 1/framerate (inverse of framerate)
+        // This allows encoder to produce sequential PTS (0, 1, 2, 3...) which enables
+        // proper B-frame DTS generation (negative DTS values)
+        if (this.codecContext.framerate && this.codecContext.framerate.num > 0) {
+            // Use inverse of framerate (e.g., framerate=30/1 → timebase=1/30)
+            this.codecContext.timeBase = new Rational(this.codecContext.framerate.den, this.codecContext.framerate.num);
+            return;
+        }
+        // Fallback: use frame timebase if framerate not available
+        this.codecContext.timeBase = frame.timeBase;
+        // Without a framerate encoders read the inverse time base as one: for a
+        // 90 kHz clock x264 picks level 6.2 and VAAPI and QSV fail to encode.
+        // Declare FFmpeg CLI's default rate and keep the clock, so the timestamps
+        // stay apart whatever the real rate is.
+        if (!isFrameRate({ num: frame.timeBase.den, den: frame.timeBase.num })) {
+            Log.log(AV_LOG_WARNING, `No information about the input frame rate is available, encoding as ${FALLBACK_FRAME_RATE} fps\n`);
+            this.codecContext.framerate = new Rational(FALLBACK_FRAME_RATE, 1);
+        }
+    }
     /**
      * Initialize encoder from first frame.
      *
@@ -1912,33 +2044,8 @@ export class Encoder {
                 this.codecContext.bitsPerRawSample = decoderCtx.bitsPerRawSample;
             }
         }
-        // Get framerate from filter if available, otherwise from decoder
-        // This matches FFmpeg CLI behavior where encoder gets frame_rate_filter from FrameData
-        if (this.options.filter && frame.isVideo()) {
-            const filterFrameRate = this.options.filter.frameRate;
-            if (filterFrameRate) {
-                this.codecContext.framerate = new Rational(filterFrameRate.num, filterFrameRate.den);
-            }
-        }
-        // If no filter framerate, try to get from decoder stream
-        if ((!this.codecContext.framerate || this.codecContext.framerate.num === 0) && this.options.decoder && frame.isVideo()) {
-            const decoderCtx = this.options.decoder.getCodecContext();
-            if (decoderCtx?.framerate && decoderCtx.framerate.num > 0) {
-                this.codecContext.framerate = decoderCtx.framerate;
-            }
-        }
         if (frame.isVideo()) {
-            // FFmpeg CLI sets encoder time_base to 1/framerate (inverse of framerate)
-            // This allows encoder to produce sequential PTS (0, 1, 2, 3...) which enables
-            // proper B-frame DTS generation (negative DTS values)
-            if (this.codecContext.framerate && this.codecContext.framerate.num > 0) {
-                // Use inverse of framerate (e.g., framerate=30/1 → timebase=1/30)
-                this.codecContext.timeBase = new Rational(this.codecContext.framerate.den, this.codecContext.framerate.num);
-            }
-            else {
-                // Fallback: use frame timebase if framerate not available
-                this.codecContext.timeBase = frame.timeBase;
-            }
+            this.setupVideoTiming(frame);
             this.codecContext.width = frame.width;
             this.codecContext.height = frame.height;
             // Pick a codec-supported pixel format (converting on demand when autoFormat).
@@ -1976,7 +2083,7 @@ export class Encoder {
         // Check if encoder requires fixed frame size (e.g., Opus, AAC, MP3)
         // If so, create AudioFrameBuffer to automatically chunk frames
         if (frame.isAudio() && this.codecContext.frameSize > 0) {
-            this.audioFrameBuffer = AudioFrameBuffer.create(this.codecContext.frameSize, this.codecContext.sampleFormat, this.codecContext.sampleRate, this.codecContext.channelLayout, this.codecContext.channels);
+            this.audioFrameBuffer = AudioFrameBuffer.create(this.codecContext.frameSize, this.codecContext.sampleFormat, this.codecContext.sampleRate, this.codecContext.channelLayout, this.codecContext.channels, this.options.audioFrameBuffer);
         }
         this.initialized = true;
     }
@@ -2004,33 +2111,8 @@ export class Encoder {
                 this.codecContext.bitsPerRawSample = decoderCtx.bitsPerRawSample;
             }
         }
-        // Get framerate from filter if available, otherwise from decoder
-        // This matches FFmpeg CLI behavior where encoder gets frame_rate_filter from FrameData
-        if (this.options.filter && frame.isVideo()) {
-            const filterFrameRate = this.options.filter.frameRate;
-            if (filterFrameRate) {
-                this.codecContext.framerate = new Rational(filterFrameRate.num, filterFrameRate.den);
-            }
-        }
-        // If no filter framerate, try to get from decoder stream
-        if ((!this.codecContext.framerate || this.codecContext.framerate.num === 0) && this.options.decoder && frame.isVideo()) {
-            const decoderCtx = this.options.decoder.getCodecContext();
-            if (decoderCtx?.framerate && decoderCtx.framerate.num > 0) {
-                this.codecContext.framerate = decoderCtx.framerate;
-            }
-        }
         if (frame.isVideo()) {
-            // FFmpeg CLI sets encoder time_base to 1/framerate (inverse of framerate)
-            // This allows encoder to produce sequential PTS (0, 1, 2, 3...) which enables
-            // proper B-frame DTS generation (negative DTS values)
-            if (this.codecContext.framerate && this.codecContext.framerate.num > 0) {
-                // Use inverse of framerate (e.g., framerate=30/1 → timebase=1/30)
-                this.codecContext.timeBase = new Rational(this.codecContext.framerate.den, this.codecContext.framerate.num);
-            }
-            else {
-                // Fallback: use frame timebase if framerate not available
-                this.codecContext.timeBase = frame.timeBase;
-            }
+            this.setupVideoTiming(frame);
             this.codecContext.width = frame.width;
             this.codecContext.height = frame.height;
             // Pick a codec-supported pixel format (converting on demand when autoFormat).
@@ -2069,7 +2151,7 @@ export class Encoder {
         // Check if encoder requires fixed frame size (e.g., Opus, AAC, MP3)
         // If so, create AudioFrameBuffer to automatically chunk frames
         if (frame.isAudio() && this.codecContext.frameSize > 0) {
-            this.audioFrameBuffer = AudioFrameBuffer.create(this.codecContext.frameSize, this.codecContext.sampleFormat, this.codecContext.sampleRate, this.codecContext.channelLayout, this.codecContext.channels);
+            this.audioFrameBuffer = AudioFrameBuffer.create(this.codecContext.frameSize, this.codecContext.sampleFormat, this.codecContext.sampleRate, this.codecContext.channelLayout, this.codecContext.channels, this.options.audioFrameBuffer);
         }
         this.initialized = true;
     }
@@ -2172,13 +2254,11 @@ export class Encoder {
         const targetRate = pickSupportedRate(inRate, this.codec.supportedSamplerates);
         const targetFmt = pickSupportedSampleFormat(inFmt, this.codec.sampleFormats);
         const targetLayout = pickSupportedLayout(inLayout, this.codec.channelLayouts);
-        // When the codec forces a different sample rate, the frames that reach it
-        // carry PTS as a running sample counter at that rate (resampler and FIFO
-        // paths), so the codec timebase must be 1/target_rate - the input timebase
-        // would misread those counts (e.g. 44.1 kHz in -> Opus-forced 48 kHz would
-        // play ~8.8% slow). Without rate conversion, keep the frame timebase
-        // (typically 1/sample_rate).
+        // When the codec forces a different sample rate, the resampler stamps its
+        // output in 1/target_rate, so that is the codec timebase. Without rate
+        // conversion, keep the frame timebase (typically 1/sample_rate).
         this.resampleChangesRate = targetRate !== inRate;
+        this.resampleInputRate = inRate;
         this.codecContext.timeBase = this.resampleChangesRate ? new Rational(1, targetRate) : frame.timeBase;
         const needsResample = targetRate !== inRate || targetFmt !== inFmt || targetLayout.nbChannels !== inLayout.nbChannels;
         if (needsResample && !this.autoResample) {
@@ -2228,13 +2308,16 @@ export class Encoder {
      * Resample an incoming audio frame to the codec's target format.
      *
      * Reuses a single output frame; `swr_convert_frame` allocates/sizes its buffer.
-     * The (fixed-frame-size) audio FIFO copies the samples and re-stamps PTS, so the
-     * reused frame and its carried timing are only relevant on the non-FIFO path.
+     * The output keeps the input timing: with rate conversion it is stamped with the
+     * time of its first output sample in 1/target_rate, otherwise it carries the input
+     * frame's PTS and timebase.
      *
      * @param frame - Source audio frame
      *
      * @returns The resampled frame (owned by the encoder, reused across calls)
      *
+     * @throws {FFmpegError} If resampling fails
+     *
      * @internal
      */
     resampleAudio(frame) {
@@ -2243,15 +2326,14 @@ export class Encoder {
         out.format = this.codecContext.sampleFormat;
         out.sampleRate = this.codecContext.sampleRate;
         out.channelLayout = this.codecContext.channelLayout;
+        // Rate conversion holds samples back inside swr, so this call's first output
+        // sample is older than the input frame's first sample. swr_next_pts() accounts
+        // for that delay (as the aresample filter does) and must run before converting.
+        const pts = this.resampleChangesRate ? this.nextResampledPts(frame) : AV_NOPTS_VALUE;
         FFmpegError.throwIfError(this.audioResampler.convertFrame(out, frame), 'Failed to resample audio frame');
         if (this.resampleChangesRate) {
-            // Rate conversion changes the sample count, so the input PTS no longer
-            // matches the output. Stamp from a running output-sample counter in
-            // 1/out_rate (the codec timebase) - the same scheme the FIFO path uses
-            // when re-stamping - instead of replicating swr_next_pts() delay tracking.
             out.timeBase = this.codecContext.timeBase;
-            out.pts = this.resampledPts;
-            this.resampledPts += BigInt(out.nbSamples);
+            out.pts = pts;
         }
         else {
             out.timeBase = frame.timeBase;
@@ -2276,18 +2358,46 @@ export class Encoder {
         out.format = this.codecContext.sampleFormat;
         out.sampleRate = this.codecContext.sampleRate;
         out.channelLayout = this.codecContext.channelLayout;
+        const pts = this.resampleChangesRate ? this.nextResampledPts(null) : AV_NOPTS_VALUE;
         const ret = this.audioResampler.convertFrame(out, null);
         if (ret < 0 || out.nbSamples <= 0) {
             return null;
         }
         if (this.resampleChangesRate) {
-            // Continue the running output-sample counter (see resampleAudio)
             out.timeBase = this.codecContext.timeBase;
-            out.pts = this.resampledPts;
-            this.resampledPts += BigInt(out.nbSamples);
+            out.pts = pts;
         }
         return out;
     }
+    /**
+     * Timestamp of the resampler's next output sample in 1/target_rate.
+     *
+     * Mirrors the aresample filter: the input PTS goes to swr_next_pts() in
+     * 1/(in_rate * out_rate), which subtracts the samples still buffered in the
+     * resampler. Without an input PTS (or when draining) swr continues from the
+     * samples it has output so far.
+     *
+     * @param frame - Input frame about to be converted, or null when draining
+     *
+     * @returns Output timestamp in 1/target_rate
+     *
+     * @internal
+     */
+    nextResampledPts(frame) {
+        const inRate = BigInt(this.resampleInputRate);
+        const outRate = BigInt(this.codecContext.sampleRate);
+        let inPts = AV_NOPTS_VALUE;
+        if (frame && frame.pts !== AV_NOPTS_VALUE) {
+            const tb = frame.timeBase;
+            if (tb.num > 0 && tb.den > 0) {
+                inPts = avRescaleRnd(frame.pts, BigInt(tb.num) * inRate * outRate, BigInt(tb.den), AV_ROUND_NEAR_INF);
+            }
+        }
+        // Rounded division back to 1/out_rate (ROUNDED_DIV in af_aresample)
+        const outPts = this.audioResampler.nextPts(inPts);
+        const half = inRate / 2n;
+        return (outPts >= 0n ? outPts + half : outPts - half) / inRate;
+    }
     /**
      * Configure the codec context's pixel format from the first video frame.
      *
@@ -2374,21 +2484,31 @@ export class Encoder {
      * Prepare frame for encoding.
      *
      * Implements FFmpeg's frame_encode() pre-encoding logic:
-     * 1. Video: Sets frame.quality from encoder's globalQuality (like -qscale)
-     * 2. Audio: Validates channel count consistency for encoders without PARAM_CHANGE capability
+     * 1. Video: Keeps timestamps strictly increasing like the CLI's VFR sync
+     * 2. Video: Sets frame.quality from encoder's globalQuality (like -qscale)
+     * 3. Audio: Validates channel count consistency for encoders without PARAM_CHANGE capability
      *
      * This matches FFmpeg CLI behavior where these properties are automatically managed.
      *
      * @param frame - Frame to prepare for encoding
      *
+     * @returns False if the frame must be dropped
+     *
      * @throws {Error} If audio channel count changed and encoder doesn't support parameter changes
      *
      * @internal
      */
     prepareFrameForEncoding(frame) {
-        // Clear pict_type - encoder will determine frame types based on its own settings
-        // Input stream's frame type hints are irrelevant when re-encoding
-        frame.pictType = AV_PICTURE_TYPE_NONE;
+        // Clear pict_type - encoder will determine frame types based on its own settings.
+        // Input stream's frame type hints are irrelevant when re-encoding. Opt out with
+        // { preserveFramePictType: true } to force keyframes via frame.pictType = I.
+        if (!this.options.preserveFramePictType) {
+            frame.pictType = AV_PICTURE_TYPE_NONE;
+        }
+        if (this.keyframeRequested) {
+            this.keyframeRequested = false;
+            frame.pictType = AV_PICTURE_TYPE_I;
+        }
         // Adjust frame PTS and timebase to encoder timebase
         // This matches FFmpeg's adjust_frame_pts_to_encoder_tb() behavior which:
         // 1. Converts PTS from frame's timebase to encoder's timebase (av_rescale_q)
@@ -2433,6 +2553,26 @@ export class Encoder {
         frame.duration = frameDuration;
         const codecType = this.codecContext.codecType;
         if (codecType === AVMEDIA_TYPE_VIDEO) {
+            // Encoders need strictly increasing pts, but frames arriving in a burst can
+            // round onto the same tick of the encoder time base (e.g. 1/25). Like FFmpeg
+            // CLI's VFR sync (video_sync_process): a frame that still reaches the next
+            // free tick moves there, one that ends before it is dropped.
+            if (frame.pts !== AV_NOPTS_VALUE) {
+                const nextPts = this.nextVideoPts;
+                if (nextPts !== undefined && frame.pts < nextPts) {
+                    if (frame.pts + frameDuration < nextPts) {
+                        // A requested keyframe goes to the next frame instead, as in the CLI
+                        this.droppedKeyframe ||= frame.pictType === AV_PICTURE_TYPE_I;
+                        return false;
+                    }
+                    frame.pts = nextPts;
+                }
+                this.nextVideoPts = frame.pts + 1n;
+            }
+            if (this.droppedKeyframe) {
+                frame.pictType = AV_PICTURE_TYPE_I;
+                this.droppedKeyframe = false;
+            }
             // Video: Set frame quality from encoder's global quality
             // Only set if encoder has globalQuality configured and frame doesn't already have quality set
             const globalQuality = this.codecContext.globalQuality;
@@ -2454,6 +2594,7 @@ export class Encoder {
                 }
             }
         }
+        return true;
     }
     /**
      * Dispose of encoder.