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

package/dist/api/utilities/image.d.ts

@@ -0,0 +1,207 @@
+import type { AVPixelFormat } from '../../constants/index.js';
+/**
+ * Image buffer allocation result.
+ */
+export interface ImageAllocation {
+    /** Allocated buffer containing the image data */
+    buffer: Buffer;
+    /** Total size in bytes */
+    size: number;
+    /** Line sizes for each plane */
+    linesizes: number[];
+}
+/**
+ * Image buffer utilities.
+ *
+ * Provides static methods for allocating, copying, and managing image buffers.
+ * These utilities handle the low-level memory layout for various pixel formats,
+ * including planar formats with multiple buffers.
+ *
+ * @example
+ * ```typescript
+ * import { ImageUtils } from 'node-av';
+ * import { AV_PIX_FMT_YUV420P, AV_PIX_FMT_RGB24 } from 'node-av/constants';
+ *
+ * // Allocate image buffer
+ * const image = ImageUtils.alloc(1920, 1080, AV_PIX_FMT_YUV420P, 32);
+ * console.log(`Allocated ${image.size} bytes`);
+ *
+ * // Get buffer size without allocating
+ * const size = ImageUtils.getBufferSize(AV_PIX_FMT_RGB24, 1920, 1080, 1);
+ * console.log(`RGB24 1080p needs ${size} bytes`);
+ * ```
+ */
+export declare class ImageUtils {
+    private constructor();
+    /**
+     * Allocate an image buffer.
+     *
+     * Allocates a buffer large enough to hold an image with the specified dimensions
+     * and pixel format. Returns the buffer along with line sizes for each plane.
+     * Direct mapping to av_image_alloc()
+     *
+     * @param width - Image width in pixels
+     *
+     * @param height - Image height in pixels
+     *
+     * @param pixFmt - Pixel format
+     *
+     * @param align - Buffer alignment (typically 1, 16, or 32)
+     *
+     * @returns Allocation result with buffer, size, and line sizes
+     *
+     * @throws {FFmpegError} On allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { ImageUtils } from 'node-av';
+     * import { AV_PIX_FMT_YUV420P } from 'node-av/constants';
+     *
+     * // Allocate aligned buffer for YUV420P image
+     * const image = ImageUtils.alloc(1920, 1080, AV_PIX_FMT_YUV420P, 32);
+     * console.log(`Buffer size: ${image.size} bytes`);
+     * console.log(`Y plane line size: ${image.linesizes[0]}`);
+     * console.log(`U plane line size: ${image.linesizes[1]}`);
+     * console.log(`V plane line size: ${image.linesizes[2]}`);
+     * ```
+     */
+    static alloc(width: number, height: number, pixFmt: AVPixelFormat, align: number): ImageAllocation;
+    /**
+     * Allocate image buffer arrays (alternative interface).
+     *
+     * Similar to alloc() but with a different return format.
+     * This is an alias for compatibility.
+     *
+     * @param width - Image width in pixels
+     *
+     * @param height - Image height in pixels
+     *
+     * @param pixFmt - Pixel format
+     *
+     * @param align - Buffer alignment
+     *
+     * @returns Allocation result
+     *
+     * @throws {FFmpegError} On allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { ImageUtils } from 'node-av';
+     * import { AV_PIX_FMT_YUV420P } from 'node-av/constants';
+     *
+     * // Allocate image buffer using allocArrays
+     * const image = ImageUtils.allocArrays(1920, 1080, AV_PIX_FMT_YUV420P, 32);
+     * console.log(`Allocated ${image.size} bytes`);
+     * ```
+     */
+    static allocArrays(width: number, height: number, pixFmt: AVPixelFormat, align: number): ImageAllocation;
+    /**
+     * Copy image data between buffers.
+     *
+     * Copies image data from source buffers to destination buffers.
+     * Direct mapping to av_image_copy2()
+     *
+     * @param dstData - Destination data buffers (one per plane)
+     *
+     * @param dstLinesizes - Destination line sizes
+     *
+     * @param srcData - Source data buffers (one per plane)
+     *
+     * @param srcLinesizes - Source line sizes
+     *
+     * @param pixFmt - Pixel format
+     *
+     * @param width - Image width
+     *
+     * @param height - Image height
+     *
+     * @example
+     * ```typescript
+     * import { ImageUtils } from 'node-av';
+     * import { AV_PIX_FMT_YUV420P } from 'node-av/constants';
+     *
+     * // Copy between two image buffers
+     * ImageUtils.copy(
+     *   dstBuffers, dstLinesizes,
+     *   srcBuffers, srcLinesizes,
+     *   AV_PIX_FMT_YUV420P, 1920, 1080
+     * );
+     * ```
+     */
+    static copy(dstData: Buffer[], dstLinesizes: number[], srcData: Buffer[], srcLinesizes: number[], pixFmt: AVPixelFormat, width: number, height: number): void;
+    /**
+     * Get required buffer size for an image.
+     *
+     * Calculates the buffer size needed to store an image with the given parameters.
+     * Direct mapping to av_image_get_buffer_size()
+     *
+     * @param pixFmt - Pixel format
+     *
+     * @param width - Image width
+     *
+     * @param height - Image height
+     *
+     * @param align - Buffer alignment
+     *
+     * @returns Required buffer size in bytes
+     *
+     * @example
+     * ```typescript
+     * import { ImageUtils } from 'node-av';
+     * import { AV_PIX_FMT_RGB24, AV_PIX_FMT_YUV420P } from 'node-av/constants';
+     *
+     * // Calculate buffer sizes for different formats
+     * const rgbSize = ImageUtils.getBufferSize(AV_PIX_FMT_RGB24, 1920, 1080, 1);
+     * const yuvSize = ImageUtils.getBufferSize(AV_PIX_FMT_YUV420P, 1920, 1080, 1);
+     *
+     * console.log(`RGB24: ${rgbSize} bytes`);   // 1920*1080*3
+     * console.log(`YUV420P: ${yuvSize} bytes`); // 1920*1080*1.5
+     * ```
+     */
+    static getBufferSize(pixFmt: AVPixelFormat, width: number, height: number, align: number): number;
+    /**
+     * Copy image to a single buffer.
+     *
+     * Copies image data from multiple plane buffers to a single contiguous buffer.
+     * Useful for serialization or when a single buffer is required.
+     * Direct mapping to av_image_copy_to_buffer()
+     *
+     * @param dst - Destination buffer
+     *
+     * @param dstSize - Destination buffer size
+     *
+     * @param srcData - Source data buffers (one per plane), or null
+     *
+     * @param srcLinesize - Source line sizes, or null
+     *
+     * @param pixFmt - Pixel format
+     *
+     * @param width - Image width
+     *
+     * @param height - Image height
+     *
+     * @param align - Buffer alignment
+     *
+     * @returns Bytes written, or negative error code
+     *
+     * @example
+     * ```typescript
+     * import { ImageUtils, FFmpegError } from 'node-av';
+     * import { AV_PIX_FMT_YUV420P } from 'node-av/constants';
+     *
+     * // Copy planar data to single buffer
+     * const dstSize = ImageUtils.getBufferSize(AV_PIX_FMT_YUV420P, 1920, 1080, 1);
+     * const dst = Buffer.alloc(dstSize);
+     *
+     * const written = ImageUtils.copyToBuffer(
+     *   dst, dstSize,
+     *   srcBuffers, srcLinesizes,
+     *   AV_PIX_FMT_YUV420P, 1920, 1080, 1
+     * );
+     *
+     * FFmpegError.throwIfError(written, 'Failed to copy image to buffer');
+     * console.log(`Wrote ${written} bytes`);
+     * ```
+     */
+    static copyToBuffer(dst: Buffer, dstSize: number, srcData: Buffer[] | null, srcLinesize: number[] | null, pixFmt: AVPixelFormat, width: number, height: number, align: number): number;
+}

