node-av-light 0.0.0-stage → 7.1.0-beta.1

package/dist/lib/binding.js

@@ -0,0 +1,102 @@
+/**
+ * Native bindings loader
+ *
+ * This module loads the native C++ bindings compiled by node-gyp.
+ * All native classes are accessed through this single entry point.
+ */
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { resolve } from 'node:path';
+import { isMainThread } from 'node:worker_threads';
+import { getDirname } from '../utils/electron.js';
+import { isMusl } from '../utils/libc.js';
+import { nativePackagePrefix } from '../utils/variant.js';
+const __dirname = getDirname(import.meta.url);
+/**
+ * Load the native binding
+ *
+ * @returns The loaded native binding interface
+ *
+ * @internal
+ */
+function loadBinding() {
+    const require = createRequire(import.meta.url);
+    const errors = [];
+    // Detect platform
+    const platform = process.platform;
+    const arch = process.arch;
+    const platformArch = `${platform}-${arch}`;
+    const loadLocal = process.env.AV_FROM_SOURCE === '1';
+    // node-av, node-av-lgpl and node-av-light each depend on their own platform packages
+    const packagePrefix = nativePackagePrefix();
+    // Local build directory (--build-from-source)
+    try {
+        const releasePath = resolve(__dirname, '..', '..', 'build', 'Release', 'node-av.node');
+        const binaryPath = resolve(__dirname, '..', '..', 'binary', 'node-av.node');
+        const rootPath = resolve(__dirname, '..', '..', 'node-av.node');
+        const localPath = [releasePath, binaryPath, rootPath];
+        for (const path of localPath) {
+            if (existsSync(path)) {
+                return require(path);
+            }
+        }
+    }
+    catch (err) {
+        errors.push(new Error(`Local build loading failed: ${err}`));
+    }
+    if (!loadLocal) {
+        // For Windows, pick the binary matching the Node.js runtime's toolchain.
+        if (platform === 'win32') {
+            // MinGW builds are discontinued: a Node.js compiled under MSYS2/MinGW
+            // (os.type() 'MINGW64_NT-*') used to get its own package, now every
+            // Windows runtime loads the MSVC build.
+            // const useMingW = type() !== 'Windows_NT';
+            // if (useMingW) {
+            //   try {
+            //     const packageName = `@seydx/node-av-${platformArch}-mingw`;
+            //     return require(`${packageName}/node-av.node`);
+            //   } catch (err) {
+            //     errors.push(new Error(`MinGW package not found or loading failed: ${err}`));
+            //   }
+            // }
+            try {
+                const packageName = `${packagePrefix}-${platformArch}-msvc`;
+                return require(`${packageName}/node-av.node`);
+            }
+            catch (err) {
+                errors.push(new Error(`MSVC package not found or loading failed: ${err}`));
+            }
+        }
+        else {
+            // Non-Windows platforms. musl (Alpine) needs its own build, a glibc one doesn't load there.
+            try {
+                const packageName = `${packagePrefix}-${platformArch}${isMusl() ? '-musl' : ''}`;
+                return require(`${packageName}/node-av.node`);
+            }
+            catch (err) {
+                errors.push(new Error(`Platform package not found or loading failed: ${err}`));
+            }
+        }
+    }
+    // All attempts failed
+    const errorMessages = errors.map((e) => e.message).join('\n  ');
+    // prettier-ignore
+    throw new Error(`Could not load the node-av native binding for ${platformArch}.\n` +
+        `Errors:\n  ${errorMessages}\n\n`);
+}
+// Load the native binding with fallback logic
+const bindings = loadBinding();
+// Custom-IO callbacks called from the threadpool wait for this thread's event
+// loop without a timeout (live sources stall legitimately). After 'exit' that
+// loop never runs them, and process.exit() joins the threadpool, so the waiting
+// threads must fail with AVERROR_EXIT instead of blocking the exit forever.
+// Only the main thread's exit ends every environment. Node sets _exiting before
+// every real 'exit'; a manual process.emit('exit') (from an embedder or a test
+// harness) must not end IO, and the real exit can still follow, hence on().
+process.on('exit', () => {
+    if (Reflect.get(process, '_exiting') === true) {
+        bindings.IOContext.markExiting?.(isMainThread);
+    }
+});
+export { bindings };
+//# sourceMappingURL=binding.js.map

package/dist/lib/binding.js.map

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

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

@@ -0,0 +1,381 @@
+import { BitStreamFilter } from './bitstream-filter.js';
+import { CodecParameters } from './codec-parameters.js';
+import { OptionMember } from './option.js';
+import { Rational } from './rational.js';
+import type { NativeBitStreamFilterContext, NativeWrapper } from './native-types.js';
+import type { Packet } from './packet.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 declare class BitStreamFilterContext extends OptionMember<NativeBitStreamFilterContext> implements Disposable, NativeWrapper<NativeBitStreamFilterContext> {
+    private _filter?;
+    constructor();
+    /**
+     * 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(): boolean;
+    /**
+     * 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(): CodecParameters | null;
+    /**
+     * 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(): CodecParameters | null;
+    /**
+     * 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(): Rational;
+    set inputTimeBase(value: Rational);
+    /**
+     * 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(): Rational | null;
+    /**
+     * The bitstream filter being used.
+     *
+     * Reference to the filter descriptor allocated to this context.
+     *
+     * Direct mapping to AVBSFContext->filter.
+     */
+    get filter(): BitStreamFilter | null;
+    /**
+     * 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: BitStreamFilter): number;
+    /**
+     * 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(): number;
+    /**
+     * 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(): void;
+    /**
+     * 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(): void;
+    /**
+     * 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
+     */
+    sendPacket(packet: Packet | null): Promise<number>;
+    /**
+     * 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: Packet | null): number;
+    /**
+     * 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
+     */
+    receivePacket(packet: Packet): Promise<number>;
+    /**
+     * 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: Packet): number;
+    /**
+     * Get the underlying native BitStreamFilterContext object.
+     *
+     * @returns The native BitStreamFilterContext binding object
+     *
+     * @internal
+     */
+    getNative(): NativeBitStreamFilterContext;
+    /**
+     * 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](): void;
+}