node-av 1.0.3 → 1.2.0

package/dist/lib/codec.js

@@ -1,132 +1,109 @@
+import { AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX, AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX } from '../constants/constants.js';
 import { bindings } from './binding.js';
 import { Rational } from './rational.js';
 /**
- * Codec (encoder/decoder) definition.
+ * Codec descriptor for audio/video encoding and decoding.
  *
- * Represents a codec implementation for encoding or decoding media.
- * Provides codec information, capabilities, and supported formats.
- * This is an immutable descriptor - actual encoding/decoding happens via CodecContext.
+ * Represents an encoder or decoder implementation that can process media data.
+ * Contains codec capabilities, supported formats, and hardware acceleration information.
+ * Used to create codec contexts for actual encoding/decoding operations.
+ * Supports both software and hardware-accelerated codecs.
  *
  * Direct mapping to FFmpeg's AVCodec.
  *
  * @example
  * ```typescript
- * import { Codec } from 'node-av';
+ * import { Codec, FFmpegError } from 'node-av';
  * import { AV_CODEC_ID_H264 } from 'node-av/constants';
  *
  * // Find decoder by ID
- * const h264Decoder = Codec.findDecoder(AV_CODEC_ID_H264);
- * if (!h264Decoder) throw new Error('H264 decoder not found');
+ * const decoder = Codec.findDecoder(AV_CODEC_ID_H264);
+ * if (!decoder) {
+ *   throw new Error('H.264 decoder not available');
+ * }
  *
  * // Find encoder by name
- * const x264Encoder = Codec.findEncoderByName('libx264');
- * if (!x264Encoder) throw new Error('x264 encoder not found');
- *
- * // Check codec capabilities
- * console.log(`Codec: ${h264Decoder.name}`);
- * console.log(`Long name: ${h264Decoder.longName}`);
- * console.log(`Type: ${h264Decoder.type}`);
- * console.log(`Is decoder: ${h264Decoder.isDecoder()}`);
+ * const encoder = Codec.findEncoderByName('libx264');
+ * if (!encoder) {
+ *   throw new Error('libx264 encoder not available');
+ * }
  *
- * // Get supported formats
- * const pixelFormats = h264Decoder.pixelFormats;
- * console.log(`Supported pixel formats: ${pixelFormats}`);
+ * // Check capabilities
+ * console.log(`Codec: ${decoder.name}`);
+ * console.log(`Type: ${decoder.type}`);
+ * console.log(`Hardware: ${decoder.hasHardwareAcceleration()}`);
  *
- * // Iterate through all codecs
- * let iter = null;
- * while (true) {
- *   const result = Codec.iterateCodecs(iter);
- *   if (!result) break;
- *   console.log(`Found codec: ${result.codec.name}`);
- *   iter = result.opaque;
+ * // Get supported pixel formats
+ * const formats = decoder.pixelFormats;
+ * if (formats) {
+ *   console.log(`Supported formats: ${formats.join(', ')}`);
  * }
  * ```
+ *
+ * @see [AVCodec](https://ffmpeg.org/doxygen/trunk/structAVCodec.html) - FFmpeg Doxygen
+ * @see {@link CodecContext} For encoding/decoding operations
  */
 export class Codec {
     native;
     /**
-     * Constructor is internal - use static factory methods.
-     *
-     * Codecs are global immutable objects managed by FFmpeg.
-     * Use the static find methods to obtain codec instances.
-     *
+     * @param native - The native codec instance
      * @internal
-     *
-     * @param native - Native AVCodec to wrap
-     *
-     * @example
-     * ```typescript
-     * import { Codec } from 'node-av';
-     * import { AV_CODEC_ID_H264 } from 'node-av/constants';
-     *
-     * // Don't use constructor directly
-     * // const codec = new Codec(); // Wrong
-     *
-     * // Use static factory methods instead
-     * const decoder = Codec.findDecoder(AV_CODEC_ID_H264); // Correct
-     * const encoder = Codec.findEncoderByName('libx264'); // Correct
-     * ```
      */
     constructor(native) {
         this.native = native;
     }
     /**
-     * Create a Codec instance from a native codec object.
-     * @internal Used by the bindings layer
-     */
-    static fromNative(native) {
-        if (!native)
-            return null;
-        return new Codec(native);
-    }
-    /**
-     * Find a registered decoder with a matching codec ID.
+     * Find a decoder by codec ID.
      *
      * Searches for a decoder that can decode the specified codec format.
      *
-     * Direct mapping to avcodec_find_decoder()
-     *
-     * @param id - AVCodecID of the requested decoder
+     * Direct mapping to avcodec_find_decoder().
      *
-     * @returns Codec object or null if no decoder found
+     * @param id - Codec ID to search for
+     * @returns Decoder if found, null otherwise
      *
      * @example
      * ```typescript
-     * import { Codec } from 'node-av';
-     * import { AV_CODEC_ID_H264 } from 'node-av/constants';
+     * import { AV_CODEC_ID_H264, AV_CODEC_ID_AAC } from 'node-av/constants';
      *
-     * const decoder = Codec.findDecoder(AV_CODEC_ID_H264);
-     * if (!decoder) {
-     *   throw new Error('H.264 decoder not available');
+     * // Find H.264 video decoder
+     * const h264 = Codec.findDecoder(AV_CODEC_ID_H264);
+     * if (h264) {
+     *   console.log(`Found: ${h264.name}`);
      * }
+     *
+     * // Find AAC audio decoder
+     * const aac = Codec.findDecoder(AV_CODEC_ID_AAC);
      * ```
      *
      * @see {@link findDecoderByName} To find by name
-     * @see {@link findEncoder} To find encoder
+     * @see {@link findEncoder} To find encoders
      */
     static findDecoder(id) {
         const native = bindings.Codec.findDecoder(id);
         return native ? new Codec(native) : null;
     }
     /**
-     * Find a registered decoder with the specified name.
-     *
-     * Searches for a decoder by its exact name.
-     * Useful for selecting specific decoder implementations.
+     * Find a decoder by name.
      *
-     * Direct mapping to avcodec_find_decoder_by_name()
+     * Searches for a specific decoder implementation by name.
+     * Useful when multiple decoders exist for the same codec.
      *
-     * @param name - Name of the requested decoder
+     * Direct mapping to avcodec_find_decoder_by_name().
      *
-     * @returns Codec object or null if no decoder found
+     * @param name - Decoder name
+     * @returns Decoder if found, null otherwise
      *
      * @example
      * ```typescript
-     * import { Codec } from 'node-av';
+     * // Find specific H.264 decoder
+     * const decoder = Codec.findDecoderByName('h264_cuvid');
+     * if (decoder) {
+     *   console.log('Found NVIDIA hardware decoder');
+     * }
      *
-     * const decoder = Codec.findDecoderByName('h264');
-     * // Can also use specific implementations:
-     * const cudaDecoder = Codec.findDecoderByName('h264_cuvid'); // NVIDIA hardware decoder
+     * // Find software decoder
+     * const sw = Codec.findDecoderByName('h264');
      * ```
      *
      * @see {@link findDecoder} To find by codec ID
@@ -136,54 +113,57 @@ export class Codec {
         return native ? new Codec(native) : null;
     }
     /**
-     * Find a registered encoder with a matching codec ID.
+     * Find an encoder by codec ID.
      *
      * Searches for an encoder that can encode to the specified codec format.
      *
-     * Direct mapping to avcodec_find_encoder()
-     *
-     * @param id - AVCodecID of the requested encoder
+     * Direct mapping to avcodec_find_encoder().
      *
-     * @returns Codec object or null if no encoder found
+     * @param id - Codec ID to search for
+     * @returns Encoder if found, null otherwise
      *
      * @example
      * ```typescript
-     * import { Codec } from 'node-av';
-     * import { AV_CODEC_ID_H264 } from 'node-av/constants';
+     * import { AV_CODEC_ID_H264, AV_CODEC_ID_AAC } from 'node-av/constants';
      *
-     * const encoder = Codec.findEncoder(AV_CODEC_ID_H264);
-     * if (!encoder) {
-     *   throw new Error('H.264 encoder not available');
+     * // Find H.264 video encoder
+     * const h264 = Codec.findEncoder(AV_CODEC_ID_H264);
+     * if (h264) {
+     *   console.log(`Found: ${h264.name}`);
      * }
+     *
+     * // Find AAC audio encoder
+     * const aac = Codec.findEncoder(AV_CODEC_ID_AAC);
      * ```
      *
      * @see {@link findEncoderByName} To find by name
-     * @see {@link findDecoder} To find decoder
+     * @see {@link findDecoder} To find decoders
      */
     static findEncoder(id) {
         const native = bindings.Codec.findEncoder(id);
         return native ? new Codec(native) : null;
     }
     /**
-     * Find a registered encoder with the specified name.
-     *
-     * Searches for an encoder by its exact name.
-     * Useful for selecting specific encoder implementations.
+     * Find an encoder by name.
      *
-     * Direct mapping to avcodec_find_encoder_by_name()
+     * Searches for a specific encoder implementation by name.
+     * Useful when multiple encoders exist for the same codec.
      *
-     * @param name - Name of the requested encoder
+     * Direct mapping to avcodec_find_encoder_by_name().
      *
-     * @returns Codec object or null if no encoder found
+     * @param name - Encoder name
+     * @returns Encoder if found, null otherwise
      *
      * @example
      * ```typescript
-     * import { Codec } from 'node-av';
+     * // Find specific H.264 encoder
+     * const x264 = Codec.findEncoderByName('libx264');
+     * if (x264) {
+     *   console.log('Found x264 encoder');
+     * }
      *
-     * // Find specific encoder implementation
-     * const x264 = Codec.findEncoderByName('libx264');    // Software H.264 encoder
-     * const nvenc = Codec.findEncoderByName('h264_nvenc'); // NVIDIA hardware encoder
-     * const vaapi = Codec.findEncoderByName('h264_vaapi'); // VAAPI hardware encoder
+     * // Find hardware encoder
+     * const nvenc = Codec.findEncoderByName('h264_nvenc');
      * ```
      *
      * @see {@link findEncoder} To find by codec ID
@@ -195,25 +175,24 @@ export class Codec {
     /**
      * Get list of all available codecs.
      *
-     * Returns all registered codecs in the system.
-     * Internally uses av_codec_iterate() to collect all codecs.
+     * Returns all registered codecs (both encoders and decoders).
      *
-     * @returns Array of all registered codecs
+     * @returns Array of all available codecs
      *
      * @example
      * ```typescript
-     * import { Codec } from 'node-av';
-     * import { AVMEDIA_TYPE_VIDEO } from 'node-av/constants';
-     *
+     * // List all codecs
      * const codecs = Codec.getCodecList();
-     * const videoEncoders = codecs.filter(c =>
-     *   c.type === AVMEDIA_TYPE_VIDEO && c.isEncoder()
-     * );
-     * console.log(`Found ${videoEncoders.length} video encoders`);
-     * ```
+     * console.log(`Total codecs: ${codecs.length}`);
+     *
+     * // Filter encoders
+     * const encoders = codecs.filter(c => c.isEncoder());
+     * console.log(`Encoders: ${encoders.length}`);
      *
-     * @note This loads all codecs at once. For large codec lists,
-     *       consider using iterateCodecs() instead.
+     * // Filter hardware codecs
+     * const hw = codecs.filter(c => c.hasHardwareAcceleration());
+     * console.log(`Hardware codecs: ${hw.length}`);
+     * ```
      *
      * @see {@link iterateCodecs} For memory-efficient iteration
      */
@@ -222,37 +201,28 @@ export class Codec {
         return natives.map((n) => new Codec(n));
     }
     /**
-     * Iterate through codecs one by one.
-     *
-     * Memory-efficient codec iteration.
-     * Processes codecs one at a time instead of loading all at once.
+     * Iterate through available codecs.
      *
-     * Direct mapping to av_codec_iterate()
+     * Memory-efficient way to iterate through all codecs.
+     * Uses an opaque pointer to track iteration state.
      *
-     * @param opaque - Iterator state (null to start, or value from previous call)
+     * Direct mapping to av_codec_iterate().
      *
-     * @returns Object with codec and next iterator state, or null when done
+     * @param opaque - Iteration state (null to start)
+     * @returns Next codec and state, or null when done
      *
      * @example
      * ```typescript
-     * import { Codec } from 'node-av';
-     * import { AVMEDIA_TYPE_VIDEO } from 'node-av/constants';
-     *
-     * let opaque = null;
-     * while (true) {
-     *   const result = Codec.iterateCodecs(opaque);
-     *   if (!result) break;
-     *
-     *   const codec = result.codec;
-     *   if (codec.type === AVMEDIA_TYPE_VIDEO && codec.isEncoder()) {
-     *     console.log(`Video encoder: ${codec.name}`);
-     *   }
-     *
-     *   opaque = result.opaque;
+     * // Iterate all codecs
+     * let iter = null;
+     * let result;
+     * while ((result = Codec.iterateCodecs(iter))) {
+     *   console.log(`Codec: ${result.codec.name}`);
+     *   iter = result.opaque;
      * }
      * ```
      *
-     * @see {@link getCodecList} To get all codecs at once
+     * @see {@link getCodecList} For simple array access
      */
     static iterateCodecs(opaque = null) {
         const result = bindings.Codec.iterateCodecs(opaque);
@@ -264,30 +234,31 @@ export class Codec {
         };
     }
     /**
-     * Short name of the codec.
+     * Codec name.
+     *
+     * Short name identifier for the codec (e.g., 'h264', 'aac').
      *
-     * Direct mapping to AVCodec->name
-     * Typically matches the name of the codec specification.
-     * For example: "h264", "aac", "vp9", "opus"
+     * Direct mapping to AVCodec->name.
      */
     get name() {
         return this.native.name;
     }
     /**
-     * Descriptive name for the codec.
+     * Codec long name.
      *
-     * Direct mapping to AVCodec->long_name
-     * More human-readable than name.
-     * For example: "H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"
+     * Human-readable description of the codec.
+     *
+     * Direct mapping to AVCodec->long_name.
      */
     get longName() {
         return this.native.longName;
     }
     /**
-     * Media type handled by this codec.
+     * Media type.
+     *
+     * Type of media this codec processes (video, audio, subtitle, etc.).
      *
-     * Direct mapping to AVCodec->type
-     * AVMEDIA_TYPE_VIDEO, AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_SUBTITLE, etc.
+     * Direct mapping to AVCodec->type.
      */
     get type() {
         return this.native.type;
@@ -295,8 +266,9 @@ export class Codec {
     /**
      * Codec ID.
      *
-     * Direct mapping to AVCodec->id
-     * Unique identifier for this codec type (AV_CODEC_ID_H264, AV_CODEC_ID_AAC, etc.)
+     * Unique identifier for the codec format.
+     *
+     * Direct mapping to AVCodec->id.
      */
     get id() {
         return this.native.id;
@@ -304,53 +276,50 @@ export class Codec {
     /**
      * Codec capabilities.
      *
-     * Direct mapping to AVCodec->capabilities
-     * Bitfield of AV_CODEC_CAP_* flags describing codec features.
+     * Bitfield of AV_CODEC_CAP_* flags indicating codec features.
+     *
+     * Direct mapping to AVCodec->capabilities.
      */
     get capabilities() {
         return this.native.capabilities;
     }
     /**
-     * Maximum lowres value supported by the decoder.
+     * Maximum lowres value.
      *
-     * Lowres decoding allows decoding at reduced resolution for faster preview.
-     * 0 means lowres decoding is not supported.
-     * 1 means 1/2 resolution is supported.
-     * 2 means 1/4 resolution is supported.
-     * 3 means 1/8 resolution is supported.
-     * @readonly
+     * Maximum value for lowres decoding (0 = no lowres support).
+     *
+     * Direct mapping to AVCodec->max_lowres.
      */
     get maxLowres() {
         return this.native.maxLowres;
     }
     /**
-     * Array of supported codec profiles.
+     * Supported profiles.
+     *
+     * Array of profiles this codec can handle (e.g., baseline, main, high).
      *
-     * Profiles define subsets of codec features.
-     * For example, H.264 has Baseline, Main, High profiles.
-     * null if codec doesn't support profiles or none are defined.
-     * @readonly
+     * Direct mapping to AVCodec->profiles.
      */
     get profiles() {
         return this.native.profiles;
     }
     /**
-     * Group name of the codec implementation.
+     * Wrapper name.
      *
-     * This is a short symbolic name of the wrapper backing this codec.
-     * For example "lavc" for internal codecs, "libopenh264" for OpenH264 wrapper.
-     * null if codec is not wrapped.
-     * @readonly
+     * Name of the codec wrapper, if this is a wrapper codec.
+     *
+     * Direct mapping to AVCodec->wrapper_name.
      */
     get wrapper() {
         return this.native.wrapper;
     }
     /**
-     * Supported framerates (video only).
+     * Supported frame rates.
+     *
+     * Array of frame rates this video codec supports.
+     * Null for audio codecs or if all rates are supported.
      *
-     * Terminated by {0,0}. null if any framerate is supported.
-     * Some codecs like MPEG-1/2 only support specific framerates.
-     * @readonly
+     * Direct mapping to AVCodec->supported_framerates.
      */
     get supportedFramerates() {
         const rates = this.native.supportedFramerates;
@@ -359,98 +328,97 @@ export class Codec {
         return rates.map((r) => new Rational(r.num, r.den));
     }
     /**
-     * Array of supported pixel formats (video only).
+     * Supported pixel formats.
      *
-     * Terminated by AV_PIX_FMT_NONE. null if unknown.
-     * Lists all pixel formats this codec can encode/decode.
-     * @readonly
+     * Array of pixel formats this video codec supports.
+     * Null for audio codecs.
+     *
+     * Direct mapping to AVCodec->pix_fmts.
      */
     get pixelFormats() {
         return this.native.pixelFormats;
     }
     /**
-     * Supported sample rates (audio only).
+     * Supported sample rates.
+     *
+     * Array of sample rates this audio codec supports.
+     * Null for video codecs or if all rates are supported.
      *
-     * Terminated by 0. null if any sample rate is supported.
-     * Common rates: 8000, 16000, 22050, 44100, 48000, 96000, 192000 Hz.
-     * @readonly
+     * Direct mapping to AVCodec->supported_samplerates.
      */
     get supportedSamplerates() {
         return this.native.supportedSamplerates;
     }
     /**
-     * Array of supported sample formats (audio only).
+     * Supported sample formats.
      *
-     * Terminated by AV_SAMPLE_FMT_NONE. null if unknown.
-     * Lists all sample formats this codec can encode/decode.
-     * Common formats: S16, S32, FLT, DBL (planar and interleaved variants).
-     * @readonly
+     * Array of sample formats this audio codec supports.
+     * Null for video codecs.
+     *
+     * Direct mapping to AVCodec->sample_fmts.
      */
     get sampleFormats() {
         return this.native.sampleFormats;
     }
     /**
-     * Array of supported channel layouts (audio only).
+     * Supported channel layouts.
+     *
+     * Array of channel layouts this audio codec supports.
+     * Null for video codecs.
      *
-     * Lists all channel configurations this codec supports.
-     * Common layouts: mono, stereo, 5.1, 7.1.
-     * null if unknown or all layouts are supported.
-     * @readonly
+     * Direct mapping to AVCodec->ch_layouts.
      */
     get channelLayouts() {
         return this.native.channelLayouts;
     }
     /**
-     * Check if the codec is an encoder.
+     * Check if codec is an encoder.
      *
-     * Direct mapping to av_codec_is_encoder()
-     *
-     * @returns true if the codec is an encoder, false otherwise
+     * @returns True if this codec can encode
      *
      * @example
      * ```typescript
      * const codec = Codec.findEncoderByName('libx264');
-     * if (codec && codec.isEncoder()) {
-     *   console.log('Found H.264 encoder');
+     * if (codec?.isEncoder()) {
+     *   console.log('This is an encoder');
      * }
      * ```
+     *
+     * @see {@link isDecoder} To check for decoders
      */
     isEncoder() {
         return this.native.isEncoder();
     }
     /**
-     * Check if the codec is a decoder.
+     * Check if codec is a decoder.
      *
-     * Direct mapping to av_codec_is_decoder()
-     *
-     * @returns true if the codec is a decoder, false otherwise
+     * @returns True if this codec can decode
      *
      * @example
      * ```typescript
      * const codec = Codec.findDecoder(AV_CODEC_ID_H264);
-     * if (codec && codec.isDecoder()) {
-     *   console.log('Found H.264 decoder');
+     * if (codec?.isDecoder()) {
+     *   console.log('This is a decoder');
      * }
      * ```
+     *
+     * @see {@link isEncoder} To check for encoders
      */
     isDecoder() {
         return this.native.isDecoder();
     }
     /**
-     * Check if the codec is experimental.
+     * Check if codec is experimental.
      *
-     * Experimental codecs require explicit allowance to use.
-     * You must set strict_std_compliance to FF_COMPLIANCE_EXPERIMENTAL
-     * or lower in the codec context to use experimental codecs.
+     * Experimental codecs require explicit opt-in to use.
      *
-     * @returns true if the codec is experimental, false otherwise
+     * @returns True if codec is marked experimental
      *
      * @example
      * ```typescript
-     * const codec = Codec.findEncoderByName('some_experimental_codec');
-     * if (codec && codec.isExperimental()) {
-     *   console.warn('This codec is experimental and may not be stable');
-     *   // codecContext.strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
+     * if (codec.isExperimental()) {
+     *   console.warn('This codec is experimental');
+     *   // Need to set strict_std_compliance = -2
      * }
      * ```
      */
@@ -458,23 +426,213 @@ export class Codec {
         return this.native.isExperimental();
     }
     /**
-     * Get hardware configuration at specified index.
+     * Check if codec supports hardware acceleration.
      *
-     * Direct mapping to avcodec_get_hw_config()
+     * Checks if the codec has any hardware configuration.
      *
-     * @param index - Configuration index (0-based)
-     * @returns Hardware configuration or null if not available
+     * @returns True if hardware acceleration is available
      *
      * @example
      * ```typescript
-     * const codec = Codec.findDecoder(AV_CODEC_ID_H264);
+     * const codec = Codec.findDecoderByName('h264_cuvid');
+     * if (codec?.hasHardwareAcceleration()) {
+     *   console.log('Hardware acceleration available');
+     * }
+     * ```
+     *
+     * @see {@link getSupportedDeviceTypes} For specific device types
+     */
+    hasHardwareAcceleration() {
+        // A codec is considered hardware if it has any hw_config with:
+        // - HW_DEVICE_CTX support (decoders typically use this)
+        // - HW_FRAMES_CTX support (encoders typically use this)
+        for (let i = 0;; i++) {
+            const config = this.getHwConfig(i);
+            if (!config)
+                break;
+            // Check for either HW_DEVICE_CTX or HW_FRAMES_CTX
+            if ((config.methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX) !== 0 || (config.methods & AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX) !== 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if codec supports specific device type.
+     *
+     * @param deviceType - Hardware device type to check
+     * @returns True if device type is supported
+     *
+     * @example
+     * ```typescript
+     * import { AV_HWDEVICE_TYPE_CUDA } from 'node-av/constants';
+     *
+     * if (codec.supportsDevice(AV_HWDEVICE_TYPE_CUDA)) {
+     *   console.log('Supports NVIDIA CUDA');
+     * }
+     * ```
+     *
+     * @see {@link getSupportedDeviceTypes} For all supported types
+     */
+    supportsDevice(deviceType) {
+        for (let i = 0;; i++) {
+            const config = this.getHwConfig(i);
+            if (!config)
+                break;
+            // Check if this config is for the requested device type
+            if (config.deviceType === deviceType) {
+                // Check if it has any valid hardware method
+                if ((config.methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX) !== 0 || (config.methods & AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX) !== 0) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if decoder supports hardware acceleration.
+     *
+     * @param deviceType - Optional specific device type
+     * @returns True if hardware decoding is supported
+     *
+     * @example
+     * ```typescript
+     * import { AV_HWDEVICE_TYPE_VIDEOTOOLBOX } from 'node-av/constants';
+     *
+     * // Check any hardware support
+     * if (codec.isHardwareAcceleratedDecoder()) {
+     *   console.log('Hardware decoding available');
+     * }
+     *
+     * // Check specific device
+     * if (codec.isHardwareAcceleratedDecoder(AV_HWDEVICE_TYPE_VIDEOTOOLBOX)) {
+     *   console.log('VideoToolbox decoding available');
+     * }
+     * ```
+     */
+    isHardwareAcceleratedDecoder(deviceType) {
+        if (!this.isDecoder())
+            return false;
+        if (deviceType !== undefined) {
+            return this.supportsDevice(deviceType);
+        }
+        return this.hasHardwareAcceleration();
+    }
+    /**
+     * Check if encoder supports hardware acceleration.
+     *
+     * @param deviceType - Optional specific device type
+     * @returns True if hardware encoding is supported
+     *
+     * @example
+     * ```typescript
+     * import { AV_HWDEVICE_TYPE_VAAPI } from 'node-av/constants';
+     *
+     * // Check any hardware support
+     * if (codec.isHardwareAcceleratedEncoder()) {
+     *   console.log('Hardware encoding available');
+     * }
+     *
+     * // Check specific device
+     * if (codec.isHardwareAcceleratedEncoder(AV_HWDEVICE_TYPE_VAAPI)) {
+     *   console.log('VAAPI encoding available');
+     * }
+     * ```
+     */
+    isHardwareAcceleratedEncoder(deviceType) {
+        if (!this.isEncoder())
+            return false;
+        if (deviceType !== undefined) {
+            return this.supportsDevice(deviceType);
+        }
+        return this.hasHardwareAcceleration();
+    }
+    /**
+     * Get supported hardware device types.
+     *
+     * Returns all hardware acceleration types this codec supports.
+     *
+     * @returns Array of supported device types
+     *
+     * @example
+     * ```typescript
+     * const devices = codec.getSupportedDeviceTypes();
+     * console.log('Supported devices:', devices.map(d => {
+     *   switch(d) {
+     *     case AV_HWDEVICE_TYPE_CUDA: return 'CUDA';
+     *     case AV_HWDEVICE_TYPE_VAAPI: return 'VAAPI';
+     *     default: return 'Unknown';
+     *   }
+     * }));
+     * ```
+     *
+     * @see {@link supportsDevice} To check specific device
+     */
+    getSupportedDeviceTypes() {
+        const deviceTypes = new Set();
+        for (let i = 0;; i++) {
+            const config = this.getHwConfig(i);
+            if (!config)
+                break;
+            // Only add if it has valid hw methods
+            if ((config.methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX) !== 0 || (config.methods & AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX) !== 0) {
+                deviceTypes.add(config.deviceType);
+            }
+        }
+        return Array.from(deviceTypes);
+    }
+    /**
+     * Get hardware method flags for device type.
+     *
+     * Returns the hardware configuration methods for a specific device.
+     *
+     * @param deviceType - Device type to query
+     * @returns Method flags, or null if not supported
+     *
+     * @example
+     * ```typescript
+     * import { AV_HWDEVICE_TYPE_CUDA } from 'node-av/constants';
+     *
+     * const methods = codec.getHardwareMethod(AV_HWDEVICE_TYPE_CUDA);
+     * if (methods) {
+     *   if (methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX) {
+     *     console.log('Supports device context');
+     *   }
+     * }
+     * ```
+     */
+    getHardwareMethod(deviceType) {
+        for (let i = 0;; i++) {
+            const config = this.getHwConfig(i);
+            if (!config)
+                break;
+            if (config.deviceType === deviceType) {
+                return config.methods;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get hardware configuration at index.
+     *
+     * Retrieves hardware acceleration configuration details.
+     *
+     * Direct mapping to avcodec_get_hw_config().
+     *
+     * @param index - Configuration index
+     * @returns Hardware configuration, or null if index out of range
+     *
+     * @example
+     * ```typescript
+     * // Enumerate all hardware configs
      * for (let i = 0; ; i++) {
      *   const config = codec.getHwConfig(i);
      *   if (!config) break;
      *
-     *   if (config.methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX) {
-     *     console.log(`Supports device type: ${config.deviceType}`);
-     *   }
+     *   console.log(`Config ${i}:`);
+     *   console.log(`  Pixel format: ${config.pixFmt}`);
+     *   console.log(`  Device type: ${config.deviceType}`);
+     *   console.log(`  Methods: 0x${config.methods.toString(16)}`);
      * }
      * ```
      */
@@ -482,11 +640,27 @@ export class Codec {
         return this.native.getHwConfig(index);
     }
     /**
-     * Get the native codec object for use with C++ bindings
+     * Get the underlying native Codec object.
+     *
+     * @returns The native Codec binding object
+     *
      * @internal
      */
     getNative() {
         return this.native;
     }
+    /**
+     * Create codec from native instance.
+     *
+     * @param native - Native codec instance
+     * @returns Codec wrapper or null
+     *
+     * @internal
+     */
+    static fromNative(native) {
+        if (!native)
+            return null;
+        return new Codec(native);
+    }
 }
 //# sourceMappingURL=codec.js.map