package/dist/api/utilities/image.js

@@ -0,0 +1,213 @@
+import { bindings } from '../../lib/binding.js';
+import { FFmpegError } from '../../lib/error.js';
+/**
+ * Image buffer utilities.
+ *
+ * Provides static methods for allocating, copying, and managing image buffers.
+ * These utilities handle the low-level memory layout for various pixel formats,
+ * including planar formats with multiple buffers.
+ *
+ * @example
+ * ```typescript
+ * import { ImageUtils } from 'node-av';
+ * import { AV_PIX_FMT_YUV420P, AV_PIX_FMT_RGB24 } from 'node-av/constants';
+ *
+ * // Allocate image buffer
+ * const image = ImageUtils.alloc(1920, 1080, AV_PIX_FMT_YUV420P, 32);
+ * console.log(`Allocated ${image.size} bytes`);
+ *
+ * // Get buffer size without allocating
+ * const size = ImageUtils.getBufferSize(AV_PIX_FMT_RGB24, 1920, 1080, 1);
+ * console.log(`RGB24 1080p needs ${size} bytes`);
+ * ```
+ */
+export class ImageUtils {
+    // Private constructor to prevent instantiation
+    constructor() { }
+    /**
+     * Allocate an image buffer.
+     *
+     * Allocates a buffer large enough to hold an image with the specified dimensions
+     * and pixel format. Returns the buffer along with line sizes for each plane.
+     * Direct mapping to av_image_alloc()
+     *
+     * @param width - Image width in pixels
+     *
+     * @param height - Image height in pixels
+     *
+     * @param pixFmt - Pixel format
+     *
+     * @param align - Buffer alignment (typically 1, 16, or 32)
+     *
+     * @returns Allocation result with buffer, size, and line sizes
+     *
+     * @throws {FFmpegError} On allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { ImageUtils } from 'node-av';
+     * import { AV_PIX_FMT_YUV420P } from 'node-av/constants';
+     *
+     * // Allocate aligned buffer for YUV420P image
+     * const image = ImageUtils.alloc(1920, 1080, AV_PIX_FMT_YUV420P, 32);
+     * console.log(`Buffer size: ${image.size} bytes`);
+     * console.log(`Y plane line size: ${image.linesizes[0]}`);
+     * console.log(`U plane line size: ${image.linesizes[1]}`);
+     * console.log(`V plane line size: ${image.linesizes[2]}`);
+     * ```
+     */
+    static alloc(width, height, pixFmt, align) {
+        const result = bindings.avImageAlloc(width, height, pixFmt, align);
+        if (typeof result === 'number') {
+            FFmpegError.throwIfError(result, 'Failed to allocate image');
+        }
+        return result;
+    }
+    /**
+     * Allocate image buffer arrays (alternative interface).
+     *
+     * Similar to alloc() but with a different return format.
+     * This is an alias for compatibility.
+     *
+     * @param width - Image width in pixels
+     *
+     * @param height - Image height in pixels
+     *
+     * @param pixFmt - Pixel format
+     *
+     * @param align - Buffer alignment
+     *
+     * @returns Allocation result
+     *
+     * @throws {FFmpegError} On allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { ImageUtils } from 'node-av';
+     * import { AV_PIX_FMT_YUV420P } from 'node-av/constants';
+     *
+     * // Allocate image buffer using allocArrays
+     * const image = ImageUtils.allocArrays(1920, 1080, AV_PIX_FMT_YUV420P, 32);
+     * console.log(`Allocated ${image.size} bytes`);
+     * ```
+     */
+    static allocArrays(width, height, pixFmt, align) {
+        return ImageUtils.alloc(width, height, pixFmt, align);
+    }
+    /**
+     * Copy image data between buffers.
+     *
+     * Copies image data from source buffers to destination buffers.
+     * Direct mapping to av_image_copy2()
+     *
+     * @param dstData - Destination data buffers (one per plane)
+     *
+     * @param dstLinesizes - Destination line sizes
+     *
+     * @param srcData - Source data buffers (one per plane)
+     *
+     * @param srcLinesizes - Source line sizes
+     *
+     * @param pixFmt - Pixel format
+     *
+     * @param width - Image width
+     *
+     * @param height - Image height
+     *
+     * @example
+     * ```typescript
+     * import { ImageUtils } from 'node-av';
+     * import { AV_PIX_FMT_YUV420P } from 'node-av/constants';
+     *
+     * // Copy between two image buffers
+     * ImageUtils.copy(
+     *   dstBuffers, dstLinesizes,
+     *   srcBuffers, srcLinesizes,
+     *   AV_PIX_FMT_YUV420P, 1920, 1080
+     * );
+     * ```
+     */
+    static copy(dstData, dstLinesizes, srcData, srcLinesizes, pixFmt, width, height) {
+        bindings.avImageCopy2(dstData, dstLinesizes, srcData, srcLinesizes, pixFmt, width, height);
+    }
+    /**
+     * Get required buffer size for an image.
+     *
+     * Calculates the buffer size needed to store an image with the given parameters.
+     * Direct mapping to av_image_get_buffer_size()
+     *
+     * @param pixFmt - Pixel format
+     *
+     * @param width - Image width
+     *
+     * @param height - Image height
+     *
+     * @param align - Buffer alignment
+     *
+     * @returns Required buffer size in bytes
+     *
+     * @example
+     * ```typescript
+     * import { ImageUtils } from 'node-av';
+     * import { AV_PIX_FMT_RGB24, AV_PIX_FMT_YUV420P } from 'node-av/constants';
+     *
+     * // Calculate buffer sizes for different formats
+     * const rgbSize = ImageUtils.getBufferSize(AV_PIX_FMT_RGB24, 1920, 1080, 1);
+     * const yuvSize = ImageUtils.getBufferSize(AV_PIX_FMT_YUV420P, 1920, 1080, 1);
+     *
+     * console.log(`RGB24: ${rgbSize} bytes`);   // 1920*1080*3
+     * console.log(`YUV420P: ${yuvSize} bytes`); // 1920*1080*1.5
+     * ```
+     */
+    static getBufferSize(pixFmt, width, height, align) {
+        return bindings.avImageGetBufferSize(pixFmt, width, height, align);
+    }
+    /**
+     * Copy image to a single buffer.
+     *
+     * Copies image data from multiple plane buffers to a single contiguous buffer.
+     * Useful for serialization or when a single buffer is required.
+     * Direct mapping to av_image_copy_to_buffer()
+     *
+     * @param dst - Destination buffer
+     *
+     * @param dstSize - Destination buffer size
+     *
+     * @param srcData - Source data buffers (one per plane), or null
+     *
+     * @param srcLinesize - Source line sizes, or null
+     *
+     * @param pixFmt - Pixel format
+     *
+     * @param width - Image width
+     *
+     * @param height - Image height
+     *
+     * @param align - Buffer alignment
+     *
+     * @returns Bytes written, or negative error code
+     *
+     * @example
+     * ```typescript
+     * import { ImageUtils, FFmpegError } from 'node-av';
+     * import { AV_PIX_FMT_YUV420P } from 'node-av/constants';
+     *
+     * // Copy planar data to single buffer
+     * const dstSize = ImageUtils.getBufferSize(AV_PIX_FMT_YUV420P, 1920, 1080, 1);
+     * const dst = Buffer.alloc(dstSize);
+     *
+     * const written = ImageUtils.copyToBuffer(
+     *   dst, dstSize,
+     *   srcBuffers, srcLinesizes,
+     *   AV_PIX_FMT_YUV420P, 1920, 1080, 1
+     * );
+     *
+     * FFmpegError.throwIfError(written, 'Failed to copy image to buffer');
+     * console.log(`Wrote ${written} bytes`);
+     * ```
+     */
+    static copyToBuffer(dst, dstSize, srcData, srcLinesize, pixFmt, width, height, align) {
+        return bindings.avImageCopyToBuffer(dst, dstSize, srcData, srcLinesize, pixFmt, width, height, align);
+    }
+}
+//# sourceMappingURL=image.js.map

