node-av-lgpl 0.0.0 → 7.1.0-beta.1

package/dist/lib/bitstream-filter-context.js

@@ -0,0 +1,443 @@
+import { bindings } from './binding.js';
+import { BitStreamFilter } from './bitstream-filter.js';
+import { CodecParameters } from './codec-parameters.js';
+import { OptionMember } from './option.js';
+import { Rational } from './rational.js';
+/**
+ * Bitstream filter context for processing compressed video/audio streams.
+ *
+ * Applies bitstream filters to modify or analyze compressed packets without
+ * full decoding/encoding. Common uses include format conversion (e.g., H.264 MP4 to Annex B),
+ * metadata extraction, parameter set manipulation, and packet splitting/merging.
+ * Essential for stream compatibility between different containers and decoders.
+ *
+ * Direct mapping to FFmpeg's AVBSFContext.
+ *
+ * @example
+ * ```typescript
+ * import { BitStreamFilterContext, BitStreamFilter, Packet, FFmpegError } from 'node-av';
+ *
+ * // Create and initialize H.264 stream format converter
+ * const ctx = new BitStreamFilterContext();
+ * const filter = BitStreamFilter.getByName('h264_mp4toannexb');
+ * if (!filter) {
+ *   throw new Error('H.264 filter not available');
+ * }
+ *
+ * let ret = ctx.alloc(filter);
+ * FFmpegError.throwIfError(ret, 'alloc');
+ *
+ * ret = ctx.init();
+ * FFmpegError.throwIfError(ret, 'init');
+ *
+ * // Process packets
+ * const inputPacket = new Packet();
+ * const outputPacket = new Packet();
+ *
+ * ret = await ctx.sendPacket(inputPacket);
+ * FFmpegError.throwIfError(ret, 'sendPacket');
+ *
+ * ret = await ctx.receivePacket(outputPacket);
+ * if (ret >= 0) {
+ *   // Process filtered packet
+ * }
+ *
+ * // Cleanup
+ * ctx.free();
+ * ```
+ *
+ * @see {@link BitStreamFilter} For available filter types
+ * @see {@link Packet} For packet manipulation
+ */
+export class BitStreamFilterContext extends OptionMember {
+    _filter; // Cache for filter wrapper
+    constructor() {
+        super(new bindings.BitStreamFilterContext());
+    }
+    /**
+     * Check if the context has been initialized.
+     *
+     * Returns true if init() has been successfully called.
+     * The context must be initialized before sending/receiving packets.
+     */
+    get isInitialized() {
+        return this.native.isInitialized();
+    }
+    /**
+     * Input codec parameters.
+     *
+     * Parameters describing the input stream format.
+     * These are automatically configured from the input packets in most cases.
+     * Reads defaults once the context is freed.
+     *
+     * Direct mapping to AVBSFContext->par_in.
+     */
+    get inputCodecParameters() {
+        const nativeParams = this.native.inputCodecParameters;
+        if (!nativeParams) {
+            return null;
+        }
+        // Wrap it in our TypeScript class
+        const wrapper = Object.create(CodecParameters.prototype);
+        wrapper.native = nativeParams;
+        return wrapper;
+    }
+    /**
+     * Output codec parameters.
+     *
+     * Parameters describing the output stream format after filtering.
+     * These reflect any changes made by the bitstream filter.
+     * Reads defaults once the context is freed.
+     *
+     * Direct mapping to AVBSFContext->par_out.
+     */
+    get outputCodecParameters() {
+        const nativeParams = this.native.outputCodecParameters;
+        if (!nativeParams) {
+            return null;
+        }
+        // Wrap it in our TypeScript class
+        const wrapper = Object.create(CodecParameters.prototype);
+        wrapper.native = nativeParams;
+        return wrapper;
+    }
+    /**
+     * Input time base.
+     *
+     * Time base of the input packets (timestamps per second).
+     * Must be set before init() for proper timestamp handling.
+     *
+     * Direct mapping to AVBSFContext->time_base_in.
+     */
+    get inputTimeBase() {
+        const tb = this.native.inputTimeBase;
+        return new Rational(tb.num, tb.den);
+    }
+    set inputTimeBase(value) {
+        this.native.inputTimeBase = { num: value.num, den: value.den };
+    }
+    /**
+     * Output time base.
+     *
+     * Time base of the output packets after filtering.
+     * May differ from input if the filter modifies timing.
+     *
+     * Direct mapping to AVBSFContext->time_base_out.
+     */
+    get outputTimeBase() {
+        const tb = this.native.outputTimeBase;
+        if (!tb)
+            return null;
+        return new Rational(tb.num, tb.den);
+    }
+    /**
+     * The bitstream filter being used.
+     *
+     * Reference to the filter descriptor allocated to this context.
+     *
+     * Direct mapping to AVBSFContext->filter.
+     */
+    get filter() {
+        if (!this._filter) {
+            const native = this.native.filter;
+            if (!native) {
+                return null;
+            }
+            this._filter = new BitStreamFilter(native);
+        }
+        return this._filter;
+    }
+    /**
+     * Allocate a bitstream filter context.
+     *
+     * Allocates and configures the context for the specified filter.
+     * Must be called before init().
+     *
+     * Direct mapping to av_bsf_alloc().
+     *
+     * @param filter - The bitstream filter to use
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - AVERROR_ENOMEM: Memory allocation failure
+     *   - AVERROR_EINVAL: Invalid filter
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     *
+     * const filter = BitStreamFilter.getByName('h264_mp4toannexb');
+     * if (!filter) {
+     *   throw new Error('Filter not found');
+     * }
+     *
+     * const ret = ctx.alloc(filter);
+     * FFmpegError.throwIfError(ret, 'alloc');
+     * ```
+     *
+     * @see {@link init} To initialize after allocation
+     * @see {@link BitStreamFilter.getByName} To get filter by name
+     */
+    alloc(filter) {
+        return this.native.alloc(filter.getNative());
+    }
+    /**
+     * Initialize the bitstream filter context.
+     *
+     * Initializes the filter with the configured parameters.
+     * Must be called after alloc() and before processing packets.
+     *
+     * Direct mapping to av_bsf_init().
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - AVERROR_EINVAL: Invalid parameters
+     *   - AVERROR_ENOMEM: Memory allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     *
+     * // Allocate and initialize
+     * const ret1 = ctx.alloc(filter);
+     * FFmpegError.throwIfError(ret1, 'alloc');
+     *
+     * // Set parameters if needed
+     * ctx.inputTimeBase = new Rational(1, 25);
+     *
+     * const ret2 = ctx.init();
+     * FFmpegError.throwIfError(ret2, 'init');
+     * ```
+     *
+     * @see {@link alloc} Must be called first
+     * @see {@link isInitialized} To check initialization status
+     */
+    init() {
+        return this.native.init();
+    }
+    /**
+     * Free the bitstream filter context.
+     *
+     * Releases all resources associated with the context.
+     * The context becomes invalid after calling this.
+     *
+     * Direct mapping to av_bsf_free().
+     *
+     * @example
+     * ```typescript
+     * ctx.free();
+     * // Context is now invalid
+     * ```
+     *
+     * @see {@link Symbol.dispose} For automatic cleanup
+     * @see {@link alloc} To allocate
+     */
+    free() {
+        this.native.free();
+        this._filter = undefined;
+    }
+    /**
+     * Flush the bitstream filter.
+     *
+     * Resets the internal state and discards any buffered data.
+     * Useful when seeking or switching streams.
+     *
+     * Direct mapping to av_bsf_flush().
+     *
+     * @example
+     * ```typescript
+     * // Flush when seeking
+     * ctx.flush();
+     * // Now ready to process packets from new position
+     * ```
+     */
+    flush() {
+        this.native.flush();
+    }
+    /**
+     * Send a packet to the bitstream filter.
+     *
+     * Submits a packet for filtering. The filter may buffer the packet
+     * internally and require multiple calls to receivePacket() to retrieve
+     * all output. Send null to signal end of stream.
+     *
+     * Direct mapping to av_bsf_send_packet().
+     *
+     * @param packet - Packet to filter, or null to signal EOF
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - AVERROR_EAGAIN: Filter needs output to be consumed first
+     *   - AVERROR_EOF: Filter has been flushed
+     *   - AVERROR_EINVAL: Invalid parameters
+     *   - AVERROR_ENOMEM: Memory allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     * import { AVERROR_EAGAIN } from 'node-av';
+     *
+     * const ret = await ctx.sendPacket(inputPacket);
+     * if (ret === AVERROR_EAGAIN) {
+     *   // Need to receive packets first
+     *   const ret2 = await ctx.receivePacket(outputPacket);
+     *   FFmpegError.throwIfError(ret2, 'receivePacket');
+     * } else {
+     *   FFmpegError.throwIfError(ret, 'sendPacket');
+     * }
+     *
+     * // Send EOF
+     * await ctx.sendPacket(null);
+     * ```
+     *
+     * @see {@link receivePacket} To retrieve filtered packets
+     */
+    async sendPacket(packet) {
+        return await this.native.sendPacket(packet ? packet.getNative() : null);
+    }
+    /**
+     * Send a packet to the bitstream filter synchronously.
+     * Synchronous version of sendPacket.
+     *
+     * Submits a packet for filtering. The filter may buffer packets
+     * internally and produce output with different timing.
+     *
+     * Direct mapping to av_bsf_send_packet().
+     *
+     * @param packet - Packet to filter (null to drain)
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - AVERROR_EAGAIN: Need to receive packets first
+     *   - AVERROR_EOF: Filter has been flushed
+     *   - AVERROR_EINVAL: Invalid state
+     *   - AVERROR(ENOMEM): Memory allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     * import { AVERROR_EAGAIN } from 'node-av/constants';
+     *
+     * // Send packet to filter
+     * const ret = ctx.sendPacketSync(inputPacket);
+     * if (ret === AVERROR_EAGAIN) {
+     *   // Need to receive output first
+     *   const outputPacket = new Packet();
+     *   ctx.receivePacketSync(outputPacket);
+     * } else {
+     *   FFmpegError.throwIfError(ret, 'sendPacketSync');
+     * }
+     *
+     * // Drain filter
+     * ctx.sendPacketSync(null);
+     * ```
+     *
+     * @see {@link sendPacket} For async version
+     */
+    sendPacketSync(packet) {
+        return this.native.sendPacketSync(packet ? packet.getNative() : null);
+    }
+    /**
+     * Receive a filtered packet from the bitstream filter.
+     *
+     * Retrieves a packet that has been processed by the filter.
+     * May need to be called multiple times after each sendPacket().
+     *
+     * Direct mapping to av_bsf_receive_packet().
+     *
+     * @param packet - Packet to receive filtered data into
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - AVERROR_EAGAIN: Need more input
+     *   - AVERROR_EOF: No more packets available
+     *   - AVERROR_EINVAL: Invalid parameters
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     * import { AVERROR_EAGAIN, AVERROR_EOF } from 'node-av';
+     *
+     * // Receive all available packets
+     * while (true) {
+     *   const ret = await ctx.receivePacket(outputPacket);
+     *   if (ret === AVERROR_EAGAIN || ret === AVERROR_EOF) {
+     *     break;
+     *   }
+     *   FFmpegError.throwIfError(ret, 'receivePacket');
+     *
+     *   // Process filtered packet
+     *   console.log(`Filtered packet size: ${outputPacket.size}`);
+     * }
+     * ```
+     *
+     * @see {@link sendPacket} To submit packets for filtering
+     */
+    async receivePacket(packet) {
+        return await this.native.receivePacket(packet.getNative());
+    }
+    /**
+     * Receive a filtered packet from the bitstream filter synchronously.
+     * Synchronous version of receivePacket.
+     *
+     * Retrieves a packet that has been processed by the filter.
+     * May need to be called multiple times after each sendPacketSync().
+     *
+     * Direct mapping to av_bsf_receive_packet().
+     *
+     * @param packet - Packet to receive filtered data into
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - AVERROR_EAGAIN: Need more input
+     *   - AVERROR_EOF: No more packets available
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     * import { AVERROR_EAGAIN, AVERROR_EOF } from 'node-av/constants';
+     *
+     * // Receive filtered packets
+     * const outputPacket = new Packet();
+     * let ret;
+     * while ((ret = ctx.receivePacketSync(outputPacket)) >= 0) {
+     *   // Process filtered packet
+     *   console.log(`Filtered packet size: ${outputPacket.size}`);
+     *   outputPacket.unref();
+     * }
+     *
+     * if (ret !== AVERROR_EAGAIN && ret !== AVERROR_EOF) {
+     *   FFmpegError.throwIfError(ret, 'receivePacketSync');
+     * }
+     * ```
+     *
+     * @see {@link receivePacket} For async version
+     */
+    receivePacketSync(packet) {
+        return this.native.receivePacketSync(packet.getNative());
+    }
+    /**
+     * Get the underlying native BitStreamFilterContext object.
+     *
+     * @returns The native BitStreamFilterContext binding object
+     *
+     * @internal
+     */
+    getNative() {
+        return this.native;
+    }
+    /**
+     * Dispose of the bitstream filter context.
+     *
+     * Implements the Disposable interface for automatic cleanup.
+     * Equivalent to calling free().
+     *
+     * @example
+     * ```typescript
+     * {
+     *   using ctx = new BitStreamFilterContext();
+     *   ctx.alloc(filter);
+     *   ctx.init();
+     *   // Use context...
+     * } // Automatically freed when leaving scope
+     * ```
+     */
+    [Symbol.dispose]() {
+        this.native[Symbol.dispose]();
+    }
+}
+//# sourceMappingURL=bitstream-filter-context.js.map

