@revizly/node-av 5.2.2-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,12 @@
+export { AudioSampleUtils, type AudioSampleAllocation, type AudioSampleBufferSize } from './audio-sample.js';
+export { ChannelLayoutUtils } from './channel-layout.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 TextureFrameOptions, type TextureInfo, } from './electron-shared-texture.js';

package/dist/api/utilities/index.js

@@ -0,0 +1,25 @@
+// Audio
+export { AudioSampleUtils } from './audio-sample.js';
+// Channel Layouts
+export { ChannelLayoutUtils } from './channel-layout.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,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,GAMd,MAAM,8BAA8B,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"}

package/dist/api/utilities/pixel-format.d.ts

@@ -0,0 +1,89 @@
+import type { AVPixelFormat } from '../../constants/index.js';
+/**
+ * Video pixel format utilities.
+ *
+ * Provides static methods for querying pixel format properties, converting
+ * between format names and values, and checking hardware acceleration support.
+ *
+ * @example
+ * ```typescript
+ * import { PixelFormat } from 'node-av';
+ * import { AV_PIX_FMT_YUV420P, AV_PIX_FMT_CUDA } from 'node-av/constants';
+ *
+ * // Get format information
+ * console.log(PixelFormat.getName(AV_PIX_FMT_YUV420P));    // "yuv420p"
+ * console.log(PixelFormat.isHardware(AV_PIX_FMT_CUDA));    // true
+ *
+ * // Convert between names and values
+ * const format = PixelFormat.fromName("yuv420p");
+ * console.log(format === AV_PIX_FMT_YUV420P);              // true
+ * ```
+ */
+export declare class PixelFormatUtils {
+    private constructor();
+    /**
+     * Get the name of a pixel format.
+     *
+     * Returns a string describing the pixel format.
+     * Direct mapping to av_get_pix_fmt_name()
+     *
+     * @param format - Video pixel format
+     *
+     * @returns Format name string, or null for invalid format
+     *
+     * @example
+     * ```typescript
+     * import { PixelFormat } from 'node-av';
+     * import { AV_PIX_FMT_YUV420P, AV_PIX_FMT_RGB24 } from 'node-av/constants';
+     *
+     * console.log(PixelFormat.getName(AV_PIX_FMT_YUV420P)); // "yuv420p"
+     * console.log(PixelFormat.getName(AV_PIX_FMT_RGB24));   // "rgb24"
+     * ```
+     */
+    static getName(format: AVPixelFormat): string | null;
+    /**
+     * Get pixel format from name.
+     *
+     * Converts a pixel format name string to its enum value.
+     * Direct mapping to av_get_pix_fmt()
+     *
+     * @param name - Pixel format name string
+     *
+     * @returns Pixel format enum value, or AV_PIX_FMT_NONE for unknown formats
+     *
+     * @example
+     * ```typescript
+     * import { PixelFormat } from 'node-av';
+     * import { AV_PIX_FMT_YUV420P } from 'node-av/constants';
+     *
+     * const format = PixelFormat.fromName("yuv420p");
+     * console.log(format === AV_PIX_FMT_YUV420P); // true
+     *
+     * const invalid = PixelFormat.fromName("invalid");
+     * console.log(invalid === AV_PIX_FMT_NONE);   // true
+     * ```
+     */
+    static fromName(name: string): AVPixelFormat;
+    /**
+     * Check if pixel format is hardware accelerated.
+     *
+     * Returns true if the pixel format represents frames in GPU/hardware memory
+     * rather than system memory.
+     * Direct mapping to av_pix_fmt_desc_get() and checking for AV_PIX_FMT_FLAG_HWACCEL
+     *
+     * @param format - Video pixel format
+     *
+     * @returns True if format is hardware accelerated
+     *
+     * @example
+     * ```typescript
+     * import { PixelFormat } from 'node-av';
+     * import { AV_PIX_FMT_YUV420P, AV_PIX_FMT_CUDA, AV_PIX_FMT_VAAPI } from 'node-av/constants';
+     *
+     * console.log(PixelFormat.isHardware(AV_PIX_FMT_YUV420P)); // false
+     * console.log(PixelFormat.isHardware(AV_PIX_FMT_CUDA));    // true
+     * console.log(PixelFormat.isHardware(AV_PIX_FMT_VAAPI));   // true
+     * ```
+     */
+    static isHardware(format: AVPixelFormat): boolean;
+}