package/dist/api/utilities/image.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.js","sourceRoot":"","sources":["../../../src/api/utilities/image.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAgBjD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,OAAO,UAAU;IACrB,+CAA+C;IAC/C,gBAAuB,CAAC;IAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,MAAM,CAAC,KAAK,CAAC,KAAa,EAAE,MAAc,EAAE,MAAqB,EAAE,KAAa;QAC9E,MAAM,MAAM,GAAG,QAAQ,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;QACnE,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC/B,WAAW,CAAC,YAAY,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;QAC/D,CAAC;QACD,OAAO,MAAyB,CAAC;IACnC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,MAAM,CAAC,WAAW,CAAC,KAAa,EAAE,MAAc,EAAE,MAAqB,EAAE,KAAa;QACpF,OAAO,UAAU,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IACxD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,MAAM,CAAC,IAAI,CAAC,OAAiB,EAAE,YAAsB,EAAE,OAAiB,EAAE,YAAsB,EAAE,MAAqB,EAAE,KAAa,EAAE,MAAc;QACpJ,QAAQ,CAAC,YAAY,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IAC7F,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,MAAM,CAAC,aAAa,CAAC,MAAqB,EAAE,KAAa,EAAE,MAAc,EAAE,KAAa;QACtF,OAAO,QAAQ,CAAC,oBAAoB,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IACrE,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,MAAM,CAAC,YAAY,CACjB,GAAW,EACX,OAAe,EACf,OAAwB,EACxB,WAA4B,EAC5B,MAAqB,EACrB,KAAa,EACb,MAAc,EACd,KAAa;QAEb,OAAO,QAAQ,CAAC,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IACxG,CAAC;CACF"}

