node-av 0.0.1

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

@@ -0,0 +1,407 @@
+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 packets.
+ *
+ * Manages the state for bitstream filtering operations.
+ * Processes packets through a bitstream filter without decoding.
+ * Supports packet-by-packet filtering with internal buffering.
+ *
+ * Direct mapping to FFmpeg's AVBSFContext.
+ *
+ * @example
+ * ```typescript
+ * import { BitStreamFilter, BitStreamFilterContext, Packet, FFmpegError } from 'node-av';
+ * import { AVERROR_EOF, AVERROR } from 'node-av/constants';
+ *
+ * // Create and initialize filter context
+ * const filter = BitStreamFilter.getByName('h264_mp4toannexb');
+ * const ctx = new BitStreamFilterContext();
+ *
+ * // Allocate and configure
+ * let ret = ctx.alloc(filter);
+ * FFmpegError.throwIfError(ret, 'alloc');
+ *
+ * // Copy input parameters from stream to BSF context
+ * stream.codecpar.copy(ctx.inputCodecParameters);
+ * ctx.inputTimeBase = stream.timeBase;
+ *
+ * // Initialize filter
+ * ret = ctx.init();
+ * FFmpegError.throwIfError(ret, 'init');
+ *
+ * // Process packets
+ * while (hasMorePackets) {
+ *   const inputPacket = getNextPacket();
+ *
+ *   // Send packet to filter
+ *   ret = await ctx.sendPacket(inputPacket);
+ *   FFmpegError.throwIfError(ret, 'sendPacket');
+ *
+ *   // Receive filtered packets
+ *   while (true) {
+ *     const outputPacket = new Packet();
+ *     const result = await ctx.receivePacket(outputPacket);
+ *
+ *     if (result.eagain || result.eof) break;
+ *     FFmpegError.throwIfError(result.ret || result, 'receivePacket');
+ *
+ *     // Process filtered packet
+ *     processPacket(outputPacket);
+ *     outputPacket.unref();
+ *   }
+ * }
+ *
+ * // Send EOF
+ * await ctx.sendPacket(null);
+ *
+ * // Drain remaining packets
+ * while (true) {
+ *   const outputPacket = new Packet();
+ *   const result = await ctx.receivePacket(outputPacket);
+ *   if (result.eof) break;
+ *   // Process remaining packets
+ * }
+ *
+ * // Cleanup
+ * ctx.free();
+ * ```
+ */
+export class BitStreamFilterContext extends OptionMember {
+    _filter; // Cache for filter wrapper
+    /**
+     * Create a new bitstream filter context.
+     *
+     * The context is uninitialized - you must call alloc() and init() before use.
+     * No FFmpeg resources are allocated until initialization.
+     *
+     * Direct wrapper around AVBSFContext.
+     *
+     * @example
+     * ```typescript
+     * const ctx = new BitStreamFilterContext();
+     * ctx.alloc(filter);
+     * ctx.init();
+     * // Context is now ready for filtering
+     * ```
+     */
+    constructor() {
+        super(new bindings.BitStreamFilterContext());
+    }
+    /**
+     * Check if the context is initialized.
+     *
+     * Returns true if init() has been called successfully.
+     *
+     * @returns True if initialized, false otherwise
+     */
+    get isInitialized() {
+        return this.native.isInitialized();
+    }
+    /**
+     * Input codec parameters (read-only reference, mutable contents).
+     *
+     * Returns a reference to the BSF context's internal codec parameters.
+     * While you cannot replace this object (no setter), you can modify its contents
+     * or use it as a destination for copy operations.
+     *
+     * You must configure these parameters before calling init().
+     *
+     * Maps to AVBSFContext->par_in.
+     *
+     * @example
+     * ```typescript
+     * // Copy parameters from input stream to BSF context
+     * if (ctx.inputCodecParameters) {
+     *   stream.codecpar.copy(ctx.inputCodecParameters);
+     *
+     *   // Or set individual properties
+     *   ctx.inputCodecParameters.codecType = AVMEDIA_TYPE_VIDEO;
+     *   ctx.inputCodecParameters.codecId = AV_CODEC_ID_H264;
+     * }
+     * ```
+     */
+    get inputCodecParameters() {
+        // The native binding returns a CodecParameters object created with the constructor
+        // It's the native object itself, not a TypeScript wrapper
+        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 (read-only reference, read-only contents).
+     *
+     * Returns a reference to the BSF context's output codec parameters.
+     * These are automatically configured by the filter during init().
+     * You should not modify these parameters.
+     *
+     * Maps to AVBSFContext->par_out.
+     *
+     * @example
+     * ```typescript
+     * // After initialization, read the output parameters
+     * console.log(`Output codec: ${ctx.outputCodecParameters?.codecId}`);
+     *
+     * // Use them to configure downstream components
+     * if (ctx.outputCodecParameters) {
+     *   ctx.outputCodecParameters.copy(nextStream.codecpar);
+     * }
+     * ```
+     */
+    get outputCodecParameters() {
+        // The native binding returns a CodecParameters object created with the constructor
+        // It's the native object itself, not a TypeScript wrapper
+        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 for input packet timestamps.
+     * Must be set before calling init().
+     *
+     * Maps to AVBSFContext->time_base_in.
+     *
+     * @example
+     * ```typescript
+     * ctx.inputTimeBase = new Rational(1, 1000); // 1ms time base
+     * ```
+     */
+    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 for output packet timestamps.
+     * Set by the filter during init().
+     *
+     * Maps to AVBSFContext->time_base_out.
+     *
+     * @example
+     * ```typescript
+     * // After initialization
+     * console.log(`Output time base: ${ctx.outputTimeBase.num}/${ctx.outputTimeBase.den}`);
+     * ```
+     */
+    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 this context was allocated with.
+     *
+     * Maps to AVBSFContext->filter.
+     *
+     * @example
+     * ```typescript
+     * console.log(`Using filter: ${ctx.filter?.name}`);
+     * ```
+     */
+    get filter() {
+        if (!this._filter) {
+            const native = this.native.filter;
+            if (!native) {
+                return null;
+            }
+            this._filter = new BitStreamFilter(native);
+        }
+        return this._filter;
+    }
+    /**
+     * Allocate the bitstream filter context.
+     *
+     * Allocates the context for the specified filter.
+     * Must be called before any other operations.
+     * After allocation, configure input parameters before calling init().
+     *
+     * Calls av_bsf_alloc() internally.
+     *
+     * @param filter - The bitstream filter to use
+     * @returns 0 on success, negative error code on failure
+     *
+     * @example
+     * ```typescript
+     * const filter = BitStreamFilter.getByName('h264_mp4toannexb');
+     * const ctx = new BitStreamFilterContext();
+     * const ret = ctx.alloc(filter);
+     * FFmpegError.throwIfError(ret, 'alloc');
+     * ```
+     */
+    alloc(filter) {
+        return this.native.alloc(filter.getNative());
+    }
+    /**
+     * Initialize the bitstream filter context.
+     *
+     * Prepares the filter for use after parameters have been set.
+     * Sets up output parameters based on input and filter configuration.
+     * Must be called after alloc() and parameter configuration.
+     *
+     * Calls av_bsf_init() internally.
+     *
+     * @returns 0 on success, negative error code on failure
+     *
+     * @example
+     * ```typescript
+     * // After allocation and parameter setup
+     * const ret = ctx.init();
+     * FFmpegError.throwIfError(ret, 'init');
+     * ```
+     */
+    init() {
+        return this.native.init();
+    }
+    /**
+     * Free the bitstream filter context.
+     *
+     * Releases all resources associated with the context.
+     * The context cannot be used after calling this method.
+     *
+     * Calls av_bsf_free() internally.
+     *
+     * @example
+     * ```typescript
+     * ctx.free();
+     * // Context is now freed and unusable
+     * ```
+     */
+    free() {
+        this.native.free();
+        this._filter = undefined;
+    }
+    /**
+     * Flush the bitstream filter.
+     *
+     * Resets the internal filter state.
+     * Should be called when seeking or switching streams.
+     *
+     * Calls av_bsf_flush() internally.
+     *
+     * @example
+     * ```typescript
+     * // When seeking
+     * ctx.flush();
+     * // Filter is reset and ready for new packets
+     * ```
+     */
+    flush() {
+        this.native.flush();
+    }
+    /**
+     * Send a packet to the filter.
+     *
+     * Submits a packet for filtering.
+     * The filter takes ownership of the packet.
+     * Pass null to signal end of stream.
+     *
+     * After sending a packet, call receivePacket() repeatedly
+     * until it returns EAGAIN or EOF.
+     *
+     * Calls av_bsf_send_packet() internally.
+     *
+     * @param packet - Packet to filter, or null for EOF
+     * @returns Promise resolving to 0 on success, error code on failure
+     *
+     * @example
+     * ```typescript
+     * // Send packet
+     * const ret = await ctx.sendPacket(inputPacket);
+     * if (ret < 0 && ret !== AVERROR_EAGAIN) {
+     *   throw new Error('Failed to send packet');
+     * }
+     *
+     * // Send EOF
+     * await ctx.sendPacket(null);
+     * ```
+     */
+    async sendPacket(packet) {
+        return await this.native.sendPacket(packet ? packet.getNative() : null);
+    }
+    /**
+     * Receive a filtered packet.
+     *
+     * Gets a filtered packet from the filter.
+     * Must be called repeatedly after sendPacket() until EAGAIN or EOF.
+     * One input packet may produce multiple output packets.
+     *
+     * Calls av_bsf_receive_packet() internally.
+     *
+     * @param packet - Packet to receive filtered data into
+     * @returns Promise resolving to 0 on success, negative error code on failure
+     *
+     * @example
+     * ```typescript
+     * import { AVERROR_EAGAIN, AVERROR_EOF } from 'node-av/constants';
+     *
+     * const packet = new Packet();
+     * const ret = await ctx.receivePacket(packet);
+     *
+     * if (ret === AVERROR_EAGAIN) {
+     *   // Need to send more packets
+     * } else if (ret === AVERROR_EOF) {
+     *   // No more packets
+     * } else if (ret < 0) {
+     *   // Error occurred
+     * } else {
+     *   // Got a packet successfully
+     *   processPacket(packet);
+     * }
+     * ```
+     */
+    async receivePacket(packet) {
+        return await this.native.receivePacket(packet.getNative());
+    }
+    /**
+     * Get the underlying native object.
+     *
+     * For advanced use cases that need direct access to the native bindings.
+     *
+     * @returns Native BitStreamFilterContext object
+     * @internal
+     */
+    getNative() {
+        return this.native;
+    }
+    /**
+     * Dispose of the context resources.
+     *
+     * Automatically called when using the `using` statement.
+     * Frees all associated FFmpeg resources.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   using ctx = new BitStreamFilterContext();
+     *   ctx.alloc(filter);
+     *   // ... 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,124 @@
+import type { AVCodecID } from './constants.js';
+import type { NativeBitStreamFilter, NativeWrapper } from './native-types.js';
+/**
+ * Bitstream filter definition.
+ *
+ * Represents a bitstream filter for manipulating encoded data without decoding.
+ * Allows modification of codec-specific headers, packet metadata, and bitstream syntax.
+ * This is an immutable descriptor - actual filtering happens via BitStreamFilterContext.
+ *
+ * Direct mapping to FFmpeg's AVBitStreamFilter.
+ *
+ * @example
+ * ```typescript
+ * import { BitStreamFilter } from 'node-av';
+ *
+ * // Find a specific bitstream filter
+ * const h264Mp4ToAnnexB = BitStreamFilter.getByName('h264_mp4toannexb');
+ * if (!h264Mp4ToAnnexB) throw new Error('h264_mp4toannexb filter not found');
+ *
+ * console.log(`Filter: ${h264Mp4ToAnnexB.name}`);
+ * console.log(`Supported codecs: ${h264Mp4ToAnnexB.codecIds}`);
+ *
+ * // List all available bitstream filters
+ * const filters = BitStreamFilter.iterate();
+ * for (const filter of filters) {
+ *   console.log(`Found filter: ${filter.name}`);
+ * }
+ * ```
+ */
+export declare class BitStreamFilter implements NativeWrapper<NativeBitStreamFilter> {
+    private native;
+    /**
+     * Create a BitStreamFilter wrapper.
+     *
+     * Usually not called directly - use static methods instead.
+     * No FFmpeg resources are allocated.
+     *
+     * @param native - Native BitStreamFilter object from bindings
+     * @internal
+     */
+    constructor(native: NativeBitStreamFilter);
+    /**
+     * Find a bitstream filter by name.
+     *
+     * Searches for a registered bitstream filter with the given name.
+     * Returns null if no filter with that name exists.
+     *
+     * Calls av_bsf_get_by_name() internally.
+     *
+     * @param name - Name of the bitstream filter (e.g., 'h264_mp4toannexb')
+     * @returns BitStreamFilter if found, null otherwise
+     *
+     * @example
+     * ```typescript
+     * const filter = BitStreamFilter.getByName('h264_mp4toannexb');
+     * if (filter) {
+     *   console.log(`Found filter: ${filter.name}`);
+     * }
+     * ```
+     */
+    static getByName(name: string): BitStreamFilter | null;
+    /**
+     * Get all available bitstream filters.
+     *
+     * Returns an array of all registered bitstream filters.
+     * Useful for discovery and debugging.
+     *
+     * Calls av_bsf_iterate() internally.
+     *
+     * @returns Array of all available bitstream filters
+     *
+     * @example
+     * ```typescript
+     * const filters = BitStreamFilter.iterate();
+     * for (const filter of filters) {
+     *   console.log(`${filter.name}: ${filter.codecIds?.join(', ') || 'all codecs'}`);
+     * }
+     * ```
+     */
+    static iterate(): BitStreamFilter[];
+    /**
+     * Filter name.
+     *
+     * Short name used to identify the filter.
+     * This is the name used with getByName().
+     *
+     * Maps to AVBitStreamFilter->name.
+     *
+     * @example
+     * ```typescript
+     * const filter = BitStreamFilter.getByName('h264_mp4toannexb');
+     * console.log(filter.name); // 'h264_mp4toannexb'
+     * ```
+     */
+    get name(): string | null;
+    /**
+     * Supported codec IDs.
+     *
+     * List of codec IDs this filter can process.
+     * If null, the filter works with any codec.
+     *
+     * Maps to AVBitStreamFilter->codec_ids.
+     *
+     * @example
+     * ```typescript
+     * import { AV_CODEC_ID_H264 } from 'node-av/constants';
+     *
+     * const filter = BitStreamFilter.getByName('h264_mp4toannexb');
+     * if (filter.codecIds?.includes(AV_CODEC_ID_H264)) {
+     *   console.log('Filter supports H.264');
+     * }
+     * ```
+     */
+    get codecIds(): AVCodecID[] | null;
+    /**
+     * Get the underlying native object.
+     *
+     * For advanced use cases that need direct access to the native bindings.
+     *
+     * @returns Native BitStreamFilter object
+     * @internal
+     */
+    getNative(): NativeBitStreamFilter;
+}

package/dist/lib/bitstream-filter.js

@@ -0,0 +1,138 @@
+import { bindings } from './binding.js';
+/**
+ * Bitstream filter definition.
+ *
+ * Represents a bitstream filter for manipulating encoded data without decoding.
+ * Allows modification of codec-specific headers, packet metadata, and bitstream syntax.
+ * This is an immutable descriptor - actual filtering happens via BitStreamFilterContext.
+ *
+ * Direct mapping to FFmpeg's AVBitStreamFilter.
+ *
+ * @example
+ * ```typescript
+ * import { BitStreamFilter } from 'node-av';
+ *
+ * // Find a specific bitstream filter
+ * const h264Mp4ToAnnexB = BitStreamFilter.getByName('h264_mp4toannexb');
+ * if (!h264Mp4ToAnnexB) throw new Error('h264_mp4toannexb filter not found');
+ *
+ * console.log(`Filter: ${h264Mp4ToAnnexB.name}`);
+ * console.log(`Supported codecs: ${h264Mp4ToAnnexB.codecIds}`);
+ *
+ * // List all available bitstream filters
+ * const filters = BitStreamFilter.iterate();
+ * for (const filter of filters) {
+ *   console.log(`Found filter: ${filter.name}`);
+ * }
+ * ```
+ */
+export class BitStreamFilter {
+    native;
+    /**
+     * Create a BitStreamFilter wrapper.
+     *
+     * Usually not called directly - use static methods instead.
+     * No FFmpeg resources are allocated.
+     *
+     * @param native - Native BitStreamFilter object from bindings
+     * @internal
+     */
+    constructor(native) {
+        this.native = native;
+    }
+    /**
+     * Find a bitstream filter by name.
+     *
+     * Searches for a registered bitstream filter with the given name.
+     * Returns null if no filter with that name exists.
+     *
+     * Calls av_bsf_get_by_name() internally.
+     *
+     * @param name - Name of the bitstream filter (e.g., 'h264_mp4toannexb')
+     * @returns BitStreamFilter if found, null otherwise
+     *
+     * @example
+     * ```typescript
+     * const filter = BitStreamFilter.getByName('h264_mp4toannexb');
+     * if (filter) {
+     *   console.log(`Found filter: ${filter.name}`);
+     * }
+     * ```
+     */
+    static getByName(name) {
+        const native = bindings.BitStreamFilter.getByName(name);
+        return native ? new BitStreamFilter(native) : null;
+    }
+    /**
+     * Get all available bitstream filters.
+     *
+     * Returns an array of all registered bitstream filters.
+     * Useful for discovery and debugging.
+     *
+     * Calls av_bsf_iterate() internally.
+     *
+     * @returns Array of all available bitstream filters
+     *
+     * @example
+     * ```typescript
+     * const filters = BitStreamFilter.iterate();
+     * for (const filter of filters) {
+     *   console.log(`${filter.name}: ${filter.codecIds?.join(', ') || 'all codecs'}`);
+     * }
+     * ```
+     */
+    static iterate() {
+        const natives = bindings.BitStreamFilter.iterate();
+        return natives.map((native) => new BitStreamFilter(native));
+    }
+    /**
+     * Filter name.
+     *
+     * Short name used to identify the filter.
+     * This is the name used with getByName().
+     *
+     * Maps to AVBitStreamFilter->name.
+     *
+     * @example
+     * ```typescript
+     * const filter = BitStreamFilter.getByName('h264_mp4toannexb');
+     * console.log(filter.name); // 'h264_mp4toannexb'
+     * ```
+     */
+    get name() {
+        return this.native.name;
+    }
+    /**
+     * Supported codec IDs.
+     *
+     * List of codec IDs this filter can process.
+     * If null, the filter works with any codec.
+     *
+     * Maps to AVBitStreamFilter->codec_ids.
+     *
+     * @example
+     * ```typescript
+     * import { AV_CODEC_ID_H264 } from 'node-av/constants';
+     *
+     * const filter = BitStreamFilter.getByName('h264_mp4toannexb');
+     * if (filter.codecIds?.includes(AV_CODEC_ID_H264)) {
+     *   console.log('Filter supports H.264');
+     * }
+     * ```
+     */
+    get codecIds() {
+        return this.native.codecIds;
+    }
+    /**
+     * Get the underlying native object.
+     *
+     * For advanced use cases that need direct access to the native bindings.
+     *
+     * @returns Native BitStreamFilter object
+     * @internal
+     */
+    getNative() {
+        return this.native;
+    }
+}
+//# sourceMappingURL=bitstream-filter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bitstream-filter.js","sourceRoot":"","sources":["../../src/lib/bitstream-filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAKxC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,OAAO,eAAe;IAClB,MAAM,CAAwB;IAEtC;;;;;;;;OAQG;IACH,YAAY,MAA6B;QACvC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,SAAS,CAAC,IAAY;QAC3B,MAAM,MAAM,GAAG,QAAQ,CAAC,eAAe,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACxD,OAAO,MAAM,CAAC,CAAC,CAAC,IAAI,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACrD,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,OAAO;QACZ,MAAM,OAAO,GAAG,QAAQ,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC;QACnD,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,MAA6B,EAAE,EAAE,CAAC,IAAI,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;IACrF,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IAC1B,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,QAA8B,CAAC;IACpD,CAAC;IAED;;;;;;;OAOG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;CACF"}