node-av 0.0.1

package/dist/lib/dictionary.js

@@ -0,0 +1,406 @@
+import { bindings } from './binding.js';
+import { AVFLAG_NONE } from './constants.js';
+/**
+ * Dictionary for options and metadata.
+ *
+ * Key-value storage for codec options, format options, and metadata.
+ * Used throughout FFmpeg for configuration and information storage.
+ * Supports parsing from strings and conversion back to strings.
+ *
+ * Direct mapping to FFmpeg's AVDictionary.
+ *
+ * @example
+ * ```typescript
+ * import { Dictionary, CodecContext, FFmpegError } from 'node-av';
+ *
+ * // Using Dictionary for codec options
+ * const options = new Dictionary();
+ * const ret1 = options.set('preset', 'fast', 0);
+ * FFmpegError.throwIfError(ret1, 'set preset');
+ * const ret2 = options.set('crf', '23', 0);
+ * FFmpegError.throwIfError(ret2, 'set crf');
+ *
+ * const codecContext = new CodecContext();
+ * codecContext.allocContext3(codec);
+ * const openRet = await codecContext.open2(codec, options);
+ * FFmpegError.throwIfError(openRet, 'open2');
+ *
+ * // Using Dictionary for format options
+ * const formatOptions = new Dictionary();
+ * const ret3 = formatOptions.set('movflags', 'faststart', 0);
+ * FFmpegError.throwIfError(ret3, 'set movflags');
+ * const headerRet = await formatContext.writeHeader(formatOptions);
+ * FFmpegError.throwIfError(headerRet, 'writeHeader');
+ *
+ * // Reading metadata
+ * const metadata = stream.metadata;
+ * if (metadata) {
+ *   const title = metadata.get('title', 0);
+ *   const artist = metadata.get('artist', 0);
+ *   console.log(`Title: ${title}, Artist: ${artist}`);
+ * }
+ *
+ * // Cleanup
+ * options.free();
+ * formatOptions.free();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { Dictionary, FFmpegError } from 'node-av';
+ *
+ * // Parsing options from string
+ * const dict = new Dictionary();
+ * const ret = dict.parseString('bitrate=128k:preset=fast', '=', ':', 0);
+ * FFmpegError.throwIfError(ret, 'parseString');
+ *
+ * // Getting all options as object
+ * const allOptions = dict.getAll();
+ * console.log(allOptions); // { bitrate: '128k', preset: 'fast' }
+ *
+ * // Converting back to string
+ * const str = dict.getString('=', ':');
+ * console.log(str); // "bitrate=128k:preset=fast"
+ *
+ * dict.free();
+ * ```
+ */
+export class Dictionary {
+    native;
+    /**
+     * Create a new dictionary.
+     *
+     * The dictionary is uninitialized and will be auto-allocated on first set() call.
+     * No FFmpeg resources are allocated until first use.
+     *
+     * Direct wrapper around AVDictionary.
+     *
+     * @example
+     * ```typescript
+     * import { Dictionary, FFmpegError } from 'node-av';
+     *
+     * const dict = new Dictionary();
+     * const ret = dict.set('key', 'value', 0); // Auto-allocates on first use
+     * FFmpegError.throwIfError(ret, 'set');
+     * ```
+     */
+    constructor() {
+        this.native = new bindings.Dictionary();
+    }
+    /**
+     * Create a Dictionary wrapper from an existing native dictionary.
+     * Used internally when wrapping dictionaries from FFmpeg.
+     * @internal
+     */
+    static fromNative(native) {
+        const dict = Object.create(Dictionary.prototype);
+        dict.native = native;
+        return dict;
+    }
+    /**
+     * Create a Dictionary from a JavaScript object.
+     *
+     * Converts a plain JavaScript object to a Dictionary.
+     * Useful for converting option objects to FFmpeg format.
+     *
+     * @param obj - Object with string key-value pairs
+     * @param flags - AV_DICT_* flags for set operations
+     *
+     * @returns New Dictionary containing all entries from the object
+     *
+     * @example
+     * ```typescript
+     * import { Dictionary } from 'node-av';
+     *
+     * const options = {
+     *   bitrate: '128k',
+     *   preset: 'fast',
+     *   crf: '23'
+     * };
+     *
+     * const dict = Dictionary.fromObject(options);
+     * // Use with codec or format context
+     * await codecContext.open2(codec, dict);
+     * dict.free();
+     * ```
+     */
+    static fromObject(obj, flags = AVFLAG_NONE) {
+        const dict = new Dictionary();
+        for (const [key, value] of Object.entries(obj)) {
+            dict.set(key, value, flags);
+        }
+        return dict;
+    }
+    /**
+     * Allocate a new dictionary.
+     *
+     * Usually not needed as set() will auto-allocate.
+     * This is mainly for compatibility - FFmpeg doesn't have explicit av_dict_alloc.
+     *
+     * @example
+     * ```typescript
+     * const dict = new Dictionary();
+     * dict.alloc(); // Explicit allocation (optional)
+     * ```
+     */
+    alloc() {
+        return this.native.alloc();
+    }
+    /**
+     * Free all the memory allocated for an AVDictionary struct and all keys and values.
+     *
+     * Direct mapping to av_dict_free()
+     * After calling this, the dictionary is empty and can be reused.
+     *
+     * @example
+     * ```typescript
+     * dict.free();
+     * // Dictionary is now empty and can be reused
+     * dict.set('new_key', 'new_value', 0);
+     * ```
+     */
+    free() {
+        return this.native.free();
+    }
+    /**
+     * Copy entries from this dictionary to destination.
+     *
+     * Copies all entries to the destination dictionary.
+     * Destination entries can be preserved or overwritten based on flags.
+     *
+     * Direct mapping to av_dict_copy()
+     *
+     * @param dst - Target dictionary to copy to
+     * @param flags - AV_DICT_* flags for the copy operation
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - 0: Success
+     *   - AVERROR(ENOMEM): Memory allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { Dictionary, FFmpegError } from 'node-av';
+     *
+     * const src = new Dictionary();
+     * src.set('key1', 'value1');
+     * src.set('key2', 'value2');
+     *
+     * const dst = new Dictionary();
+     * const ret = src.copy(dst);
+     * FFmpegError.throwIfError(ret, 'copy');
+     * ```
+     *
+     * @note Common flags:
+     * - AVFLAG_NONE: Default behavior
+     * - AV_DICT_DONT_OVERWRITE: Don't overwrite existing entries
+     * - AV_DICT_MULTIKEY: Allow multiple entries with same key
+     */
+    copy(dst, flags = AVFLAG_NONE) {
+        return this.native.copy(dst.getNative(), flags);
+    }
+    /**
+     * Set the given entry in the dictionary.
+     *
+     * Adds or modifies a key-value pair in the dictionary.
+     * If key or value are empty, the entry is deleted.
+     * The dictionary will be auto-allocated on first call if needed.
+     *
+     * Direct mapping to av_dict_set()
+     *
+     * @param key - Entry key to add/modify
+     * @param value - Entry value to add/modify
+     * @param flags - AV_DICT_* flags
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - 0: Success
+     *   - AVERROR(ENOMEM): Memory allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { Dictionary, FFmpegError } from 'node-av';
+     * import { AV_DICT_DONT_OVERWRITE } from 'node-av/constants';
+     *
+     * const ret1 = dict.set('bitrate', '128k');
+     * FFmpegError.throwIfError(ret1, 'set bitrate');
+     *
+     * const ret2 = dict.set('preset', 'fast', AV_DICT_DONT_OVERWRITE);
+     * FFmpegError.throwIfError(ret2, 'set preset');
+     *
+     * // Delete an entry
+     * dict.set('bitrate', '');
+     * ```
+     *
+     * @note Common flags:
+     * - AVFLAG_NONE: Default behavior (replace existing, copy strings)
+     * - AV_DICT_DONT_OVERWRITE: Don't overwrite existing entries
+     * - AV_DICT_APPEND: Append to existing value (with comma separator)
+     * - AV_DICT_MULTIKEY: Allow multiple entries with same key
+     * - AV_DICT_MATCH_CASE: Case sensitive key matching
+     */
+    set(key, value, flags = AVFLAG_NONE) {
+        return this.native.set(key, value, flags);
+    }
+    /**
+     * Get a dictionary entry with matching key.
+     *
+     * Direct mapping to av_dict_get()
+     *
+     * @param key - Key to search for
+     * @param flags - AV_DICT_* flags for matching
+     *
+     * @returns Entry value or null if not found
+     *
+     * @example
+     * ```typescript
+     * const value = dict.get('bitrate');
+     * if (value) {
+     *   console.log(`Bitrate: ${value}`);
+     * }
+     *
+     * // Case sensitive search
+     * const title = dict.get('Title', AV_DICT_MATCH_CASE);
+     * ```
+     *
+     * Common flags:
+     * - AVFLAG_NONE: Default (case insensitive)
+     * - AV_DICT_MATCH_CASE: Case sensitive matching
+     * - AV_DICT_IGNORE_SUFFIX: Match entries starting with key
+     */
+    get(key, flags = AVFLAG_NONE) {
+        return this.native.get(key, flags);
+    }
+    /**
+     * Get number of entries in dictionary.
+     *
+     * Direct mapping to av_dict_count()
+     *
+     * @returns Number of entries
+     *
+     * @example
+     * ```typescript
+     * const count = dict.count();
+     * console.log(`Dictionary has ${count} entries`);
+     * ```
+     */
+    count() {
+        return this.native.count();
+    }
+    /**
+     * Get all entries as a JavaScript object.
+     *
+     * Helper method for easier access from JavaScript.
+     * Internally iterates through all entries using av_dict_get().
+     *
+     * @returns Object with all key-value pairs
+     *
+     * @example
+     * ```typescript
+     * const allOptions = dict.getAll();
+     * for (const [key, value] of Object.entries(allOptions)) {
+     *   console.log(`${key}: ${value}`);
+     * }
+     *
+     * // Check if dictionary is empty
+     * if (Object.keys(dict.getAll()).length === 0) {
+     *   console.log('Dictionary is empty');
+     * }
+     * ```
+     */
+    getAll() {
+        return this.native.getAll();
+    }
+    /**
+     * Parse the key/value pairs from a string.
+     *
+     * Parses a formatted string into key-value pairs.
+     * Supports both single and multi-character separators.
+     *
+     * Direct mapping to av_dict_parse_string()
+     *
+     * @param str - String to parse (e.g., "key1=value1:key2=value2")
+     * @param keyValSep - String separator between key and value (e.g., '=' or ':=')
+     * @param pairsSep - String separator between pairs (e.g., ':' or ',' or ';')
+     * @param flags - AV_DICT_* flags (default: AVFLAG_NONE)
+     *
+     * @returns 0 on success, negative AVERROR on error:
+     *   - 0: Success
+     *   - AVERROR(EINVAL): Invalid parameters
+     *   - AVERROR(ENOMEM): Memory allocation failure
+     *
+     * @example
+     * ```typescript
+     * import { Dictionary, FFmpegError } from 'node-av';
+     *
+     * // Parse codec options with single-char separators
+     * const ret = dict.parseString('bitrate=128k:preset=fast', '=', ':');
+     * FFmpegError.throwIfError(ret, 'parseString');
+     *
+     * // Parse with multi-char separators
+     * const ret2 = dict.parseString('title:=My Video;;artist:=Me', ':=', ';;');
+     * FFmpegError.throwIfError(ret2, 'parseString');
+     * ```
+     *
+     * @see {@link getString} To convert back to string
+     */
+    parseString(str, keyValSep, pairsSep, flags = AVFLAG_NONE) {
+        return this.native.parseString(str, keyValSep, pairsSep, flags);
+    }
+    /**
+     * Get dictionary as a string.
+     *
+     * Direct mapping to av_dict_get_string()
+     *
+     * @param keyValSep - Character to separate key from value
+     * @param pairsSep - Character to separate pairs
+     *
+     * @returns String representation or null on error
+     *
+     * @example
+     * ```typescript
+     * const str = dict.getString('=', ':');
+     * console.log(str); // "key1=value1:key2=value2"
+     *
+     * // Export as comma-separated
+     * const csv = dict.getString('=', ',');
+     * console.log(csv); // "key1=value1,key2=value2"
+     * ```
+     *
+     * @see parseString() - To parse a string back to dictionary
+     */
+    getString(keyValSep, pairsSep) {
+        return this.native.getString(keyValSep, pairsSep);
+    }
+    /**
+     * Get the native FFmpeg AVDictionary pointer.
+     *
+     * @internal For use by other wrapper classes
+     * @returns The underlying native dictionary object
+     */
+    getNative() {
+        return this.native;
+    }
+    /**
+     * Dispose of the dictionary.
+     *
+     * Implements the Disposable interface for automatic cleanup.
+     * Equivalent to calling free().
+     *
+     * @example
+     * ```typescript
+     * import { Dictionary, FFmpegError } from 'node-av';
+     *
+     * {
+     *   using dict = new Dictionary();
+     *   const ret = dict.set('key', 'value', 0);
+     *   FFmpegError.throwIfError(ret, 'set');
+     *   // ... use dictionary
+     * } // Automatically freed when leaving scope
+     * ```
+     *
+     * @see {@link free} For manual cleanup
+     */
+    [Symbol.dispose]() {
+        this.native[Symbol.dispose]();
+    }
+}
+//# sourceMappingURL=dictionary.js.map