package/dist/api/utilities/index.d.ts

@@ -0,0 +1,14 @@
+export { AudioSampleUtils, type AudioSampleAllocation, type AudioSampleBufferSize } from './audio-sample.js';
+export { ChannelLayoutUtils } from './channel-layout.js';
+export { pickSupportedLayout, pickSupportedPixelFormat, pickSupportedRate, pickSupportedSampleFormat } from './codec-format.js';
+export type { ContextOptions } from './context-options.js';
+export { ImageUtils, type ImageAllocation } from './image.js';
+export { MediaTypeUtils } from './media-type.js';
+export { PixelFormatUtils } from './pixel-format.js';
+export { SampleFormatUtils } from './sample-format.js';
+export { TimestampUtils } from './timestamp.js';
+export { StreamingUtils } from './streaming.js';
+export { WHISPER_MODELS, WHISPER_VAD_MODELS, WhisperDownloader, type DownloadOptions, type WhisperModelName, type WhisperModelType, type WhisperVADModelName, } from './whisper-model.js';
+export { AsyncQueue } from './async-queue.js';
+export { Scheduler, SchedulerControl, type SchedulableComponent } from './scheduler.js';
+export { SharedTexture, type ImportHandleProps, type SharedTextureHandle, type SharedTextureOptions, type TextureColorSpace, type TextureFrameOptions, type TextureInfo, } from './electron-shared-texture.js';

