node-av 3.1.3 → 5.0.0

package/dist/api/bitstream-filter.js

@@ -1,10 +1,70 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { AVERROR_EAGAIN, AVERROR_EOF } from '../constants/constants.js';
-import { BitStreamFilter, BitStreamFilterContext, FFmpegError, Packet } from '../lib/index.js';
+import { BitStreamFilterContext } from '../lib/bitstream-filter-context.js';
+import { BitStreamFilter } from '../lib/bitstream-filter.js';
+import { FFmpegError } from '../lib/error.js';
+import { Packet } from '../lib/packet.js';
+import { PACKET_THREAD_QUEUE_SIZE } from './constants.js';
+import { Muxer } from './muxer.js';
+import { AsyncQueue } from './utilities/async-queue.js';
+import { Scheduler, SchedulerControl } from './utilities/scheduler.js';
 /**
  * High-level bitstream filter for packet processing.
  *
  * Provides simplified interface for applying bitstream filters to packets.
  * Handles filter initialization, packet processing, and memory management.
+ * Supports both synchronous packet-by-packet filtering and async iteration over packets.
  * Supports filters like h264_mp4toannexb, hevc_mp4toannexb, aac_adtstoasc.
  * Essential for format conversion and stream compatibility in transcoding pipelines.
  *
@@ -15,8 +75,8 @@ import { BitStreamFilter, BitStreamFilterContext, FFmpegError, Packet } from '..
  * // Create H.264 Annex B converter
  * const filter = BitStreamFilterAPI.create('h264_mp4toannexb', stream);
  *
- * // Process packet
- * const outputPackets = await filter.process(inputPacket);
+ * // Filter packet
+ * const outputPackets = await filter.filterAll(inputPacket);
  * for (const packet of outputPackets) {
  *   await output.writePacket(packet);
  *   packet.free();
@@ -25,7 +85,7 @@ import { BitStreamFilter, BitStreamFilterContext, FFmpegError, Packet } from '..
  *
  * @example
  * ```typescript
- * // Process packet stream
+ * // Filter packet stream
  * const filter = BitStreamFilterAPI.create('hevc_mp4toannexb', videoStream);
  *
  * for await (const packet of filter.packets(input.packets())) {
@@ -36,15 +96,22 @@ import { BitStreamFilter, BitStreamFilterContext, FFmpegError, Packet } from '..
  *
  * @see {@link BitStreamFilter} For available filters
  * @see {@link BitStreamFilterContext} For low-level API
- * @see {@link MediaOutput} For writing filtered packets
+ * @see {@link Muxer} For writing filtered packets
  */
 export class BitStreamFilterAPI {
     ctx;
-    filter;
+    bsf;
     stream;
+    packet;
     isClosed = false;
+    // Worker pattern for push-based processing
+    inputQueue;
+    outputQueue;
+    workerPromise = null;
+    nextComponent = null;
+    pipeToPromise = null;
     /**
-     * @param filter - Bitstream filter instance
+     * @param bsf - Bitstream filter
      *
      * @param ctx - Filter context
      *
@@ -52,10 +119,14 @@ export class BitStreamFilterAPI {
      *
      * @internal
      */
-    constructor(filter, ctx, stream) {
-        this.filter = filter;
+    constructor(bsf, ctx, stream) {
+        this.bsf = bsf;
         this.ctx = ctx;
         this.stream = stream;
+        this.packet = new Packet();
+        this.packet.alloc();
+        this.inputQueue = new AsyncQueue(PACKET_THREAD_QUEUE_SIZE);
+        this.outputQueue = new AsyncQueue(PACKET_THREAD_QUEUE_SIZE);
     }
     /**
      * Create a bitstream filter for a stream.
@@ -136,7 +207,7 @@ export class BitStreamFilterAPI {
      * ```
      */
     get name() {
-        return this.filter.name ?? 'unknown';
+        return this.bsf.name ?? 'unknown';
     }
     /**
      * Get output codec parameters.
@@ -181,125 +252,211 @@ export class BitStreamFilterAPI {
         return !this.isClosed;
     }
     /**
-     * Process a packet through the filter.
+     * Filter a packet.
      *
-     * Applies bitstream filter to packet.
-     * May produce zero, one, or multiple output packets.
-     * Pass null to signal end-of-stream.
+     * Sends a packet to the filter and attempts to receive a filtered packet.
+     * Handles internal buffering - may return null if more packets needed.
+     *
+     * **Note**: This method receives only ONE packet per call.
+     * A single packet can produce multiple output packets (e.g., codec buffering).
+     * To receive all packets from a packet, use {@link filterAll} or {@link packets} instead.
      *
      * Direct mapping to av_bsf_send_packet() and av_bsf_receive_packet().
      *
-     * @param packet - Packet to filter or null for EOF
+     * @param packet - Packet to filter
      *
-     * @returns Array of filtered packets or null if filter is closed
+     * @returns Filtered packet, null if more data needed, or null if filter is closed
      *
      * @throws {FFmpegError} If filtering fails
      *
      * @example
      * ```typescript
-     * const outputPackets = await filter.process(inputPacket);
-     * if (outputPackets) {
-     *   for (const packet of outputPackets) {
-     *     console.log(`Filtered packet: pts=${packet.pts}`);
-     *     packet.free();
-     *   }
+     * const outPacket = await filter.filter(inputPacket);
+     * if (outPacket) {
+     *   console.log(`Filtered packet: pts=${outPacket.pts}`);
+     *   await output.writePacket(outPacket);
+     *   outPacket.free();
      * }
      * ```
      *
+     * @see {@link filterAll} For multiple packet filtering
+     * @see {@link packets} For stream processing
+     * @see {@link flush} For end-of-stream handling
+     * @see {@link filterSync} For synchronous version
+     */
+    async filter(packet) {
+        if (this.isClosed) {
+            return null;
+        }
+        // Send packet to filter
+        const sendRet = await this.ctx.sendPacket(packet);
+        // Handle EAGAIN: filter buffer is full, need to read packets first
+        if (sendRet === AVERROR_EAGAIN) {
+            // Filter is full, receive a packet first
+            const outPacket = await this.receive();
+            if (outPacket) {
+                return outPacket;
+            }
+            // If receive() returned null, this is unexpected - treat as error
+            throw new Error('Filter returned EAGAIN but no packet available');
+        }
+        if (sendRet < 0 && sendRet !== AVERROR_EOF) {
+            FFmpegError.throwIfError(sendRet, 'Failed to send packet to bitstream filter');
+        }
+        // Try to receive packet
+        return await this.receive();
+    }
+    /**
+     * Filter a packet synchronously.
+     * Synchronous version of filter.
+     *
+     * Sends a packet to the filter and attempts to receive a filtered packet.
+     * Handles internal buffering - may return null if more packets needed.
+     *
+     * **Note**: This method receives only ONE packet per call.
+     * A single packet can produce multiple output packets (e.g., codec buffering).
+     * To receive all packets from a packet, use {@link filterAllSync} or {@link packetsSync} instead.
+     *
+     * Direct mapping to av_bsf_send_packet() and av_bsf_receive_packet().
+     *
+     * @param packet - Packet to filter
+     *
+     * @returns Filtered packet, null if more data needed, or null if filter is closed
+     *
+     * @throws {FFmpegError} If filtering fails
+     *
      * @example
      * ```typescript
-     * // Flush filter
-     * const remaining = await filter.process(null);
+     * const outPacket = filter.filterSync(inputPacket);
+     * if (outPacket) {
+     *   console.log(`Filtered packet: pts=${outPacket.pts}`);
+     *   output.writePacketSync(outPacket);
+     *   outPacket.free();
+     * }
      * ```
      *
-     * @see {@link flush} For explicit flushing
+     * @see {@link filterAllSync} For multiple packet filtering
+     * @see {@link packetsSync} For stream processing
+     * @see {@link flushSync} For end-of-stream handling
+     * @see {@link filter} For async version
+     */
+    filterSync(packet) {
+        if (this.isClosed) {
+            return null;
+        }
+        // Send packet to filter
+        const sendRet = this.ctx.sendPacketSync(packet);
+        // Handle EAGAIN: filter buffer is full, need to read packets first
+        if (sendRet === AVERROR_EAGAIN) {
+            // Filter is full, receive a packet first
+            const outPacket = this.receiveSync();
+            if (outPacket) {
+                return outPacket;
+            }
+            // If receive() returned null, this is unexpected - treat as error
+            throw new Error('Filter returned EAGAIN but no packet available');
+        }
+        if (sendRet < 0 && sendRet !== AVERROR_EOF) {
+            FFmpegError.throwIfError(sendRet, 'Failed to send packet to bitstream filter');
+        }
+        // Try to receive packet
+        return this.receiveSync();
+    }
+    /**
+     * Filter a packet to packets.
+     *
+     * Sends a packet to the filter and receives all available filtered packets.
+     * Returns array of packets - may be empty if filter needs more data.
+     * One packet can produce zero, one, or multiple packets depending on filter.
+     *
+     * Direct mapping to av_bsf_send_packet() and av_bsf_receive_packet().
+     *
+     * @param packet - Packet to filter
+     *
+     * @returns Array of filtered packets (empty if more data needed or filter is closed)
+     *
+     * @throws {FFmpegError} If filtering fails
+     *
+     * @example
+     * ```typescript
+     * const outputPackets = await filter.filterAll(inputPacket);
+     * for (const packet of outputPackets) {
+     *   console.log(`Filtered packet: pts=${packet.pts}`);
+     *   await output.writePacket(packet);
+     *   packet.free();
+     * }
+     * ```
+     *
+     * @see {@link filter} For single packet filtering
      * @see {@link packets} For stream processing
+     * @see {@link flush} For end-of-stream handling
+     * @see {@link filterAllSync} For synchronous version
      */
-    async process(packet) {
+    async filterAll(packet) {
         if (this.isClosed) {
             return [];
         }
         const outputPackets = [];
         // Send packet to filter
         const sendRet = await this.ctx.sendPacket(packet);
-        if (sendRet < 0 && sendRet !== AVERROR_EAGAIN) {
+        if (sendRet < 0 && sendRet !== AVERROR_EOF) {
             FFmpegError.throwIfError(sendRet, 'Failed to send packet to bitstream filter');
         }
         // Receive all output packets
-        while (!this.isClosed) {
-            const outPacket = new Packet();
-            outPacket.alloc();
-            const recvRet = await this.ctx.receivePacket(outPacket);
-            if (recvRet === AVERROR_EAGAIN || recvRet === AVERROR_EOF) {
-                outPacket.unref();
+        while (true) {
+            const outPacket = await this.receive();
+            if (!outPacket)
                 break;
-            }
-            if (recvRet < 0) {
-                outPacket.unref();
-                FFmpegError.throwIfError(recvRet, 'Failed to receive packet from bitstream filter');
-            }
             outputPackets.push(outPacket);
         }
         return outputPackets;
     }
     /**
-     * Process a packet through the filter synchronously.
-     * Synchronous version of process.
+     * Filter a packet to packets synchronously.
+     * Synchronous version of filterAll.
      *
-     * Applies bitstream filter to packet.
-     * May produce zero, one, or multiple output packets.
-     * Pass null to signal end-of-stream.
+     * Sends a packet to the filter and receives all available filtered packets.
+     * Returns array of packets - may be empty if filter needs more data.
+     * One packet can produce zero, one, or multiple packets depending on filter.
      *
      * Direct mapping to av_bsf_send_packet() and av_bsf_receive_packet().
      *
-     * @param packet - Packet to filter or null for EOF
+     * @param packet - Packet to filter
      *
-     * @returns Array of filtered packets or null if filter is closed
+     * @returns Array of filtered packets (empty if more data needed or filter is closed)
      *
      * @throws {FFmpegError} If filtering fails
      *
      * @example
      * ```typescript
-     * const outputPackets = filter.processSync(inputPacket);
-     * if (outputPackets) {
-     *   for (const packet of outputPackets) {
-     *     console.log(`Filtered packet: pts=${packet.pts}`);
-     *     packet.free();
-     *   }
+     * const outputPackets = filter.filterAllSync(inputPacket);
+     * for (const packet of outputPackets) {
+     *   console.log(`Filtered packet: pts=${packet.pts}`);
+     *   output.writePacketSync(packet);
+     *   packet.free();
      * }
      * ```
      *
-     * @example
-     * ```typescript
-     * // Flush filter
-     * const remaining = filter.processSync(null);
-     * ```
-     *
-     * @see {@link process} For async version
+     * @see {@link filterSync} For single packet filtering
+     * @see {@link packetsSync} For stream processing
+     * @see {@link flushSync} For end-of-stream handling
+     * @see {@link filterAll} For async version
      */
-    processSync(packet) {
+    filterAllSync(packet) {
         if (this.isClosed) {
             return [];
         }
         const outputPackets = [];
         // Send packet to filter
         const sendRet = this.ctx.sendPacketSync(packet);
-        if (sendRet < 0 && sendRet !== AVERROR_EAGAIN) {
+        if (sendRet < 0 && sendRet !== AVERROR_EOF) {
             FFmpegError.throwIfError(sendRet, 'Failed to send packet to bitstream filter');
         }
         // Receive all output packets
-        while (!this.isClosed) {
-            const outPacket = new Packet();
-            outPacket.alloc();
-            const recvRet = this.ctx.receivePacketSync(outPacket);
-            if (recvRet === AVERROR_EAGAIN || recvRet === AVERROR_EOF) {
-                outPacket.unref();
+        while (true) {
+            const outPacket = this.receiveSync();
+            if (!outPacket)
                 break;
-            }
-            if (recvRet < 0) {
-                outPacket.unref();
-                FFmpegError.throwIfError(recvRet, 'Failed to receive packet from bitstream filter');
-            }
             outputPackets.push(outPacket);
         }
         return outputPackets;
@@ -338,33 +495,67 @@ export class BitStreamFilterAPI {
      * }
      * ```
      *
-     * @see {@link process} For single packet filtering
+     * @see {@link filterAll} For filtering single packets
      * @see {@link flush} For end-of-stream handling
      */
     async *packets(packets) {
-        try {
-            // Process all input packets
-            for await (const packet of packets) {
-                const filtered = await this.process(packet);
-                if (filtered) {
-                    for (const outPacket of filtered) {
-                        yield outPacket;
-                    }
+        // Process all input packets
+        for await (const packet of packets) {
+            // Handle EOF signal
+            if (packet === null) {
+                // Flush filter
+                await this.flush();
+                while (true) {
+                    const remaining = await this.receive();
+                    if (!remaining)
+                        break;
+                    yield remaining;
                 }
+                // Signal EOF and stop processing
+                yield null;
+                return;
+            }
+            if (this.isClosed) {
+                break;
             }
-            // Send EOF and get remaining packets
-            const remaining = await this.flush();
-            if (remaining) {
-                for (const packet of remaining) {
-                    yield packet;
+            // Send packet to filter
+            const sendRet = await this.ctx.sendPacket(packet);
+            // Handle EAGAIN
+            if (sendRet === AVERROR_EAGAIN) {
+                // Filter buffer full, receive packets first
+                while (true) {
+                    const outPacket = await this.receive();
+                    if (!outPacket)
+                        break;
+                    yield outPacket;
                 }
+                // Retry sending
+                const retryRet = await this.ctx.sendPacket(packet);
+                if (retryRet < 0 && retryRet !== AVERROR_EOF && retryRet !== AVERROR_EAGAIN) {
+                    FFmpegError.throwIfError(retryRet, 'Failed to send packet to bitstream filter');
+                }
+            }
+            else if (sendRet < 0 && sendRet !== AVERROR_EOF) {
+                FFmpegError.throwIfError(sendRet, 'Failed to send packet to bitstream filter');
+            }
+            // Receive ALL available packets immediately
+            while (true) {
+                const outPacket = await this.receive();
+                if (!outPacket)
+                    break; // EAGAIN or EOF
+                yield outPacket;
             }
         }
-        catch (error) {
-            // Ensure cleanup on error
-            this.ctx.flush();
-            throw error;
+        // Flush filter after all packets (fallback if no null was sent)
+        await this.flush();
+        while (true) {
+            const remaining = await this.receive();
+            if (!remaining)
+                break;
+            yield remaining;
         }
+        // Signal EOF
+        yield null;
     }
     /**
      * Process packet stream through filter synchronously.
@@ -404,149 +595,331 @@ export class BitStreamFilterAPI {
      * @see {@link packets} For async version
      */
     *packetsSync(packets) {
-        try {
-            // Process all input packets
-            for (const packet of packets) {
-                const filtered = this.processSync(packet);
-                if (filtered) {
-                    for (const outPacket of filtered) {
-                        yield outPacket;
-                    }
+        // Process all input packets
+        for (const packet of packets) {
+            // Handle EOF signal
+            if (packet === null) {
+                // Flush filter
+                this.flushSync();
+                while (true) {
+                    const remaining = this.receiveSync();
+                    if (!remaining)
+                        break;
+                    yield remaining;
                 }
+                // Signal EOF and stop processing
+                yield null;
+                return;
+            }
+            if (this.isClosed) {
+                break;
             }
-            // Send EOF and get remaining packets
-            const remaining = this.flushSync();
-            if (remaining) {
-                for (const packet of remaining) {
-                    yield packet;
+            // Send packet to filter
+            const sendRet = this.ctx.sendPacketSync(packet);
+            // Handle EAGAIN
+            if (sendRet === AVERROR_EAGAIN) {
+                // Filter buffer full, receive packets first
+                while (true) {
+                    const outPacket = this.receiveSync();
+                    if (!outPacket)
+                        break;
+                    yield outPacket;
                 }
+                // Retry sending
+                const retryRet = this.ctx.sendPacketSync(packet);
+                if (retryRet < 0 && retryRet !== AVERROR_EOF && retryRet !== AVERROR_EAGAIN) {
+                    FFmpegError.throwIfError(retryRet, 'Failed to send packet to bitstream filter');
+                }
+            }
+            else if (sendRet < 0 && sendRet !== AVERROR_EOF) {
+                FFmpegError.throwIfError(sendRet, 'Failed to send packet to bitstream filter');
+            }
+            // Receive ALL available packets immediately
+            while (true) {
+                const outPacket = this.receiveSync();
+                if (!outPacket)
+                    break; // EAGAIN or EOF
+                yield outPacket;
             }
         }
-        catch (error) {
-            // Ensure cleanup on error
-            this.ctx.flush();
-            throw error;
+        // Flush filter after all packets (fallback if no null was sent)
+        this.flushSync();
+        while (true) {
+            const remaining = this.receiveSync();
+            if (!remaining)
+                break;
+            yield remaining;
         }
+        // Signal EOF
+        yield null;
     }
     /**
-     * Flush filter and get remaining packets.
+     * Flush filter and signal end-of-stream.
      *
-     * Signals end-of-stream and retrieves buffered packets.
-     * Also resets internal filter state.
+     * Sends null packet to filter to signal end-of-stream.
+     * Does nothing if filter is closed.
+     * Must call receive() or flushPackets() to get remaining buffered packets.
      *
-     * Direct mapping to av_bsf_flush().
+     * Direct mapping to av_bsf_send_packet(NULL) and av_bsf_flush().
      *
-     * @returns Array of remaining packets or null if filter is closed
+     * @throws {FFmpegError} If flush fails
      *
      * @example
      * ```typescript
-     * const remaining = await filter.flush();
-     * if (remaining) {
-     *   for (const packet of remaining) {
-     *     await output.writePacket(packet);
-     *     packet.free();
-     *   }
+     * // Signal end of stream
+     * await filter.flush();
+     *
+     * // Then get remaining packets
+     * let packet;
+     * while ((packet = await filter.receive()) !== null) {
+     *   console.log('Got buffered packet');
+     *   await output.writePacket(packet);
+     *   packet.free();
      * }
      * ```
      *
      * @see {@link flushPackets} For async iteration
+     * @see {@link receive} For getting buffered packets
      * @see {@link reset} For state reset only
+     * @see {@link flushSync} For synchronous version
      */
     async flush() {
         if (this.isClosed) {
-            return [];
+            return;
         }
         // Send EOF
-        const filtered = await this.process(null);
+        const sendRet = await this.ctx.sendPacket(null);
+        if (sendRet < 0 && sendRet !== AVERROR_EOF && sendRet !== AVERROR_EAGAIN) {
+            FFmpegError.throwIfError(sendRet, 'Failed to flush bitstream filter');
+        }
         // Also flush the context to reset internal state
         this.ctx.flush();
-        return filtered;
     }
     /**
-     * Flush filter and get remaining packets synchronously.
+     * Flush filter and signal end-of-stream synchronously.
      * Synchronous version of flush.
      *
-     * Signals end-of-stream and retrieves buffered packets.
-     * Also resets internal filter state.
+     * Sends null packet to filter to signal end-of-stream.
+     * Does nothing if filter is closed.
+     * Must call receiveSync() or flushPacketsSync() to get remaining buffered packets.
      *
-     * Direct mapping to av_bsf_flush().
+     * Direct mapping to av_bsf_send_packet(NULL) and av_bsf_flush().
      *
-     * @returns Array of remaining packets or null if filter is closed
+     * @throws {FFmpegError} If flush fails
      *
      * @example
      * ```typescript
-     * const remaining = filter.flushSync();
-     * if (remaining) {
-     *   for (const packet of remaining) {
-     *     output.writePacketSync(packet);
-     *     packet.free();
-     *   }
+     * // Signal end of stream
+     * filter.flushSync();
+     *
+     * // Then get remaining packets
+     * let packet;
+     * while ((packet = filter.receiveSync()) !== null) {
+     *   console.log('Got buffered packet');
+     *   output.writePacketSync(packet);
+     *   packet.free();
      * }
      * ```
      *
+     * @see {@link flushPacketsSync} For sync iteration
+     * @see {@link receiveSync} For getting buffered packets
+     * @see {@link reset} For state reset only
      * @see {@link flush} For async version
      */
     flushSync() {
         if (this.isClosed) {
-            return [];
+            return;
         }
         // Send EOF
-        const filtered = this.processSync(null);
+        const sendRet = this.ctx.sendPacketSync(null);
+        if (sendRet < 0 && sendRet !== AVERROR_EOF && sendRet !== AVERROR_EAGAIN) {
+            FFmpegError.throwIfError(sendRet, 'Failed to flush bitstream filter');
+        }
         // Also flush the context to reset internal state
         this.ctx.flush();
-        return filtered;
     }
     /**
-     * Flush filter as async generator.
+     * Receive packet from filter.
+     *
+     * Gets filtered packets from the filter's internal buffer.
+     * Handles packet allocation and error checking.
+     * Returns null if filter is closed or no packets available.
+     * Call repeatedly until null to drain all buffered packets.
+     *
+     * Direct mapping to av_bsf_receive_packet().
+     *
+     * @returns Cloned packet or null if no packets available
+     *
+     * @throws {FFmpegError} If receive fails with error other than AVERROR_EAGAIN or AVERROR_EOF
+     *
+     * @example
+     * ```typescript
+     * const packet = await filter.receive();
+     * if (packet) {
+     *   console.log('Got filtered packet');
+     *   await output.writePacket(packet);
+     *   packet.free();
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Drain all buffered packets
+     * let packet;
+     * while ((packet = await filter.receive()) !== null) {
+     *   console.log(`Packet PTS: ${packet.pts}`);
+     *   await output.writePacket(packet);
+     *   packet.free();
+     * }
+     * ```
+     *
+     * @see {@link filter} For filtering packets
+     * @see {@link flush} For signaling end-of-stream
+     * @see {@link receiveSync} For synchronous version
+     */
+    async receive() {
+        if (this.isClosed) {
+            return null;
+        }
+        // Clear previous packet data
+        this.packet.unref();
+        const recvRet = await this.ctx.receivePacket(this.packet);
+        if (recvRet === 0) {
+            // Got a packet, clone it for the user
+            return this.packet.clone();
+        }
+        else if (recvRet === AVERROR_EAGAIN || recvRet === AVERROR_EOF) {
+            // Need more data or end of stream
+            return null;
+        }
+        else {
+            // Error
+            FFmpegError.throwIfError(recvRet, 'Failed to receive packet from bitstream filter');
+            return null;
+        }
+    }
+    /**
+     * Receive packet from filter synchronously.
+     * Synchronous version of receive.
+     *
+     * Gets filtered packets from the filter's internal buffer.
+     * Handles packet allocation and error checking.
+     * Returns null if filter is closed or no packets available.
+     * Call repeatedly until null to drain all buffered packets.
+     *
+     * Direct mapping to av_bsf_receive_packet().
+     *
+     * @returns Cloned packet or null if no packets available
+     *
+     * @throws {FFmpegError} If receive fails with error other than AVERROR_EAGAIN or AVERROR_EOF
+     *
+     * @example
+     * ```typescript
+     * const packet = filter.receiveSync();
+     * if (packet) {
+     *   console.log('Got filtered packet');
+     *   output.writePacketSync(packet);
+     *   packet.free();
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Drain all buffered packets
+     * let packet;
+     * while ((packet = filter.receiveSync()) !== null) {
+     *   console.log(`Packet PTS: ${packet.pts}`);
+     *   output.writePacketSync(packet);
+     *   packet.free();
+     * }
+     * ```
+     *
+     * @see {@link filterSync} For filtering packets
+     * @see {@link flushSync} For signaling end-of-stream
+     * @see {@link receive} For async version
+     */
+    receiveSync() {
+        if (this.isClosed) {
+            return null;
+        }
+        // Clear previous packet data
+        this.packet.unref();
+        const recvRet = this.ctx.receivePacketSync(this.packet);
+        if (recvRet === 0) {
+            // Got a packet, clone it for the user
+            return this.packet.clone();
+        }
+        else if (recvRet === AVERROR_EAGAIN || recvRet === AVERROR_EOF) {
+            // Need more data or end of stream
+            return null;
+        }
+        else {
+            // Error
+            FFmpegError.throwIfError(recvRet, 'Failed to receive packet from bitstream filter');
+            return null;
+        }
+    }
+    /**
+     * Flush all buffered packets as async generator.
      *
      * Convenient async iteration over remaining packets.
-     * Combines flush and iteration.
+     * Automatically sends flush signal and retrieves buffered packets.
+     * Useful for end-of-stream processing.
      *
-     * @yields {Packet} Remaining packets
+     * @yields {Packet} Buffered packets
      *
      * @example
      * ```typescript
+     * // Flush at end of filtering
      * for await (const packet of filter.flushPackets()) {
+     *   console.log('Processing buffered packet');
      *   await output.writePacket(packet);
      *   packet.free();
      * }
      * ```
      *
-     * @see {@link flush} For array return
+     * @see {@link filter} For filtering packets
+     * @see {@link flush} For signaling end-of-stream
+     * @see {@link flushPacketsSync} For synchronous version
      */
     async *flushPackets() {
-        const remaining = await this.flush();
-        if (remaining) {
-            for (const packet of remaining) {
-                yield packet;
-            }
+        while (true) {
+            const packet = await this.receive();
+            if (!packet)
+                break;
+            yield packet;
         }
     }
     /**
-     * Flush filter as generator synchronously.
+     * Flush all buffered packets as generator synchronously.
      * Synchronous version of flushPackets.
      *
      * Convenient sync iteration over remaining packets.
-     * Combines flush and iteration.
+     * Automatically retrieves buffered packets after flush.
+     * Useful for end-of-stream processing.
      *
-     * @yields {Packet} Remaining packets
+     * @yields {Packet} Buffered packets
      *
      * @example
      * ```typescript
+     * // Flush at end of filtering
      * for (const packet of filter.flushPacketsSync()) {
+     *   console.log('Processing buffered packet');
      *   output.writePacketSync(packet);
      *   packet.free();
      * }
      * ```
      *
+     * @see {@link filterSync} For filtering packets
+     * @see {@link flushSync} For signaling end-of-stream
      * @see {@link flushPackets} For async version
      */
     *flushPacketsSync() {
-        const remaining = this.flushSync();
-        if (remaining) {
-            for (const packet of remaining) {
-                yield packet;
-            }
+        while (true) {
+            const packet = this.receiveSync();
+            if (!packet)
+                break;
+            yield packet;
         }
     }
     /**
@@ -605,6 +978,10 @@ export class BitStreamFilterAPI {
             return;
         }
         this.isClosed = true;
+        // Close queues
+        this.inputQueue.close();
+        this.outputQueue.close();
+        this.packet.free();
         this.ctx.free();
     }
     /**
@@ -626,5 +1003,161 @@ export class BitStreamFilterAPI {
     [Symbol.dispose]() {
         this.close();
     }
+    /**
+     * Send packet to input queue or flush the pipeline.
+     *
+     * When packet is provided, queues it for filtering.
+     * When null is provided, triggers flush sequence:
+     * - Closes input queue
+     * - Waits for worker completion
+     * - Closes output queue (no buffering, bitstream filters are stateless)
+     * - Waits for pipeTo task completion
+     * - Propagates flush to next component (if any)
+     *
+     * Used by scheduler system for pipeline control.
+     *
+     * @param packet - Packet to send, or null to flush
+     *
+     * @internal
+     */
+    async sendToQueue(packet) {
+        if (packet) {
+            await this.inputQueue.send(packet);
+        }
+        else {
+            // Close input queue to signal end of stream to worker
+            this.inputQueue.close();
+            // Wait for worker to finish processing all packets
+            if (this.workerPromise) {
+                await this.workerPromise;
+            }
+            // Close output queue to signal end of stream to pipeTo() task
+            this.outputQueue.close();
+            // Wait for pipeTo() task to finish processing all packets (if exists)
+            if (this.pipeToPromise) {
+                await this.pipeToPromise;
+            }
+            // Then propagate flush to next component
+            if (this.nextComponent) {
+                await this.nextComponent.sendToQueue(null);
+            }
+        }
+    }
+    /**
+     * Receive packet from output queue.
+     *
+     * @returns Packet from queue or null if closed
+     *
+     * @internal
+     */
+    async receiveFromQueue() {
+        return await this.outputQueue.receive();
+    }
+    /**
+     * Worker loop for push-based processing.
+     *
+     * @internal
+     */
+    async runWorker() {
+        try {
+            // Outer loop - receive packets
+            while (!this.inputQueue.isClosed) {
+                const env_1 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const packet = __addDisposableResource(env_1, await this.inputQueue.receive(), false);
+                    if (!packet)
+                        break;
+                    if (this.isClosed) {
+                        break;
+                    }
+                    // Send packet to filter
+                    const sendRet = await this.ctx.sendPacket(packet);
+                    // Handle EAGAIN
+                    if (sendRet === AVERROR_EAGAIN) {
+                        // Filter buffer full, receive packets first
+                        while (!this.outputQueue.isClosed) {
+                            const outPacket = await this.receive();
+                            if (!outPacket)
+                                break;
+                            await this.outputQueue.send(outPacket);
+                        }
+                        // Retry sending
+                        const retryRet = await this.ctx.sendPacket(packet);
+                        if (retryRet < 0 && retryRet !== AVERROR_EOF && retryRet !== AVERROR_EAGAIN) {
+                            FFmpegError.throwIfError(retryRet, 'Failed to send packet to bitstream filter');
+                        }
+                    }
+                    else if (sendRet < 0 && sendRet !== AVERROR_EOF) {
+                        FFmpegError.throwIfError(sendRet, 'Failed to send packet to bitstream filter');
+                    }
+                    // Receive ALL available packets immediately
+                    while (!this.outputQueue.isClosed) {
+                        const outPacket = await this.receive();
+                        if (!outPacket)
+                            break;
+                        await this.outputQueue.send(outPacket);
+                    }
+                }
+                catch (e_1) {
+                    env_1.error = e_1;
+                    env_1.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_1);
+                }
+            }
+            // Flush filter at end
+            await this.flush();
+            while (!this.outputQueue.isClosed) {
+                const outPacket = await this.receive();
+                if (!outPacket)
+                    break;
+                await this.outputQueue.send(outPacket);
+            }
+        }
+        catch {
+            // Ignore error
+        }
+        finally {
+            // Close output queue when done
+            this.outputQueue?.close();
+        }
+    }
+    pipeTo(target, streamIndex) {
+        if (target instanceof Muxer) {
+            // Start worker if not already running
+            this.workerPromise ??= this.runWorker();
+            // Start pipe task: filter.outputQueue -> output
+            this.pipeToPromise = (async () => {
+                while (true) {
+                    const packet = await this.receiveFromQueue();
+                    if (!packet)
+                        break;
+                    await target.writePacket(packet, streamIndex);
+                }
+            })();
+            // Return control without pipeTo (terminal stage)
+            return new SchedulerControl(this);
+        }
+        else {
+            // BitStreamFilterAPI
+            const t = target;
+            // Store reference to next component for flush propagation
+            this.nextComponent = t;
+            // Start worker if not already running
+            this.workerPromise ??= this.runWorker();
+            // Start pipe task: filter.outputQueue -> target.inputQueue (via target.send)
+            this.pipeToPromise = (async () => {
+                while (true) {
+                    const packet = await this.receiveFromQueue();
+                    if (!packet)
+                        break;
+                    await t.sendToQueue(packet);
+                }
+            })();
+            // Return scheduler for chaining (target is now the last component)
+            return new Scheduler(this, t);
+        }
+    }
 }
 //# sourceMappingURL=bitstream-filter.js.map