node-av 0.0.1

package/dist/api/pipeline.js

@@ -0,0 +1,836 @@
+/**
+ * Pipeline - Stream-based media processing pipeline
+ *
+ * Provides a Node.js-style pipeline function for chaining media processing components.
+ * Automatically handles type conversions, buffering, and flushing.
+ *
+ * Supports two modes:
+ * 1. Simple: Single stream with variable parameters
+ * 2. Named: Multiple streams with named routing with variable parameters
+ *
+ * @module api/pipeline
+ */
+// ============================================================================
+// Implementation
+// ============================================================================
+/**
+ * Pipeline implementation
+ *
+ * Creates a processing pipeline from media components.
+ * Automatically handles type conversions and proper flushing order.
+ *
+ * @param args - Variable arguments depending on pipeline type
+ * @returns Promise<void> if output is present, AsyncGenerator otherwise
+ *
+ * @example
+ * ```typescript
+ * // Simple pipeline
+ * await pipeline(
+ *   input,
+ *   decoder,
+ *   filter,
+ *   encoder,
+ *   output
+ * );
+ *
+ * // Named pipeline for muxing
+ * await pipeline(
+ *   { video: videoInput, audio: audioInput },
+ *   {
+ *     video: [videoDecoder, scaleFilter, videoEncoder],
+ *     audio: [audioDecoder, volumeFilter, audioEncoder]
+ *   },
+ *   output
+ * );
+ * ```
+ */
+export function pipeline(...args) {
+    // Detect pipeline type based on first argument
+    const firstArg = args[0];
+    if (isNamedInputs(firstArg)) {
+        // Named pipeline (2 or 3 arguments)
+        if (args.length === 2) {
+            // Partial named pipeline - return generators
+            return runNamedPartialPipeline(args[0], args[1]);
+        }
+        else {
+            // Full named pipeline with output
+            return runNamedPipeline(args[0], args[1], args[2]);
+        }
+    }
+    else if (isMediaInput(firstArg)) {
+        // Check if this is a stream copy (MediaInput → MediaOutput)
+        if (args.length === 2 && isMediaOutput(args[1])) {
+            // Stream copy all streams
+            return runMediaInputPipeline(args[0], args[1]);
+        }
+        else {
+            // Simple pipeline starting with MediaInput
+            return runSimplePipeline(args);
+        }
+    }
+    else {
+        // Simple pipeline (variable arguments)
+        return runSimplePipeline(args);
+    }
+}
+// ============================================================================
+// PipelineControl Implementation
+// ============================================================================
+class PipelineControlImpl {
+    _stopped = false;
+    _completion;
+    constructor(executionPromise) {
+        // Don't resolve immediately on stop, wait for the actual pipeline to finish
+        this._completion = executionPromise;
+    }
+    stop() {
+        this._stopped = true;
+    }
+    isStopped() {
+        return this._stopped;
+    }
+    get completion() {
+        return this._completion;
+    }
+}
+// ============================================================================
+// MediaInput Pipeline Implementation
+// ============================================================================
+function runMediaInputPipeline(input, output) {
+    let control;
+    // eslint-disable-next-line prefer-const
+    control = new PipelineControlImpl(runMediaInputPipelineAsync(input, output, () => control.isStopped()));
+    return control;
+}
+async function runMediaInputPipelineAsync(input, output, shouldStop) {
+    // Get all streams from input
+    const videoStream = input.video();
+    const audioStream = input.audio();
+    const streams = [];
+    // Add video stream if present
+    if (videoStream) {
+        const outputIndex = output.addStream(videoStream);
+        streams.push({ stream: videoStream, index: outputIndex });
+    }
+    // Add audio stream if present
+    if (audioStream) {
+        const outputIndex = output.addStream(audioStream);
+        streams.push({ stream: audioStream, index: outputIndex });
+    }
+    // Add any other streams
+    const allStreams = input.streams;
+    for (const stream of allStreams) {
+        // Skip if already added
+        if (stream !== videoStream && stream !== audioStream) {
+            const outputIndex = output.addStream(stream);
+            streams.push({ stream, index: outputIndex });
+        }
+    }
+    // Write header
+    if (!output.isHeaderWritten()) {
+        await output.writeHeader();
+    }
+    // Copy all packets
+    for await (const packet of input.packets()) {
+        // Check if we should stop
+        if (shouldStop()) {
+            packet.free();
+            break;
+        }
+        // Find the corresponding output stream index
+        const mapping = streams.find((s) => s.stream.index === packet.streamIndex);
+        if (mapping) {
+            await output.writePacket(packet, mapping.index);
+        }
+        packet.free(); // Free packet after processing
+    }
+    // Write trailer
+    if (!output.isTrailerWritten()) {
+        await output.writeTrailer();
+    }
+}
+// ============================================================================
+// Simple Pipeline Implementation
+// ============================================================================
+function runSimplePipeline(args) {
+    const [source, ...stages] = args;
+    // Check if last stage is MediaOutput (consumes stream)
+    const lastStage = stages[stages.length - 1];
+    const isOutput = isMediaOutput(lastStage);
+    // Track metadata through pipeline
+    const metadata = {};
+    // Store MediaInput reference if we have one
+    if (isMediaInput(source)) {
+        metadata.mediaInput = source;
+    }
+    // Build the pipeline generator
+    // If output is present, exclude it from stages for processing
+    const processStages = isOutput ? stages.slice(0, -1) : stages;
+    // Process metadata first by walking through stages
+    for (const stage of processStages) {
+        if (isDecoder(stage)) {
+            metadata.decoder = stage;
+        }
+        else if (isEncoder(stage)) {
+            metadata.encoder = stage;
+        }
+        else if (isBitStreamFilterAPI(stage)) {
+            metadata.bitStreamFilter = stage;
+        }
+    }
+    // Convert MediaInput to packet stream if needed
+    // If we have a decoder or BSF, filter packets by stream index
+    let actualSource;
+    if (isMediaInput(source)) {
+        if (metadata.decoder) {
+            // Filter packets for the decoder's stream
+            const streamIndex = metadata.decoder.getStream().index;
+            actualSource = source.packets(streamIndex);
+        }
+        else if (metadata.bitStreamFilter) {
+            // Filter packets for the BSF's stream
+            const streamIndex = metadata.bitStreamFilter.getStream().index;
+            actualSource = source.packets(streamIndex);
+        }
+        else {
+            // No decoder or BSF, pass all packets
+            actualSource = source.packets();
+        }
+    }
+    else {
+        actualSource = source;
+    }
+    const generator = buildSimplePipeline(actualSource, processStages);
+    // If output, consume the generator
+    if (isOutput) {
+        let control;
+        // eslint-disable-next-line prefer-const
+        control = new PipelineControlImpl(consumeSimplePipeline(generator, lastStage, metadata, () => control.isStopped()));
+        return control;
+    }
+    // Otherwise return the generator for further processing
+    return generator;
+}
+async function* buildSimplePipeline(source, stages) {
+    let stream = source;
+    for (const stage of stages) {
+        if (isDecoder(stage)) {
+            stream = decodeStream(stream, stage);
+        }
+        else if (isEncoder(stage)) {
+            stream = encodeStream(stream, stage);
+        }
+        else if (isFilterAPI(stage)) {
+            stream = filterStream(stream, stage);
+        }
+        else if (isBitStreamFilterAPI(stage)) {
+            stream = bitStreamFilterStream(stream, stage);
+        }
+        else if (Array.isArray(stage)) {
+            // Chain multiple filters or BSFs
+            for (const filter of stage) {
+                if (isFilterAPI(filter)) {
+                    stream = filterStream(stream, filter);
+                }
+                else if (isBitStreamFilterAPI(filter)) {
+                    stream = bitStreamFilterStream(stream, filter);
+                }
+            }
+        }
+    }
+    yield* stream;
+}
+async function consumeSimplePipeline(stream, output, metadata, shouldStop) {
+    // Add stream to output if we have encoder or decoder info
+    let streamIndex = 0;
+    if (metadata.encoder) {
+        streamIndex = output.addStream(metadata.encoder);
+    }
+    else if (metadata.decoder) {
+        // Stream copy - use decoder's original stream
+        const originalStream = metadata.decoder.getStream();
+        streamIndex = output.addStream(originalStream);
+    }
+    else if (metadata.bitStreamFilter) {
+        // BSF without encoder/decoder - use BSF's original stream
+        const originalStream = metadata.bitStreamFilter.getStream();
+        streamIndex = output.addStream(originalStream);
+    }
+    else {
+        // For direct MediaInput → MediaOutput, we redirect to runMediaInputPipeline
+        // This case shouldn't happen in simple pipeline
+        throw new Error('Cannot determine stream configuration. This is likely a bug in the pipeline.');
+    }
+    // Write header if needed
+    if (!output.isHeaderWritten()) {
+        await output.writeHeader();
+    }
+    // Process stream
+    for await (const item of stream) {
+        // Check if we should stop
+        if (shouldStop()) {
+            if (isPacket(item)) {
+                item.free();
+            }
+            else {
+                item.free();
+            }
+            break;
+        }
+        if (isPacket(item)) {
+            await output.writePacket(item, streamIndex);
+            // Free the packet after writing
+            item.free();
+        }
+        else {
+            throw new Error('Cannot write frames directly to MediaOutput. Use an encoder first.');
+        }
+    }
+    // Write trailer if needed
+    if (!output.isTrailerWritten()) {
+        await output.writeTrailer();
+    }
+}
+// ============================================================================
+// Named Pipeline Implementation
+// ============================================================================
+function runNamedPartialPipeline(inputs, stages) {
+    const result = {};
+    for (const [streamName, streamStages] of Object.entries(stages)) {
+        const input = inputs[streamName];
+        if (!input) {
+            throw new Error(`No input found for stream: ${streamName}`);
+        }
+        // Get the appropriate stream based on the stream name
+        let stream = null;
+        switch (streamName) {
+            case 'video':
+                stream = input.video() ?? null;
+                break;
+            case 'audio':
+                stream = input.audio() ?? null;
+                break;
+            default:
+                // This should never happen
+                throw new Error(`Invalid stream name: ${streamName}. Must be 'video' or 'audio'.`);
+        }
+        if (!stream) {
+            throw new Error(`No ${streamName} stream found in input.`);
+        }
+        if (streamStages === 'passthrough') {
+            // Direct passthrough - return input packets for this specific stream
+            result[streamName] = (async function* () {
+                for await (const packet of input.packets(stream.index)) {
+                    yield packet;
+                }
+            })();
+        }
+        else {
+            // Process the stream - pass packets for this specific stream only
+            // Build pipeline for this stream (can return frames or packets)
+            const metadata = {};
+            result[streamName] = buildFlexibleNamedStreamPipeline(input.packets(stream.index), streamStages, metadata);
+        }
+    }
+    return result;
+}
+function runNamedPipeline(inputs, stages, output) {
+    let control;
+    // eslint-disable-next-line prefer-const
+    control = new PipelineControlImpl(runNamedPipelineAsync(inputs, stages, output, () => control.isStopped()));
+    return control;
+}
+async function runNamedPipelineAsync(inputs, stages, output, shouldStop) {
+    // Track metadata for each stream
+    const streamMetadata = {};
+    // Process each named stream into generators
+    const processedStreams = {};
+    for (const [streamName, streamStages] of Object.entries(stages)) {
+        const metadata = {};
+        streamMetadata[streamName] = metadata;
+        const input = inputs[streamName];
+        if (!input) {
+            throw new Error(`No input found for stream: ${streamName}`);
+        }
+        if (streamStages === 'passthrough') {
+            // Direct passthrough - no processing
+            let stream = null;
+            switch (streamName) {
+                case 'video':
+                    stream = input.video() ?? null;
+                    metadata.type = 'video';
+                    break;
+                case 'audio':
+                    stream = input.audio() ?? null;
+                    metadata.type = 'audio';
+                    break;
+            }
+            if (!stream) {
+                throw new Error(`No ${streamName} stream found in input for passthrough.`);
+            }
+            processedStreams[streamName] = input.packets(stream.index);
+            metadata.mediaInput = input; // Track MediaInput for passthrough
+        }
+        else {
+            // Process the stream
+            // Pre-populate metadata by walking through stages
+            for (const stage of streamStages) {
+                if (isDecoder(stage)) {
+                    metadata.decoder = stage;
+                }
+                else if (isEncoder(stage)) {
+                    metadata.encoder = stage;
+                }
+                else if (isBitStreamFilterAPI(stage)) {
+                    metadata.bitStreamFilter = stage;
+                }
+            }
+            // Get packets - filter by stream index based on decoder, BSF, or stream type
+            let packets;
+            if (metadata.decoder) {
+                const streamIndex = metadata.decoder.getStream().index;
+                packets = input.packets(streamIndex);
+            }
+            else if (metadata.bitStreamFilter) {
+                const streamIndex = metadata.bitStreamFilter.getStream().index;
+                packets = input.packets(streamIndex);
+            }
+            else {
+                // No decoder or BSF - determine stream by name
+                let stream = null;
+                switch (streamName) {
+                    case 'video':
+                        stream = input.video() ?? null;
+                        break;
+                    case 'audio':
+                        stream = input.audio() ?? null;
+                        break;
+                }
+                if (!stream) {
+                    throw new Error(`No ${streamName} stream found in input.`);
+                }
+                packets = input.packets(stream.index);
+            }
+            // Build pipeline for this stream
+            processedStreams[streamName] = buildNamedStreamPipeline(packets, streamStages, metadata);
+        }
+    }
+    // Write to output(s)
+    if (isMediaOutput(output)) {
+        // Single output - properly interleave all streams
+        await interleaveToOutput(processedStreams, output, streamMetadata, shouldStop);
+    }
+    else {
+        // Multiple outputs - write each stream to its output
+        const outputs = output;
+        const promises = [];
+        for (const [streamName, stream] of Object.entries(processedStreams)) {
+            const streamOutput = outputs[streamName];
+            if (streamOutput) {
+                const metadata = streamMetadata[streamName];
+                promises.push(consumeNamedStream(stream, streamOutput, metadata, shouldStop));
+            }
+        }
+        await Promise.all(promises);
+    }
+}
+async function* buildFlexibleNamedStreamPipeline(source, stages, metadata) {
+    let stream = source;
+    for (const stage of stages) {
+        if (isDecoder(stage)) {
+            metadata.decoder = stage;
+            stream = decodeStream(stream, stage);
+        }
+        else if (isEncoder(stage)) {
+            metadata.encoder = stage;
+            stream = encodeStream(stream, stage);
+        }
+        else if (isFilterAPI(stage)) {
+            stream = filterStream(stream, stage);
+        }
+        else if (isBitStreamFilterAPI(stage)) {
+            metadata.bitStreamFilter = stage;
+            stream = bitStreamFilterStream(stream, stage);
+        }
+        else if (Array.isArray(stage)) {
+            // Chain multiple filters or BSFs
+            for (const filter of stage) {
+                if (isFilterAPI(filter)) {
+                    stream = filterStream(stream, filter);
+                }
+                else if (isBitStreamFilterAPI(filter)) {
+                    stream = bitStreamFilterStream(stream, filter);
+                }
+            }
+        }
+    }
+    // Yield whatever the pipeline produces (frames or packets)
+    yield* stream;
+}
+async function* buildNamedStreamPipeline(source, stages, metadata) {
+    let stream = source;
+    for (const stage of stages) {
+        if (isDecoder(stage)) {
+            metadata.decoder = stage;
+            stream = decodeStream(stream, stage);
+        }
+        else if (isEncoder(stage)) {
+            metadata.encoder = stage;
+            stream = encodeStream(stream, stage);
+        }
+        else if (isFilterAPI(stage)) {
+            stream = filterStream(stream, stage);
+        }
+        else if (isBitStreamFilterAPI(stage)) {
+            metadata.bitStreamFilter = stage;
+            stream = bitStreamFilterStream(stream, stage);
+        }
+        else if (Array.isArray(stage)) {
+            // Chain multiple filters or BSFs
+            for (const filter of stage) {
+                if (isFilterAPI(filter)) {
+                    stream = filterStream(stream, filter);
+                }
+                else if (isBitStreamFilterAPI(filter)) {
+                    stream = bitStreamFilterStream(stream, filter);
+                }
+            }
+        }
+    }
+    // Ensure we're yielding packets
+    for await (const item of stream) {
+        if (isPacket(item)) {
+            yield item;
+        }
+        else {
+            throw new Error('Named pipeline must end with packets (use encoder after filters)');
+        }
+    }
+}
+async function consumeNamedStream(stream, output, metadata, shouldStop) {
+    // Add stream to output
+    let streamIndex = 0;
+    if (metadata.encoder) {
+        streamIndex = output.addStream(metadata.encoder);
+    }
+    else if (metadata.decoder) {
+        // Stream copy - use decoder's original stream
+        const originalStream = metadata.decoder.getStream();
+        streamIndex = output.addStream(originalStream);
+    }
+    else if (metadata.bitStreamFilter) {
+        // BSF - use BSF's original stream
+        const originalStream = metadata.bitStreamFilter.getStream();
+        streamIndex = output.addStream(originalStream);
+    }
+    else if (metadata.mediaInput) {
+        // Passthrough from MediaInput - use type hint from metadata
+        const inputStream = metadata.type === 'video' ? metadata.mediaInput.video() : metadata.mediaInput.audio();
+        if (!inputStream) {
+            throw new Error(`No ${metadata.type} stream found in MediaInput`);
+        }
+        streamIndex = output.addStream(inputStream);
+    }
+    else {
+        // This should not happen with the new API
+        throw new Error('Cannot determine stream configuration. This is likely a bug in the pipeline.');
+    }
+    // Store for later use
+    metadata.streamIndex = streamIndex;
+    // Write header if needed
+    if (!output.isHeaderWritten()) {
+        await output.writeHeader();
+    }
+    // Write all packets
+    for await (const packet of stream) {
+        // Check if we should stop
+        if (shouldStop()) {
+            packet.free();
+            break;
+        }
+        try {
+            await output.writePacket(packet, streamIndex);
+        }
+        finally {
+            packet.free(); // Free packet after writing
+        }
+    }
+    // Note: Trailer will be written by interleaveToOutput
+}
+async function interleaveToOutput(streams, output, metadata, shouldStop) {
+    // Add all streams to output first
+    const streamIndices = {};
+    for (const [name, meta] of Object.entries(metadata)) {
+        if (meta.encoder) {
+            streamIndices[name] = output.addStream(meta.encoder);
+        }
+        else if (meta.decoder) {
+            // Stream copy - use decoder's original stream
+            const originalStream = meta.decoder.getStream();
+            streamIndices[name] = output.addStream(originalStream);
+        }
+        else if (meta.bitStreamFilter) {
+            // BSF - use BSF's original stream
+            const originalStream = meta.bitStreamFilter.getStream();
+            streamIndices[name] = output.addStream(originalStream);
+        }
+        else if (meta.mediaInput) {
+            // Passthrough from MediaInput - use stream name to determine which stream
+            const stream = name.includes('video') ? meta.mediaInput.video() : meta.mediaInput.audio();
+            if (!stream) {
+                throw new Error(`No matching stream found in MediaInput for ${name}`);
+            }
+            streamIndices[name] = output.addStream(stream);
+        }
+        else {
+            // This should not happen
+            throw new Error(`Cannot determine stream configuration for ${name}. This is likely a bug in the pipeline.`);
+        }
+    }
+    // Write header
+    if (!output.isHeaderWritten()) {
+        await output.writeHeader();
+    }
+    const queues = new Map();
+    const iterators = new Map();
+    const done = new Set();
+    // Initialize iterators
+    for (const [name, stream] of Object.entries(streams)) {
+        queues.set(name, []);
+        iterators.set(name, stream[Symbol.asyncIterator]());
+    }
+    // Read initial packet from each stream
+    for (const [name, iterator] of iterators) {
+        const result = await iterator.next();
+        if (!result.done && result.value) {
+            const packet = result.value;
+            packet._streamName = name;
+            queues.get(name).push(packet);
+        }
+        else {
+            done.add(name);
+        }
+    }
+    // Interleave packets based on DTS/PTS
+    while (done.size < Object.keys(streams).length && !shouldStop()) {
+        // Find packet with smallest DTS/PTS
+        let minPacket = null;
+        let minStreamName = null;
+        let minTime = BigInt(Number.MAX_SAFE_INTEGER);
+        for (const [name, queue] of queues) {
+            if (queue.length > 0) {
+                const packet = queue[0];
+                const time = packet.dts ?? packet.pts ?? BigInt(0);
+                if (time < minTime) {
+                    minTime = time;
+                    minPacket = packet;
+                    minStreamName = name;
+                }
+            }
+        }
+        if (!minPacket || !minStreamName) {
+            // All queues empty, read more
+            for (const [name, iterator] of iterators) {
+                if (!done.has(name)) {
+                    const result = await iterator.next();
+                    if (!result.done && result.value) {
+                        const packet = result.value;
+                        packet._streamName = name;
+                        queues.get(name).push(packet);
+                    }
+                    else {
+                        done.add(name);
+                    }
+                }
+            }
+            continue;
+        }
+        // Write the packet with smallest timestamp
+        const streamIndex = streamIndices[minStreamName];
+        await output.writePacket(minPacket, streamIndex);
+        // Free the packet after writing
+        minPacket.free();
+        // Remove from queue
+        queues.get(minStreamName).shift();
+        // Read next packet from that stream
+        const iterator = iterators.get(minStreamName);
+        const result = await iterator.next();
+        if (!result.done && result.value) {
+            const packet = result.value;
+            packet._streamName = minStreamName;
+            queues.get(minStreamName).push(packet);
+        }
+        else {
+            done.add(minStreamName);
+        }
+    }
+    // If stopped, free all remaining packets in queues
+    if (shouldStop()) {
+        for (const [, queue] of queues) {
+            for (const packet of queue) {
+                packet.free();
+            }
+        }
+    }
+    else {
+        // Write any remaining packets
+        for (const [name, queue] of queues) {
+            const streamIndex = streamIndices[name];
+            for (const packet of queue) {
+                await output.writePacket(packet, streamIndex);
+                packet.free(); // Free packet after writing
+            }
+        }
+    }
+    // Write trailer
+    if (!output.isTrailerWritten()) {
+        await output.writeTrailer();
+    }
+}
+// ============================================================================
+// Stream Processing Functions
+// ============================================================================
+async function* decodeStream(packets, decoder) {
+    // Process all packets
+    for await (const packet of packets) {
+        try {
+            const frame = await decoder.decode(packet);
+            if (frame) {
+                yield frame;
+            }
+        }
+        finally {
+            // Free packet after decoding
+            packet.free();
+        }
+    }
+    // Flush decoder
+    if ('flushFrames' in decoder && typeof decoder.flushFrames === 'function') {
+        // Use generator method if available
+        for await (const frame of decoder.flushFrames()) {
+            yield frame;
+        }
+    }
+    else {
+        // Fallback to loop
+        let frame;
+        while ((frame = await decoder.flush()) !== null) {
+            yield frame;
+        }
+    }
+}
+async function* encodeStream(frames, encoder) {
+    // Process all frames
+    for await (const frame of frames) {
+        try {
+            const packet = await encoder.encode(frame);
+            if (packet) {
+                yield packet;
+            }
+        }
+        finally {
+            // Free the input frame after encoding
+            frame.free();
+        }
+    }
+    // Flush encoder
+    if ('flushPackets' in encoder && typeof encoder.flushPackets === 'function') {
+        // Use generator method if available
+        for await (const packet of encoder.flushPackets()) {
+            yield packet;
+        }
+    }
+    else {
+        // Fallback to loop
+        let packet;
+        while ((packet = await encoder.flush()) !== null) {
+            yield packet;
+        }
+    }
+}
+async function* filterStream(frames, filter) {
+    // Process all frames
+    for await (const frame of frames) {
+        try {
+            const filtered = await filter.process(frame);
+            if (filtered) {
+                yield filtered;
+            }
+            // Check for buffered frames
+            let buffered;
+            while ((buffered = await filter.receive()) !== null) {
+                yield buffered;
+            }
+        }
+        finally {
+            // Free the input frame after filtering
+            frame.free();
+        }
+    }
+    // Flush filter
+    if ('flushFrames' in filter && typeof filter.flushFrames === 'function') {
+        // Use generator method if available
+        for await (const frame of filter.flushFrames()) {
+            yield frame;
+        }
+    }
+    else {
+        // Fallback to manual flush + receive
+        await filter.flush();
+        let frame;
+        while ((frame = await filter.receive()) !== null) {
+            yield frame;
+        }
+    }
+}
+async function* bitStreamFilterStream(packets, bsf) {
+    // Process all packets through bitstream filter
+    for await (const packet of packets) {
+        try {
+            const filtered = await bsf.process(packet);
+            for (const outPacket of filtered) {
+                yield outPacket;
+            }
+        }
+        finally {
+            // Free the input packet after filtering
+            packet.free();
+        }
+    }
+    // Flush bitstream filter
+    for await (const packet of bsf.flushPackets()) {
+        yield packet;
+    }
+}
+// ============================================================================
+// Type Guards
+// ============================================================================
+function isNamedInputs(obj) {
+    return obj && typeof obj === 'object' && !Array.isArray(obj) && !isAsyncIterable(obj) && !isMediaInput(obj);
+}
+function isAsyncIterable(obj) {
+    return obj && typeof obj[Symbol.asyncIterator] === 'function';
+}
+function isMediaInput(obj) {
+    return obj && typeof obj.packets === 'function' && typeof obj.video === 'function' && typeof obj.audio === 'function';
+}
+function isDecoder(obj) {
+    return obj && typeof obj.decode === 'function' && typeof obj.flush === 'function';
+}
+function isEncoder(obj) {
+    return obj && typeof obj.encode === 'function' && typeof obj.flush === 'function';
+}
+function isFilterAPI(obj) {
+    return obj && typeof obj.process === 'function' && typeof obj.receive === 'function';
+}
+function isBitStreamFilterAPI(obj) {
+    return obj && typeof obj.process === 'function' && typeof obj.flushPackets === 'function' && typeof obj.reset === 'function';
+}
+function isMediaOutput(obj) {
+    return obj && typeof obj.writePacket === 'function' && typeof obj.writeHeader === 'function';
+}
+function isPacket(obj) {
+    return obj && 'streamIndex' in obj && 'pts' in obj && 'dts' in obj;
+}
+//# sourceMappingURL=pipeline.js.map