package/dist/api/utilities/index.js

@@ -0,0 +1,27 @@
+// Audio
+export { AudioSampleUtils } from './audio-sample.js';
+// Channel Layouts
+export { ChannelLayoutUtils } from './channel-layout.js';
+// Codec-format negotiation
+export { pickSupportedLayout, pickSupportedPixelFormat, pickSupportedRate, pickSupportedSampleFormat } from './codec-format.js';
+// Image
+export { ImageUtils } from './image.js';
+// Media
+export { MediaTypeUtils } from './media-type.js';
+// Pixel Format
+export { PixelFormatUtils } from './pixel-format.js';
+// Sample Format
+export { SampleFormatUtils } from './sample-format.js';
+// Timestamp
+export { TimestampUtils } from './timestamp.js';
+// Streaming
+export { StreamingUtils } from './streaming.js';
+// Whisper Model Downloader
+export { WHISPER_MODELS, WHISPER_VAD_MODELS, WhisperDownloader, } from './whisper-model.js';
+// AsyncQueue
+export { AsyncQueue } from './async-queue.js';
+// Scheduler
+export { Scheduler, SchedulerControl } from './scheduler.js';
+// SharedTexture
+export { SharedTexture, } from './electron-shared-texture.js';
+//# sourceMappingURL=index.js.map

package/dist/api/utilities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/api/utilities/index.ts"],"names":[],"mappings":"AAAA,QAAQ;AACR,OAAO,EAAE,gBAAgB,EAA0D,MAAM,mBAAmB,CAAC;AAE7G,kBAAkB;AAClB,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEzD,2BAA2B;AAC3B,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAKhI,QAAQ;AACR,OAAO,EAAE,UAAU,EAAwB,MAAM,YAAY,CAAC;AAE9D,QAAQ;AACR,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD,eAAe;AACf,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD,gBAAgB;AAChB,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD,YAAY;AACZ,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEhD,YAAY;AACZ,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEhD,2BAA2B;AAC3B,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,iBAAiB,GAKlB,MAAM,oBAAoB,CAAC;AAE5B,aAAa;AACb,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,YAAY;AACZ,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAA6B,MAAM,gBAAgB,CAAC;AAExF,gBAAgB;AAChB,OAAO,EACL,aAAa,GAOd,MAAM,8BAA8B,CAAC"}