package/dist/lib/dictionary.js.map

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

package/dist/lib/error.d.ts

@@ -0,0 +1,216 @@
+import type { NativeFFmpegError } from './native-types.js';
+/**
+ * FFmpeg error handling.
+ *
+ * Represents FFmpeg errors with error codes and human-readable messages.
+ * Provides utilities for error checking and throwing.
+ * Essential for proper error handling in FFmpeg operations.
+ *
+ * Direct mapping to FFmpeg's error system.
+ *
+ * @example
+ * ```typescript
+ * import { FFmpegError } from 'node-av';
+ *
+ * // Check return codes
+ * const ret = await codecContext.sendPacket(packet);
+ * FFmpegError.throwIfError(ret, 'sendPacket');
+ *
+ * // Handle specific errors
+ * try {
+ *   const openRet = await formatContext.openInput('file.mp4', null, null);
+ *   FFmpegError.throwIfError(openRet, 'openInput');
+ * } catch (error) {
+ *   if (error instanceof FFmpegError) {
+ *     console.error(`Error code: ${error.code}`);
+ *     console.error(`Message: ${error.message}`);
+ *   }
+ * }
+ * ```
+ */
+export declare class FFmpegError extends Error {
+    private native;
+    /**
+     * Create a new FFmpegError instance.
+     *
+     * Wraps an FFmpeg error code with a JavaScript Error.
+     * Automatically retrieves the error message from FFmpeg.
+     *
+     * Direct wrapper around FFmpeg error codes.
+     *
+     * @param code - FFmpeg error code (negative number)
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     * import { AVERROR_EOF } from 'node-av/constants';
+     *
+     * const error = new FFmpegError(AVERROR_EOF);
+     * console.log(error.message); // "End of file"
+     * console.log(error.code);    // -541478725
+     * ```
+     */
+    constructor(code?: number);
+    /**
+     * Put a description of the AVERROR code errnum in a string.
+     *
+     * Converts an error code to a human-readable message.
+     *
+     * Direct mapping to av_strerror()
+     *
+     * @param errnum - Error code to describe
+     *
+     * @returns Error description string
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     * import { AVERROR_EAGAIN, AVERROR_EOF } from 'node-av/constants';
+     *
+     * const message = FFmpegError.strerror(AVERROR_EAGAIN);
+     * console.log(message); // "Resource temporarily unavailable"
+     *
+     * const message2 = FFmpegError.strerror(AVERROR_EOF);
+     * console.log(message2); // "End of file"
+     * ```
+     */
+    static strerror(errnum: number): string;
+    /**
+     * Convert a POSIX error code to FFmpeg error code.
+     *
+     * Converts standard POSIX error codes to FFmpeg's error format.
+     *
+     * Direct mapping to AVERROR() macro
+     *
+     * @param posixError - POSIX error code (positive)
+     *
+     * @returns FFmpeg error code (negative)
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     * import { EAGAIN } from 'errno';
+     *
+     * const ffmpegError = FFmpegError.makeError(EAGAIN);
+     * // ffmpegError is now AVERROR(EAGAIN)
+     *
+     * if (ret === ffmpegError) {
+     *   console.log('Resource temporarily unavailable');
+     * }
+     * ```
+     */
+    static makeError(posixError: number): number;
+    /**
+     * Check if a value is an error code.
+     *
+     * @param code - Value to check
+     *
+     * @returns true if code is negative (error), false otherwise
+     *
+     * @example
+     * ```typescript
+     * const ret = await formatContext.readFrame(packet);
+     * if (FFmpegError.isFFmpegError(ret)) {
+     *   console.error('Read frame failed');
+     * }
+     * ```
+     */
+    static isFFmpegError(code: number): boolean;
+    /**
+     * Create FFmpegError from error code if it's an error.
+     *
+     * Helper method to conditionally create error objects.
+     *
+     * @param code - FFmpeg return code
+     *
+     * @returns FFmpegError if code < 0, null otherwise
+     *
+     * @example
+     * ```typescript
+     * const ret = await formatContext.openInput('video.mp4', null, null);
+     * const error = FFmpegError.fromCode(ret);
+     * if (error) {
+     *   console.error(`Failed: ${error.message}`);
+     *   console.error(`Code: ${error.code}`);
+     * }
+     * ```
+     */
+    static fromCode(code: number): FFmpegError | null;
+    /**
+     * Throw FFmpegError if code indicates error.
+     *
+     * Checks return code and throws an error if negative.
+     * Essential for FFmpeg error handling pattern.
+     *
+     * @param code - FFmpeg return code
+     * @param operation - Optional operation name for better error messages
+     *
+     * @throws {FFmpegError} If code < 0
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     *
+     * const ret = await codecContext.sendPacket(packet);
+     * FFmpegError.throwIfError(ret, 'sendPacket');
+     * // Continues if successful, throws if error
+     *
+     * // With operation name for better error messages
+     * const ret2 = formatContext.allocOutputContext2(null, 'mp4', 'out.mp4');
+     * FFmpegError.throwIfError(ret2, 'allocOutputContext2');
+     * // Error message: "allocOutputContext2 failed: ..."
+     * ```
+     *
+     * @see {@link fromCode} To create error without throwing
+     * @see {@link isFFmpegError} To check if value is error
+     */
+    static throwIfError(code: number, operation?: string): void;
+    /**
+     * Check if error code matches specific error.
+     *
+     * Compares return code with specific error constant.
+     * Useful for handling different error conditions.
+     *
+     * @param code - FFmpeg return code
+     * @param errorCode - Error code to check against
+     *
+     * @returns true if codes match, false otherwise
+     *
+     * @example
+     * ```typescript
+     * import { FFmpegError } from 'node-av';
+     * import { AVERROR_EOF, AVERROR_EAGAIN } from 'node-av/constants';
+     *
+     * const ret = await codecContext.receiveFrame(frame);
+     * if (FFmpegError.is(ret, AVERROR_EOF)) {
+     *   console.log('End of stream reached');
+     * } else if (FFmpegError.is(ret, AVERROR_EAGAIN)) {
+     *   console.log('Need more input');
+     * }
+     * ```
+     */
+    static is(code: number, errorCode: number): boolean;
+    /**
+     * Get error code.
+     *
+     * Direct mapping to AVERROR code
+     *
+     * FFmpeg error code (negative number).
+     */
+    get code(): number;
+    /**
+     * Get human-readable error message.
+     *
+     * Direct mapping to av_strerror() output
+     *
+     * Error description string.
+     */
+    get message(): string;
+    /**
+     * Get the native FFmpeg error object.
+     *
+     * @internal For use by other wrapper classes
+     * @returns The underlying native error object
+     */
+    getNative(): NativeFFmpegError;
+}