node-av 1.1.0 → 1.3.0

package/dist/lib/audio-fifo.js

@@ -1,10 +1,10 @@
 import { bindings } from './binding.js';
 /**
- * Audio FIFO buffer for sample management.
+ * Audio FIFO (First-In-First-Out) buffer for managing audio samples.
  *
- * Provides a first-in-first-out buffer for audio samples.
- * Supports both planar and interleaved audio formats.
- * Automatically handles reallocation when needed.
+ * Provides a thread-safe buffer for audio sample data, supporting both planar and interleaved formats.
+ * Automatically handles buffer reallocation when needed. Essential for audio resampling,
+ * format conversion, and buffering operations.
  *
  * Direct mapping to FFmpeg's AVAudioFifo.
  *
@@ -13,256 +13,211 @@ import { bindings } from './binding.js';
  * import { AudioFifo, FFmpegError } from 'node-av';
  * import { AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
  *
- * // Create audio FIFO for stereo float samples
+ * // Create FIFO for stereo float planar audio
  * const fifo = new AudioFifo();
  * fifo.alloc(AV_SAMPLE_FMT_FLTP, 2, 4096);
  *
- * // Write samples to FIFO
- * const samplesWritten = await fifo.write(inputBuffers, frameSize);
- * FFmpegError.throwIfError(samplesWritten, 'write');
+ * // Write samples
+ * const leftChannel = Buffer.alloc(1024 * 4);  // 1024 float samples
+ * const rightChannel = Buffer.alloc(1024 * 4);
+ * const written = await fifo.write([leftChannel, rightChannel], 1024);
+ * FFmpegError.throwIfError(written, 'write');
  *
- * // Read samples from FIFO
- * const samplesRead = await fifo.read(outputBuffers, frameSize);
- * FFmpegError.throwIfError(samplesRead, 'read');
- *
- * // Check available samples
- * console.log(`Samples in FIFO: ${fifo.size}`);
+ * // Read samples when enough available
+ * if (fifo.size >= 512) {
+ *   const outLeft = Buffer.alloc(512 * 4);
+ *   const outRight = Buffer.alloc(512 * 4);
+ *   const read = await fifo.read([outLeft, outRight], 512);
+ *   FFmpegError.throwIfError(read, 'read');
+ * }
  *
  * // Cleanup
  * fifo.free();
  * ```
+ *
+ * @see [AudioFifo](https://ffmpeg.org/doxygen/trunk/structAVAudioFifo.html) - FFmpeg Doxygen
  */
 export class AudioFifo {
     native;
-    /**
-     * Create a new audio FIFO buffer.
-     *
-     * The FIFO is uninitialized - you must call alloc() before use.
-     * No FFmpeg resources are allocated until alloc() is called.
-     *
-     * Direct wrapper around AVAudioFifo.
-     *
-     * @example
-     * ```typescript
-     * import { AudioFifo } from 'node-av';
-     * import { AV_SAMPLE_FMT_S16 } from 'node-av/constants';
-     *
-     * const fifo = new AudioFifo();
-     * fifo.alloc(AV_SAMPLE_FMT_S16, 2, 1024);
-     * // FIFO is now ready for use
-     * ```
-     */
     constructor() {
         this.native = new bindings.AudioFifo();
     }
     /**
-     * Get the current number of samples in the AVAudioFifo.
-     *
-     * Returns the number of samples currently buffered in the FIFO.
-     *
-     * Direct mapping to av_audio_fifo_size()
-     *
-     * @returns Number of samples currently in the FIFO
-     *
-     * @example
-     * ```typescript
-     * import { FFmpegError } from 'node-av';
-     *
-     * if (fifo.size >= frameSize) {
-     *   // Enough samples available for a full frame
-     *   const ret = await fifo.read(outputBuffer, frameSize);
-     *   FFmpegError.throwIfError(ret, 'read');
-     * }
-     * ```
+     * Number of samples currently in the FIFO.
      *
-     * @readonly
+     * Direct mapping to av_audio_fifo_size().
      */
     get size() {
         return this.native.size;
     }
     /**
-     * Get the available space in the AVAudioFifo.
+     * Number of samples that can be written without reallocation.
      *
-     * Returns the number of samples that can be written without reallocation.
-     *
-     * Direct mapping to av_audio_fifo_space()
-     *
-     * @returns Number of samples that can be written to the FIFO
-     *
-     * @example
-     * ```typescript
-     * import { FFmpegError } from 'node-av';
-     *
-     * if (fifo.space >= frameSize) {
-     *   // Enough space for a full frame
-     *   const ret = await fifo.write(inputBuffer, frameSize);
-     *   FFmpegError.throwIfError(ret, 'write');
-     * }
-     * ```
-     *
-     * @readonly
+     * Direct mapping to av_audio_fifo_space().
      */
     get space() {
         return this.native.space;
     }
     /**
-     * Allocate an AVAudioFifo.
+     * Allocate an AVAudioFifo buffer.
      *
-     * Allocates a FIFO buffer for the specified audio format and size.
+     * Creates a FIFO buffer for the specified audio format and size.
      * The FIFO will automatically grow if more data is written than allocated.
      *
-     * Direct mapping to av_audio_fifo_alloc()
+     * Direct mapping to av_audio_fifo_alloc().
      *
      * @param sampleFmt - Sample format (e.g., AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLTP)
-     * @param channels - Number of channels
-     * @param nbSamples - Initial allocation size, in samples
+     * @param channels - Number of audio channels
+     * @param nbSamples - Initial buffer size in samples
      *
-     * @throws {Error} Memory allocation failure (ENOMEM)
+     * @throws {Error} If allocation fails (ENOMEM)
      *
      * @example
      * ```typescript
      * import { AudioFifo } from 'node-av';
-     * import { AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
+     * import { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
+     *
+     * // For interleaved 16-bit stereo
+     * const fifo1 = new AudioFifo();
+     * fifo1.alloc(AV_SAMPLE_FMT_S16, 2, 4096);
      *
-     * const fifo = new AudioFifo();
-     * fifo.alloc(AV_SAMPLE_FMT_FLTP, 2, 4096);
-     * // FIFO can now hold up to 4096 stereo float samples
+     * // For planar float 5.1 audio
+     * const fifo2 = new AudioFifo();
+     * fifo2.alloc(AV_SAMPLE_FMT_FLTP, 6, 8192);
      * ```
      *
      * @see {@link realloc} To resize the FIFO
+     * @see {@link free} To release the FIFO
      */
     alloc(sampleFmt, channels, nbSamples) {
         this.native.alloc(sampleFmt, channels, nbSamples);
     }
     /**
-     * Free an AVAudioFifo.
+     * Free the FIFO buffer and all associated resources.
      *
-     * Frees the FIFO buffer and all associated resources.
-     * The FIFO object becomes invalid after this call.
+     * After calling this, the FIFO is invalid and must be reallocated before use.
      *
-     * Direct mapping to av_audio_fifo_free()
+     * Direct mapping to av_audio_fifo_free().
      *
      * @example
      * ```typescript
      * fifo.free();
-     * // FIFO is now invalid and should not be used
+     * // FIFO is now invalid, must call alloc() before using again
      * ```
+     *
+     * @see {@link Symbol.dispose} For automatic cleanup
+     * @see {@link alloc} To allocate
      */
     free() {
         this.native.free();
     }
     /**
-     * Write data to an AVAudioFifo.
+     * Write audio samples to the FIFO.
      *
-     * Writes audio samples to the FIFO buffer.
-     * Automatically reallocates the FIFO if more space is needed.
+     * Writes samples to the FIFO buffer. Automatically reallocates if more space is needed.
+     * For planar formats, provide an array of buffers (one per channel).
+     * For interleaved formats, provide a single buffer.
      *
-     * Direct mapping to av_audio_fifo_write()
+     * Direct mapping to av_audio_fifo_write().
      *
-     * @param data - Audio buffer(s) to write from.
-     *               For planar formats: array of buffers (one per channel).
-     *               For interleaved formats: single buffer.
+     * @param data - Audio data buffer(s). Array for planar, single Buffer for interleaved
      * @param nbSamples - Number of samples to write
      *
-     * @returns Number of samples actually written, or negative AVERROR on error:
-     *   - >=0: Number of samples written
-     *   - AVERROR(EINVAL): Invalid parameters
-     *   - AVERROR(ENOMEM): Memory allocation failure
+     * @returns Number of samples written, or negative AVERROR:
+     *   - AVERROR_EINVAL: Invalid parameters
+     *   - AVERROR_ENOMEM: Memory allocation failure
      *
      * @example
      * ```typescript
      * import { FFmpegError } from 'node-av';
      *
-     * // Planar format (separate buffers per channel)
-     * const leftChannel = Buffer.alloc(frameSize * 4);  // float32
-     * const rightChannel = Buffer.alloc(frameSize * 4);
-     * const written = await fifo.write([leftChannel, rightChannel], frameSize);
+     * // Planar format (e.g., FLTP) - separate buffers per channel
+     * const leftData = Buffer.alloc(1024 * 4);  // 1024 float samples
+     * const rightData = Buffer.alloc(1024 * 4);
+     * const written = await fifo.write([leftData, rightData], 1024);
      * FFmpegError.throwIfError(written, 'write');
+     * console.log(`Wrote ${written} samples`);
      *
-     * // Interleaved format (single buffer)
-     * const interleavedBuffer = Buffer.alloc(frameSize * 2 * 2); // stereo s16
-     * const written2 = await fifo.write(interleavedBuffer, frameSize);
+     * // Interleaved format (e.g., S16) - single buffer
+     * const interleavedData = Buffer.alloc(1024 * 2 * 2);  // 1024 stereo S16 samples
+     * const written2 = await fifo.write(interleavedData, 1024);
      * FFmpegError.throwIfError(written2, 'write');
      * ```
      *
-     * @see {@link read} To read samples from FIFO
+     * @see {@link read} To retrieve samples from FIFO
+     * @see {@link space} To check available space
      */
     async write(data, nbSamples) {
-        return this.native.write(data, nbSamples);
+        return await this.native.write(data, nbSamples);
     }
     /**
-     * Read data from an AVAudioFifo.
+     * Read and remove samples from the FIFO.
      *
-     * Reads and removes samples from the FIFO buffer.
-     * Reads up to nb_samples or the available amount, whichever is less.
+     * Reads up to the specified number of samples from the FIFO.
+     * The samples are removed from the FIFO after reading.
+     * Buffers must be pre-allocated with sufficient size.
      *
-     * Direct mapping to av_audio_fifo_read()
+     * Direct mapping to av_audio_fifo_read().
      *
-     * @param data - Audio buffer(s) to read into.
-     *               For planar formats: array of buffers (one per channel).
-     *               For interleaved formats: single buffer.
-     *               Buffers must be pre-allocated with sufficient size.
-     * @param nbSamples - Number of samples to read
+     * @param data - Pre-allocated buffer(s) to read into. Array for planar, single Buffer for interleaved
+     * @param nbSamples - Maximum number of samples to read
      *
-     * @returns Number of samples actually read, or negative AVERROR on error:
-     *   - >=0: Number of samples read
-     *   - AVERROR(EINVAL): Invalid parameters
+     * @returns Number of samples read, or negative AVERROR:
+     *   - AVERROR_EINVAL: Invalid parameters
      *
      * @example
      * ```typescript
      * import { FFmpegError } from 'node-av';
      *
-     * // Planar format (separate buffers per channel)
-     * const leftChannel = Buffer.alloc(frameSize * 4);  // float32
-     * const rightChannel = Buffer.alloc(frameSize * 4);
-     * const read = await fifo.read([leftChannel, rightChannel], frameSize);
-     * FFmpegError.throwIfError(read, 'read');
-     *
-     * // Interleaved format (single buffer)
-     * const interleavedBuffer = Buffer.alloc(frameSize * 2 * 2); // stereo s16
-     * const read2 = await fifo.read(interleavedBuffer, frameSize);
-     * FFmpegError.throwIfError(read2, 'read');
+     * // Check available samples
+     * const available = fifo.size;
+     * if (available >= 1024) {
+     *   // Planar format
+     *   const leftOut = Buffer.alloc(1024 * 4);
+     *   const rightOut = Buffer.alloc(1024 * 4);
+     *   const read = await fifo.read([leftOut, rightOut], 1024);
+     *   FFmpegError.throwIfError(read, 'read');
+     *   console.log(`Read ${read} samples`);
+     * }
      * ```
      *
      * @see {@link peek} To read without removing
-     * @see {@link write} To write samples to FIFO
+     * @see {@link size} To check available samples
      */
     async read(data, nbSamples) {
-        return this.native.read(data, nbSamples);
+        return await this.native.read(data, nbSamples);
     }
     /**
-     * Peek data from an AVAudioFifo.
+     * Read samples from the FIFO without removing them.
      *
-     * Reads samples from the FIFO without removing them.
-     * Useful for inspecting upcoming data.
+     * Similar to read() but leaves the samples in the FIFO.
+     * Useful for inspecting upcoming data without consuming it.
      *
-     * Direct mapping to av_audio_fifo_peek()
+     * Direct mapping to av_audio_fifo_peek().
      *
-     * @param data - Audio buffer(s) to peek into.
-     *               For planar formats: array of buffers (one per channel).
-     *               For interleaved formats: single buffer.
-     *               Buffers must be pre-allocated.
-     * @param nbSamples - Number of samples to peek
+     * @param data - Pre-allocated buffer(s) to peek into. Array for planar, single Buffer for interleaved
+     * @param nbSamples - Maximum number of samples to peek
      *
-     * @returns Number of samples actually peeked, or negative AVERROR on error:
-     *   - >=0: Number of samples peeked
-     *   - AVERROR(EINVAL): Invalid parameters
+     * @returns Number of samples peeked, or negative AVERROR:
+     *   - AVERROR_EINVAL: Invalid parameters
      *
      * @example
      * ```typescript
      * import { FFmpegError } from 'node-av';
      *
      * // Peek at next samples without removing them
-     * const peekBuffer = Buffer.alloc(frameSize * 4);
-     * const peeked = await fifo.peek(peekBuffer, frameSize);
+     * const peekBuffer = Buffer.alloc(256 * 4);
+     * const peeked = await fifo.peek(peekBuffer, 256);
      * FFmpegError.throwIfError(peeked, 'peek');
-     * // Samples are still in FIFO after peek
+     *
+     * // Samples are still in FIFO
+     * console.log(`FIFO still has ${fifo.size} samples`);
      * ```
      *
      * @see {@link read} To read and remove samples
      */
     async peek(data, nbSamples) {
-        return this.native.peek(data, nbSamples);
+        return await this.native.peek(data, nbSamples);
     }
     /**
      * Remove samples from the FIFO without reading them.
@@ -270,58 +225,64 @@ export class AudioFifo {
      * Discards the specified number of samples from the FIFO.
      * Useful for skipping unwanted audio data.
      *
-     * Direct mapping to av_audio_fifo_drain()
+     * Direct mapping to av_audio_fifo_drain().
      *
-     * @param nbSamples - Number of samples to drain
+     * @param nbSamples - Number of samples to discard
      *
      * @example
      * ```typescript
-     * // Skip next 100 samples
+     * // Skip 100 samples
      * fifo.drain(100);
+     * console.log(`FIFO now has ${fifo.size} samples`);
      * ```
+     *
+     * @see {@link reset} To remove all samples
      */
     drain(nbSamples) {
         this.native.drain(nbSamples);
     }
     /**
-     * Reset the AVAudioFifo buffer.
+     * Remove all samples from the FIFO.
      *
-     * Empties all data in the FIFO without deallocating the buffer.
-     * The FIFO remains allocated and ready for use.
+     * Empties the FIFO buffer without deallocating it.
+     * The FIFO remains allocated and ready for new data.
      *
-     * Direct mapping to av_audio_fifo_reset()
+     * Direct mapping to av_audio_fifo_reset().
      *
      * @example
      * ```typescript
      * fifo.reset();
-     * // FIFO is now empty but still allocated
+     * console.log(fifo.size);  // 0
+     * console.log(fifo.space); // Original allocation size
      * ```
+     *
+     * @see {@link drain} To remove specific number of samples
      */
     reset() {
         this.native.reset();
     }
     /**
-     * Reallocate an AVAudioFifo to a new size.
+     * Resize the FIFO buffer.
      *
-     * Changes the size of the FIFO buffer.
-     * Can be used to grow or shrink the buffer.
+     * Changes the allocated size of the FIFO. Can grow or shrink the buffer.
+     * Existing samples are preserved up to the new size.
      *
-     * Direct mapping to av_audio_fifo_realloc()
+     * Direct mapping to av_audio_fifo_realloc().
      *
-     * @param nbSamples - New allocation size, in samples
+     * @param nbSamples - New allocation size in samples
      *
      * @returns 0 on success, negative AVERROR on error:
-     *   - 0: Success
-     *   - AVERROR(EINVAL): Invalid parameters
-     *   - AVERROR(ENOMEM): Memory allocation failure
+     *   - AVERROR_EINVAL: Invalid size
+     *   - AVERROR_ENOMEM: Memory allocation failure
      *
      * @example
      * ```typescript
      * import { FFmpegError } from 'node-av';
      *
-     * // Increase FIFO capacity
-     * const ret = fifo.realloc(8192);
+     * // Grow FIFO to handle larger buffers
+     * const ret = fifo.realloc(16384);
      * FFmpegError.throwIfError(ret, 'realloc');
+     * console.log(`New space: ${fifo.space} samples`);
      * ```
      *
      * @see {@link alloc} For initial allocation
@@ -330,10 +291,11 @@ export class AudioFifo {
         return this.native.realloc(nbSamples);
     }
     /**
-     * Get the native FFmpeg AVAudioFifo pointer.
+     * Get the underlying native AudioFifo object.
+     *
+     * @returns The native AudioFifo binding object
      *
-     * @internal For use by other wrapper classes
-     * @returns The underlying native AudioFifo object
+     * @internal
      */
     getNative() {
         return this.native;
@@ -346,17 +308,12 @@ export class AudioFifo {
      *
      * @example
      * ```typescript
-     * import { AudioFifo } from 'node-av';
-     * import { AV_SAMPLE_FMT_S16 } from 'node-av/constants';
-     *
      * {
      *   using fifo = new AudioFifo();
-     *   fifo.alloc(AV_SAMPLE_FMT_S16, 2, 1024);
-     *   // ... use FIFO
+     *   fifo.alloc(AV_SAMPLE_FMT_FLTP, 2, 4096);
+     *   // Use fifo...
      * } // Automatically freed when leaving scope
      * ```
-     *
-     * @see {@link free} For manual cleanup
      */
     [Symbol.dispose]() {
         this.native[Symbol.dispose]();

package/dist/lib/audio-fifo.js.map

@@ -1 +1 @@
-{"version":3,"file":"audio-fifo.js","sourceRoot":"","sources":["../../src/lib/audio-fifo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAKxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,OAAO,SAAS;IACZ,MAAM,CAAkB;IAEhC;;;;;;;;;;;;;;;;;OAiBG;IACH;QACE,IAAI,CAAC,MAAM,GAAG,IAAI,QAAQ,CAAC,SAAS,EAAE,CAAC;IACzC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IAC1B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;IAC3B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,KAAK,CAAC,SAAyB,EAAE,QAAgB,EAAE,SAAiB;QAClE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,IAAI;QACF,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACrB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,KAAK,CAAC,KAAK,CAAC,IAAuB,EAAE,SAAiB;QACpD,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,KAAK,CAAC,IAAI,CAAC,IAAuB,EAAE,SAAiB;QACnD,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,KAAK,CAAC,IAAI,CAAC,IAAuB,EAAE,SAAiB;QACnD,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,SAAiB;QACrB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,KAAK;QACH,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO,CAAC,SAAiB;QACvB,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC;QACd,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;IAChC,CAAC;CACF"}
+{"version":3,"file":"audio-fifo.js","sourceRoot":"","sources":["../../src/lib/audio-fifo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAKxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,OAAO,SAAS;IACZ,MAAM,CAAkB;IAEhC;QACE,IAAI,CAAC,MAAM,GAAG,IAAI,QAAQ,CAAC,SAAS,EAAE,CAAC;IACzC,CAAC;IAED;;;;OAIG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IAC1B,CAAC;IAED;;;;OAIG;IACH,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;IAC3B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,KAAK,CAAC,SAAyB,EAAE,QAAgB,EAAE,SAAiB;QAClE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,IAAI;QACF,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;IACrB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,KAAK,CAAC,KAAK,CAAC,IAAuB,EAAE,SAAiB;QACpD,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAClD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,KAAK,CAAC,IAAI,CAAC,IAAuB,EAAE,SAAiB;QACnD,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IACjD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,KAAK,CAAC,IAAI,CAAC,IAAuB,EAAE,SAAiB;QACnD,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IACjD,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CAAC,SAAiB;QACrB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK;QACH,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO,CAAC,SAAiB;QACvB,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;OAMG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC;QACd,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;IAChC,CAAC;CACF"}

package/dist/lib/binding.d.ts

@@ -153,6 +153,7 @@ export interface NativeBinding {
     avGetPackedSampleFmt: (sampleFmt: AVSampleFormat) => AVSampleFormat;
     avGetPlanarSampleFmt: (sampleFmt: AVSampleFormat) => AVSampleFormat;
     avSampleFmtIsPlanar: (sampleFmt: AVSampleFormat) => boolean;
+    avGetCodecName: (codecId: AVCodecID) => string | null;
     avGetPixFmtName: (pixFmt: AVPixelFormat) => string | null;
     avGetPixFmtFromName: (name: string) => AVPixelFormat;
     avIsHardwarePixelFormat: (pixFmt: AVPixelFormat) => boolean;

package/dist/lib/binding.js

@@ -10,6 +10,13 @@ import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+/**
+ * Load the native binding
+ *
+ * @returns The loaded native binding interface
+ *
+ * @internal
+ */
 function loadBinding() {
     const require = createRequire(import.meta.url);
     const errors = [];

package/dist/lib/binding.js.map

@@ -1 +1 @@
-{"version":3,"file":"binding.js","sourceRoot":"","sources":["../../src/lib/binding.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAoCzC,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AA+OtC,SAAS,WAAW;IAClB,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC/C,MAAM,MAAM,GAAY,EAAE,CAAC;IAE3B,kBAAkB;IAClB,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAClC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC1B,MAAM,YAAY,GAAG,GAAG,QAAQ,IAAI,IAAI,EAAE,CAAC;IAE3C,8CAA8C;IAC9C,IAAI,CAAC;QACH,MAAM,WAAW,GAAG,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QACvF,MAAM,UAAU,GAAG,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;QAC5E,MAAM,QAAQ,GAAG,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;QAChE,MAAM,SAAS,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;QACtD,KAAK,MAAM,IAAI,IAAI,SAAS,EAAE,CAAC;YAC7B,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;gBACrB,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,4CAA4C,GAAG,EAAE,CAAC,CAAC,CAAC;IAC5E,CAAC;IAED,mDAAmD;IACnD,IAAI,CAAC;QACH,MAAM,WAAW,GAAG,kBAAkB,YAAY,EAAE,CAAC;QACrD,OAAO,OAAO,CAAC,GAAG,WAAW,eAAe,CAAC,CAAC;IAChD,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,iDAAiD,GAAG,EAAE,CAAC,CAAC,CAAC;IACjF,CAAC;IAED,sBAAsB;IACtB,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChE,kBAAkB;IAClB,MAAM,IAAI,KAAK,CACb,iDAAiD,YAAY,KAAK;QAClE,2BAA2B,aAAa,MAAM,CAC/C,CAAC;AACJ,CAAC;AAED,8CAA8C;AAC9C,MAAM,QAAQ,GAAG,WAAW,EAAE,CAAC;AAE/B,OAAO,EAAE,QAAQ,EAAE,CAAC"}
+{"version":3,"file":"binding.js","sourceRoot":"","sources":["../../src/lib/binding.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAoCzC,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAgPtC;;;;;;GAMG;AACH,SAAS,WAAW;IAClB,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC/C,MAAM,MAAM,GAAY,EAAE,CAAC;IAE3B,kBAAkB;IAClB,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAClC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC1B,MAAM,YAAY,GAAG,GAAG,QAAQ,IAAI,IAAI,EAAE,CAAC;IAE3C,8CAA8C;IAC9C,IAAI,CAAC;QACH,MAAM,WAAW,GAAG,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QACvF,MAAM,UAAU,GAAG,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;QAC5E,MAAM,QAAQ,GAAG,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;QAChE,MAAM,SAAS,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;QACtD,KAAK,MAAM,IAAI,IAAI,SAAS,EAAE,CAAC;YAC7B,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;gBACrB,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,4CAA4C,GAAG,EAAE,CAAC,CAAC,CAAC;IAC5E,CAAC;IAED,mDAAmD;IACnD,IAAI,CAAC;QACH,MAAM,WAAW,GAAG,kBAAkB,YAAY,EAAE,CAAC;QACrD,OAAO,OAAO,CAAC,GAAG,WAAW,eAAe,CAAC,CAAC;IAChD,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,iDAAiD,GAAG,EAAE,CAAC,CAAC,CAAC;IACjF,CAAC;IAED,sBAAsB;IACtB,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChE,kBAAkB;IAClB,MAAM,IAAI,KAAK,CACb,iDAAiD,YAAY,KAAK;QAClE,2BAA2B,aAAa,MAAM,CAC/C,CAAC;AACJ,CAAC;AAED,8CAA8C;AAC9C,MAAM,QAAQ,GAAG,WAAW,EAAE,CAAC;AAE/B,OAAO,EAAE,QAAQ,EAAE,CAAC"}