package/dist/api/utilities/live-decoding.d.ts

@@ -0,0 +1,15 @@
+import type { CodecContext } from '../../lib/codec-context.js';
+/**
+ * Choose low-latency threading for a live video decoder; a Decoder `configure` callback.
+ *
+ * Frame threading holds back one frame per thread before the first output, up to
+ * 16 with the automatic thread count (~0.6 s at 25 fps). Hardware decoding gets
+ * slice threading, which costs it nothing. Software decoding keeps frame threading
+ * with at most 4 threads: slice threading only splits a frame into its slices, and
+ * most cameras send one slice per frame, so it would decode on a single thread.
+ *
+ * @param context - Decoder context, before it is opened
+ *
+ * @internal
+ */
+export declare function configureLiveDecoderThreading(context: CodecContext): void;

package/dist/api/utilities/live-decoding.js

@@ -0,0 +1,32 @@
+import { availableParallelism } from 'node:os';
+import { FF_THREAD_SLICE } from '../../constants/constants.js';
+/**
+ * Most frame threads a live software decoder uses.
+ *
+ * @internal
+ */
+const MAX_LIVE_FRAME_THREADS = 4;
+/**
+ * Choose low-latency threading for a live video decoder; a Decoder `configure` callback.
+ *
+ * Frame threading holds back one frame per thread before the first output, up to
+ * 16 with the automatic thread count (~0.6 s at 25 fps). Hardware decoding gets
+ * slice threading, which costs it nothing. Software decoding keeps frame threading
+ * with at most 4 threads: slice threading only splits a frame into its slices, and
+ * most cameras send one slice per frame, so it would decode on a single thread.
+ *
+ * @param context - Decoder context, before it is opened
+ *
+ * @internal
+ */
+export function configureLiveDecoderThreading(context) {
+    // Decoder.create() set the device only if it decodes on it
+    if (context.hwDeviceCtx) {
+        context.threadType = FF_THREAD_SLICE;
+        return;
+    }
+    // Like FFmpeg's automatic count (CPUs + 1, a single thread on one CPU), capped
+    const cpus = availableParallelism();
+    context.threadCount = cpus > 1 ? Math.min(cpus + 1, MAX_LIVE_FRAME_THREADS) : 1;
+}
+//# sourceMappingURL=live-decoding.js.map

package/dist/api/utilities/live-decoding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-decoding.js","sourceRoot":"","sources":["../../../src/api/utilities/live-decoding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAI/D;;;;GAIG;AACH,MAAM,sBAAsB,GAAG,CAAC,CAAC;AAEjC;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,6BAA6B,CAAC,OAAqB;IACjE,2DAA2D;IAC3D,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;QACxB,OAAO,CAAC,UAAU,GAAG,eAAe,CAAC;QACrC,OAAO;IACT,CAAC;IAED,+EAA+E;IAC/E,MAAM,IAAI,GAAG,oBAAoB,EAAE,CAAC;IACpC,OAAO,CAAC,WAAW,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,EAAE,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAClF,CAAC"}

package/dist/api/utilities/media-type.d.ts