package/dist/lib/bitstream-filter-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitstream-filter-context.js","sourceRoot":"","sources":["../../src/lib/bitstream-filter-context.ts"],"names":[],"mappings":"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"}

package/dist/lib/bitstream-filter.d.ts

@@ -0,0 +1,140 @@
+import type { AVCodecID } from '../constants/constants.js';
+import type { NativeBitStreamFilter, NativeWrapper } from './native-types.js';
+/**
+ * Bitstream filter descriptor.
+ *
+ * Provides access to bitstream filter properties and codec compatibility information.
+ * Bitstream filters are used to modify or analyze compressed bitstreams without
+ * full decoding/encoding. Common uses include H.264/HEVC parameter set extraction,
+ * VP9 superframe splitting, and adding/removing codec-specific headers.
+ *
+ * Direct mapping to FFmpeg's AVBitStreamFilter.
+ *
+ * @example
+ * ```typescript
+ * import { BitStreamFilter } from 'node-av';
+ *
+ * // Get a specific bitstream filter
+ * const h264Filter = BitStreamFilter.getByName('h264_mp4toannexb');
+ * if (h264Filter) {
+ *   console.log(`Filter: ${h264Filter.name}`);
+ *   console.log(`Supported codecs: ${h264Filter.codecIds}`);
+ * }
+ *
+ * // List all available bitstream filters
+ * const filters = BitStreamFilter.iterate();
+ * for (const filter of filters) {
+ *   console.log(`- ${filter.name}`);
+ * }
+ * ```
+ *
+ * @see [AVBitStreamFilter](https://ffmpeg.org/doxygen/trunk/structAVBitStreamFilter.html) - FFmpeg Doxygen
+ */
+export declare class BitStreamFilter implements NativeWrapper<NativeBitStreamFilter> {
+    private native;
+    /**
+     * @param native The native bitstream filter instance
+     *
+     * @internal
+     */
+    constructor(native: NativeBitStreamFilter);
+    /**
+     * Get a bitstream filter by name.
+     *
+     * Retrieves a specific bitstream filter descriptor by its name.
+     * Common filter names include 'h264_mp4toannexb', 'hevc_mp4toannexb',
+     * 'extract_extradata', 'vp9_superframe', etc.
+     *
+     * Direct mapping to av_bsf_get_by_name().
+     *
+     * @param name - Name of the bitstream filter
+     *
+     * @returns BitStreamFilter instance if found, null otherwise
+     *
+     * @example
+     * ```typescript
+     * // Get H.264 stream format converter
+     * const h264Filter = BitStreamFilter.getByName('h264_mp4toannexb');
+     * if (!h264Filter) {
+     *   throw new Error('H.264 bitstream filter not available');
+     * }
+     *
+     * // Get HEVC metadata extractor
+     * const hevcFilter = BitStreamFilter.getByName('hevc_metadata');
+     * ```
+     *
+     * @see {@link iterate} To list all available filters
+     * @see {@link BitStreamFilterContext.alloc} To use the filter
+     */
+    static getByName(name: string): BitStreamFilter | null;
+    /**
+     * Iterate over all available bitstream filters.
+     *
+     * Returns an array of all registered bitstream filters in FFmpeg.
+     * Useful for discovering available filters or building filter lists.
+     *
+     * Direct mapping to av_bsf_iterate().
+     *
+     * @returns Array of all available bitstream filters
+     *
+     * @example
+     * ```typescript
+     * import { BitStreamFilter } from 'node-av';
+     * import { AV_CODEC_ID_H264 } from 'node-av/constants';
+     *
+     * // List all available filters
+     * const filters = BitStreamFilter.iterate();
+     * console.log(`Found ${filters.length} bitstream filters`);
+     *
+     * // Find filters that support H.264
+     * const h264Filters = filters.filter(f =>
+     *   f.codecIds?.includes(AV_CODEC_ID_H264)
+     * );
+     * console.log('H.264 compatible filters:');
+     * for (const filter of h264Filters) {
+     *   console.log(`- ${filter.name}`);
+     * }
+     * ```
+     *
+     * @see {@link getByName} To get a specific filter
+     */
+    static iterate(): BitStreamFilter[];
+    /**
+     * Name of the bitstream filter.
+     *
+     * Human-readable name identifying the filter (e.g., 'h264_mp4toannexb').
+     *
+     * Direct mapping to AVBitStreamFilter->name.
+     */
+    get name(): string | null;
+    /**
+     * List of supported codec IDs.
+     *
+     * Array of codec IDs that this filter can process.
+     * If null, the filter supports all codecs.
+     *
+     * Direct mapping to AVBitStreamFilter->codec_ids.
+     *
+     * @example
+     * ```typescript
+     * import { AV_CODEC_ID_H264, AV_CODEC_ID_HEVC } from 'node-av/constants';
+     *
+     * const filter = BitStreamFilter.getByName('extract_extradata');
+     * if (filter?.codecIds) {
+     *   const supportsH264 = filter.codecIds.includes(AV_CODEC_ID_H264);
+     *   const supportsHEVC = filter.codecIds.includes(AV_CODEC_ID_HEVC);
+     *   console.log(`H.264 support: ${supportsH264}`);
+     *   console.log(`HEVC support: ${supportsHEVC}`);
+     * }
+     * ```
+     */
+    get codecIds(): AVCodecID[] | null;
+    /**
+     * Get the underlying native BitStreamFilter object.
+     *
+     * @returns The native BitStreamFilter binding object
+     *
+     * @internal
+     */
+    getNative(): NativeBitStreamFilter;
+}