@@ -0,0 +1,49 @@
+import type { AVMediaType } from '../../constants/index.js';
+/**
+ * Media type utilities.
+ *
+ * Provides static methods for converting media type enum values to
+ * human-readable strings.
+ *
+ * @example
+ * ```typescript
+ * import { MediaType } from 'node-av';
+ * import { AVMEDIA_TYPE_VIDEO, AVMEDIA_TYPE_AUDIO } from 'node-av/constants';
+ *
+ * console.log(MediaType.getString(AVMEDIA_TYPE_VIDEO));      // "video"
+ * console.log(MediaType.getString(AVMEDIA_TYPE_AUDIO));      // "audio"
+ * console.log(MediaType.getString(AVMEDIA_TYPE_SUBTITLE));   // "subtitle"
+ * ```
+ */
+export declare class MediaTypeUtils {
+    private constructor();
+    /**
+     * Get string representation of media type.
+     *
+     * Converts a media type enum value to its string representation.
+     * Direct mapping to av_get_media_type_string()
+     *
+     * @param type - Media type enum value
+     *
+     * @returns String representation, or null for invalid type
+     *
+     * @example
+     * ```typescript
+     * import { MediaType } from 'node-av';
+     * import {
+     *   AVMEDIA_TYPE_VIDEO,
+     *   AVMEDIA_TYPE_AUDIO,
+     *   AVMEDIA_TYPE_DATA,
+     *   AVMEDIA_TYPE_SUBTITLE,
+     *   AVMEDIA_TYPE_ATTACHMENT
+     * } from 'node-av/constants';
+     *
+     * console.log(MediaType.getString(AVMEDIA_TYPE_VIDEO));      // "video"
+     * console.log(MediaType.getString(AVMEDIA_TYPE_AUDIO));      // "audio"
+     * console.log(MediaType.getString(AVMEDIA_TYPE_DATA));       // "data"
+     * console.log(MediaType.getString(AVMEDIA_TYPE_SUBTITLE));   // "subtitle"
+     * console.log(MediaType.getString(AVMEDIA_TYPE_ATTACHMENT)); // "attachment"
+     * ```
+     */
+    static getString(type: AVMediaType): string | null;
+}

package/dist/api/utilities/media-type.js

@@ -0,0 +1,53 @@
+import { bindings } from '../../lib/binding.js';
+/**
+ * Media type utilities.
+ *
+ * Provides static methods for converting media type enum values to
+ * human-readable strings.
+ *
+ * @example
+ * ```typescript
+ * import { MediaType } from 'node-av';
+ * import { AVMEDIA_TYPE_VIDEO, AVMEDIA_TYPE_AUDIO } from 'node-av/constants';
+ *
+ * console.log(MediaType.getString(AVMEDIA_TYPE_VIDEO));      // "video"
+ * console.log(MediaType.getString(AVMEDIA_TYPE_AUDIO));      // "audio"
+ * console.log(MediaType.getString(AVMEDIA_TYPE_SUBTITLE));   // "subtitle"
+ * ```
+ */
+export class MediaTypeUtils {
+    // Private constructor to prevent instantiation
+    constructor() { }
+    /**
+     * Get string representation of media type.
+     *
+     * Converts a media type enum value to its string representation.
+     * Direct mapping to av_get_media_type_string()
+     *
+     * @param type - Media type enum value
+     *
+     * @returns String representation, or null for invalid type
+     *
+     * @example
+     * ```typescript
+     * import { MediaType } from 'node-av';
+     * import {
+     *   AVMEDIA_TYPE_VIDEO,
+     *   AVMEDIA_TYPE_AUDIO,
+     *   AVMEDIA_TYPE_DATA,
+     *   AVMEDIA_TYPE_SUBTITLE,
+     *   AVMEDIA_TYPE_ATTACHMENT
+     * } from 'node-av/constants';
+     *
+     * console.log(MediaType.getString(AVMEDIA_TYPE_VIDEO));      // "video"
+     * console.log(MediaType.getString(AVMEDIA_TYPE_AUDIO));      // "audio"
+     * console.log(MediaType.getString(AVMEDIA_TYPE_DATA));       // "data"
+     * console.log(MediaType.getString(AVMEDIA_TYPE_SUBTITLE));   // "subtitle"
+     * console.log(MediaType.getString(AVMEDIA_TYPE_ATTACHMENT)); // "attachment"
+     * ```
+     */
+    static getString(type) {
+        return bindings.avGetMediaTypeString(type);
+    }
+}
+//# sourceMappingURL=media-type.js.map

package/dist/api/utilities/media-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-type.js","sourceRoot":"","sources":["../../../src/api/utilities/media-type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAIhD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,cAAc;IACzB,+CAA+C;IAC/C,gBAAuB,CAAC;IAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,MAAM,CAAC,SAAS,CAAC,IAAiB;QAChC,OAAO,QAAQ,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAC7C,CAAC;CACF"}