node-av 1.0.3 → 1.2.0

package/dist/lib/utilities.d.ts

@@ -1,138 +1,213 @@
+import type { AVMediaType, AVPixelFormat, AVSampleFormat } from '../constants/constants.js';
+import type { FormatContext } from './format-context.js';
+import type { ChannelLayout, IRational } from './types.js';
 /**
- * FFmpeg utility functions collection.
+ * Get bytes per audio sample.
+ *
+ * Returns the number of bytes required to store a single audio sample
+ * in the specified format.
  *
- * Provides direct mappings to various FFmpeg utility functions from libavutil.
- * These functions handle common operations like timestamp conversion, image buffer
- * allocation, sample format queries, and more.
+ * Direct mapping to av_get_bytes_per_sample().
+ *
+ * @param sampleFmt - Audio sample format
+ * @returns Number of bytes per sample, or 0 if unknown format
  *
  * @example
  * ```typescript
- * import { avImageAlloc, avTs2TimeStr, avRescaleQ, FFmpegError } from 'node-av';
- * import { AV_PIX_FMT_YUV420P, IRational } from 'node-av';
- *
- * // Allocate image buffer
- * const image = avImageAlloc(1920, 1080, AV_PIX_FMT_YUV420P, 32);
- * console.log(`Allocated ${image.size} bytes`);
+ * import { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
  *
- * // Convert timestamp to readable time
- * const timebase: IRational = { num: 1, den: 90000 };
- * const pts = 450000n;
- * console.log(avTs2TimeStr(pts, timebase)); // "5.000000"
+ * const bytesS16 = avGetBytesPerSample(AV_SAMPLE_FMT_S16);  // Returns 2
+ * const bytesFloat = avGetBytesPerSample(AV_SAMPLE_FMT_FLTP); // Returns 4
  * ```
  */
-import type { AVMediaType, AVPixelFormat, AVSampleFormat } from './constants.js';
-import type { FormatContext } from './format-context.js';
-import type { ChannelLayout, IRational } from './types.js';
+export declare function avGetBytesPerSample(sampleFmt: AVSampleFormat): number;
 /**
- * Get bytes per sample for a sample format.
+ * Get sample format name.
  *
- * Returns the number of bytes required to store one sample in the given format.
+ * Returns the name of the audio sample format as a string.
  *
- * Direct mapping to av_get_bytes_per_sample()
+ * Direct mapping to av_get_sample_fmt_name().
  *
  * @param sampleFmt - Audio sample format
- *
- * @returns Number of bytes per sample, or 0 for invalid format
+ * @returns Format name, or null if unknown
  *
  * @example
  * ```typescript
- * import { avGetBytesPerSample, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT } from 'node-av';
+ * import { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
  *
- * console.log(avGetBytesPerSample(AV_SAMPLE_FMT_S16)); // 2
- * console.log(avGetBytesPerSample(AV_SAMPLE_FMT_FLT)); // 4
+ * const name1 = avGetSampleFmtName(AV_SAMPLE_FMT_S16);  // Returns "s16"
+ * const name2 = avGetSampleFmtName(AV_SAMPLE_FMT_FLTP); // Returns "fltp"
  * ```
  */
-export declare function avGetBytesPerSample(sampleFmt: AVSampleFormat): number;
+export declare function avGetSampleFmtName(sampleFmt: AVSampleFormat): string | null;
 /**
- * Get the name of a sample format.
+ * Get packed sample format.
  *
- * Returns a string describing the sample format.
+ * Returns the packed (interleaved) version of a planar sample format,
+ * or the format itself if already packed.
  *
- * Direct mapping to av_get_sample_fmt_name()
+ * Direct mapping to av_get_packed_sample_fmt().
  *
  * @param sampleFmt - Audio sample format
- *
- * @returns Format name string, or null for invalid format
+ * @returns Packed version of the format
  *
  * @example
  * ```typescript
- * import { avGetSampleFmtName, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLTP } from 'node-av';
+ * import { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_FLT } from 'node-av/constants';
  *
- * console.log(avGetSampleFmtName(AV_SAMPLE_FMT_S16)); // "s16"
- * console.log(avGetSampleFmtName(AV_SAMPLE_FMT_FLTP)); // "fltp"
+ * const packed = avGetPackedSampleFmt(AV_SAMPLE_FMT_FLTP); // Returns AV_SAMPLE_FMT_FLT
+ * const same = avGetPackedSampleFmt(AV_SAMPLE_FMT_FLT);    // Returns AV_SAMPLE_FMT_FLT
  * ```
- */
-export declare function avGetSampleFmtName(sampleFmt: AVSampleFormat): string | null;
-/**
- * Get packed sample format
- * Direct mapping to av_get_packed_sample_fmt()
+ *
+ * @see {@link avGetPlanarSampleFmt} For getting planar version
  */
 export declare function avGetPackedSampleFmt(sampleFmt: AVSampleFormat): AVSampleFormat;
 /**
- * Get planar sample format
- * Direct mapping to av_get_planar_sample_fmt()
+ * Get planar sample format.
+ *
+ * Returns the planar (non-interleaved) version of a packed sample format,
+ * or the format itself if already planar.
+ *
+ * Direct mapping to av_get_planar_sample_fmt().
+ *
+ * @param sampleFmt - Audio sample format
+ * @returns Planar version of the format
+ *
+ * @example
+ * ```typescript
+ * import { AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
+ *
+ * const planar = avGetPlanarSampleFmt(AV_SAMPLE_FMT_FLT);   // Returns AV_SAMPLE_FMT_FLTP
+ * const same = avGetPlanarSampleFmt(AV_SAMPLE_FMT_FLTP);    // Returns AV_SAMPLE_FMT_FLTP
+ * ```
+ *
+ * @see {@link avGetPackedSampleFmt} For getting packed version
  */
 export declare function avGetPlanarSampleFmt(sampleFmt: AVSampleFormat): AVSampleFormat;
 /**
- * Check if sample format is planar
- * Direct mapping to av_sample_fmt_is_planar()
+ * Check if sample format is planar.
+ *
+ * Returns whether the audio sample format stores channels in separate planes
+ * (planar) rather than interleaved.
+ *
+ * Direct mapping to av_sample_fmt_is_planar().
+ *
+ * @param sampleFmt - Audio sample format to check
+ * @returns True if planar, false if packed/interleaved
+ *
+ * @example
+ * ```typescript
+ * import { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P } from 'node-av/constants';
+ *
+ * const isPacked = avSampleFmtIsPlanar(AV_SAMPLE_FMT_S16);  // Returns false
+ * const isPlanar = avSampleFmtIsPlanar(AV_SAMPLE_FMT_S16P); // Returns true
+ * ```
  */
 export declare function avSampleFmtIsPlanar(sampleFmt: AVSampleFormat): boolean;
 /**
- * Get pixel format name
- * Direct mapping to av_get_pix_fmt_name()
+ * Get pixel format name.
+ *
+ * Returns the name of the pixel format as a string.
+ *
+ * Direct mapping to av_get_pix_fmt_name().
+ *
+ * @param pixFmt - Pixel format
+ * @returns Format name, or null if unknown
+ *
+ * @example
+ * ```typescript
+ * import { AV_PIX_FMT_YUV420P, AV_PIX_FMT_RGB24 } from 'node-av/constants';
+ *
+ * const name1 = avGetPixFmtName(AV_PIX_FMT_YUV420P); // Returns "yuv420p"
+ * const name2 = avGetPixFmtName(AV_PIX_FMT_RGB24);   // Returns "rgb24"
+ * ```
  */
 export declare function avGetPixFmtName(pixFmt: AVPixelFormat): string | null;
 /**
- * Get pixel format from name
- * Direct mapping to av_get_pix_fmt()
+ * Get pixel format from name.
+ *
+ * Returns the pixel format enum value from its string name.
+ *
+ * Direct mapping to av_get_pix_fmt().
+ *
+ * @param name - Pixel format name
+ * @returns Pixel format enum, or AV_PIX_FMT_NONE if unknown
+ *
+ * @example
+ * ```typescript
+ * const fmt1 = avGetPixFmtFromName("yuv420p"); // Returns AV_PIX_FMT_YUV420P
+ * const fmt2 = avGetPixFmtFromName("rgb24");   // Returns AV_PIX_FMT_RGB24
+ * const none = avGetPixFmtFromName("invalid"); // Returns AV_PIX_FMT_NONE
+ * ```
  */
 export declare function avGetPixFmtFromName(name: string): AVPixelFormat;
 /**
- * Check if a pixel format is hardware-accelerated
- * Direct mapping using av_pix_fmt_desc_get() and AV_PIX_FMT_FLAG_HWACCEL
+ * Check if pixel format is hardware accelerated.
+ *
+ * Returns whether the pixel format represents hardware-accelerated frames
+ * (GPU memory) rather than software frames (system memory).
+ *
+ * Direct mapping to av_pix_fmt_desc_get() with hwaccel check.
+ *
+ * @param pixFmt - Pixel format to check
+ * @returns True if hardware format, false if software format
+ *
+ * @example
+ * ```typescript
+ * import { AV_PIX_FMT_YUV420P, AV_PIX_FMT_CUDA } from 'node-av/constants';
+ *
+ * const isSoftware = avIsHardwarePixelFormat(AV_PIX_FMT_YUV420P); // Returns false
+ * const isHardware = avIsHardwarePixelFormat(AV_PIX_FMT_CUDA);    // Returns true
+ * ```
  */
 export declare function avIsHardwarePixelFormat(pixFmt: AVPixelFormat): boolean;
 /**
- * Get media type string
- * Direct mapping to av_get_media_type_string()
+ * Get media type string.
+ *
+ * Returns a human-readable string for the media type.
+ *
+ * Direct mapping to av_get_media_type_string().
+ *
+ * @param mediaType - Media type enum
+ * @returns Media type name, or null if unknown
+ *
+ * @example
+ * ```typescript
+ * import { AVMEDIA_TYPE_VIDEO, AVMEDIA_TYPE_AUDIO } from 'node-av/constants';
+ *
+ * const video = avGetMediaTypeString(AVMEDIA_TYPE_VIDEO); // Returns "video"
+ * const audio = avGetMediaTypeString(AVMEDIA_TYPE_AUDIO); // Returns "audio"
+ * ```
  */
 export declare function avGetMediaTypeString(mediaType: AVMediaType): string | null;
 /**
- * Allocate an image with size, pixel format and alignment.
+ * Allocate image buffer.
  *
- * Allocates a buffer large enough to hold an image with the given parameters.
- * The allocated buffer is properly aligned for optimal performance.
+ * Allocates a buffer large enough to hold an image with the specified dimensions
+ * and pixel format. Returns buffer and layout information.
  *
- * Direct mapping to av_image_alloc()
+ * 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 (1 for no alignment, 32 for SIMD)
+ * @param align - Buffer alignment (typically 1 or 32)
+ * @returns Object with buffer, size, and line sizes
  *
- * @returns Object containing:
- *   - buffer: Allocated image buffer
- *   - size: Total size in bytes
- *   - linesizes: Array of line sizes for each plane
- *
- * @throws {Error} If allocation fails
+ * @throws {FFmpegError} If allocation fails
  *
  * @example
  * ```typescript
- * import { avImageAlloc, AV_PIX_FMT_YUV420P, FFmpegError } from 'node-av';
- *
- * try {
- *   const result = avImageAlloc(1920, 1080, AV_PIX_FMT_YUV420P, 32);
- *   console.log(`Allocated ${result.size} bytes`);
- *   console.log(`Y linesize: ${result.linesizes[0]}`);
- *   // Use result.buffer for image data
- * } catch (error) {
- *   console.error('Failed to allocate image buffer');
- * }
+ * import { AV_PIX_FMT_YUV420P } from 'node-av/constants';
+ *
+ * const { buffer, size, linesizes } = avImageAlloc(
+ *   1920, 1080, AV_PIX_FMT_YUV420P, 32
+ * );
+ * console.log(`Allocated ${size} bytes`);
+ * console.log(`Line sizes: ${linesizes}`);
  * ```
  *
- * @see {@link avImageGetBufferSize} To calculate required size without allocating
+ * @see {@link avImageGetBufferSize} To calculate size without allocating
  */
 export declare function avImageAlloc(width: number, height: number, pixFmt: AVPixelFormat, align: number): {
     buffer: Buffer;
@@ -140,83 +215,135 @@ export declare function avImageAlloc(width: number, height: number, pixFmt: AVPi
     linesizes: number[];
 };
 /**
- * Copy image data from src to dst
- * Direct mapping to av_image_copy2()
+ * Copy image data.
+ *
+ * Copies image data from source to destination buffers.
  *
- * @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
+ * Direct mapping to av_image_copy2().
+ *
+ * @param dstData - Destination data planes
+ * @param dstLinesizes - Destination bytes per line
+ * @param srcData - Source data planes
+ * @param srcLinesizes - Source bytes per line
  * @param pixFmt - Pixel format
  * @param width - Image width
  * @param height - Image height
+ *
+ * @example
+ * ```typescript
+ * avImageCopy2(
+ *   dstPlanes, dstStrides,
+ *   srcPlanes, srcStrides,
+ *   AV_PIX_FMT_YUV420P, 1920, 1080
+ * );
+ * ```
  */
 export declare function avImageCopy2(dstData: Buffer[], dstLinesizes: number[], srcData: Buffer[], srcLinesizes: number[], pixFmt: AVPixelFormat, width: number, height: number): void;
 /**
- * Get the required buffer size for an image
- * Direct mapping to av_image_get_buffer_size()
+ * Get image buffer size.
  *
- * @returns The required buffer size in bytes, or negative on error
+ * Calculates the required buffer size for an image without allocating.
+ *
+ * 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 { AV_PIX_FMT_RGB24 } from 'node-av/constants';
+ *
+ * const size = avImageGetBufferSize(AV_PIX_FMT_RGB24, 1920, 1080, 1);
+ * console.log(`Need ${size} bytes for Full HD RGB24`);
+ * ```
+ *
+ * @see {@link avImageAlloc} To allocate the buffer
  */
 export declare function avImageGetBufferSize(pixFmt: AVPixelFormat, width: number, height: number, align: number): number;
 /**
- * Copy image data to a single buffer.
+ * Copy image to buffer.
  *
- * Copies image data from separate planes into a single continuous buffer.
- * Useful for serialization or when a single buffer is required.
+ * Copies image data from separate planes to a single contiguous buffer.
  *
- * Direct mapping to av_image_copy_to_buffer()
+ * Direct mapping to av_image_copy_to_buffer().
  *
  * @param dst - Destination buffer
- * @param dstSize - Size of destination buffer in bytes
- * @param srcData - Array of source data planes
- * @param srcLinesize - Array of source linesizes
+ * @param dstSize - Destination buffer size
+ * @param srcData - Source data planes
+ * @param srcLinesize - Source bytes per line
  * @param pixFmt - Pixel format
- * @param width - Image width in pixels
- * @param height - Image height in pixels
+ * @param width - Image width
+ * @param height - Image height
  * @param align - Buffer alignment
- *
- * @returns Number of bytes written to dst, or negative AVERROR on error:
- *   - >0: Number of bytes written
- *   - AVERROR(EINVAL): Invalid parameters
- *   - AVERROR(ENOMEM): Destination buffer too small
+ * @returns Bytes written, or negative AVERROR
  *
  * @example
  * ```typescript
- * import { avImageCopyToBuffer, avImageGetBufferSize, FFmpegError } from 'node-av';
- * import { AV_PIX_FMT_RGB24 } from 'node-av';
- *
- * const width = 640, height = 480;
- * const pixFmt = AV_PIX_FMT_RGB24;
- *
- * // Calculate required buffer size
- * const dstSize = avImageGetBufferSize(pixFmt, width, height, 1);
- * const dst = Buffer.alloc(dstSize);
- *
- * const ret = avImageCopyToBuffer(
- *   dst, dstSize,
- *   srcData, srcLinesize,
- *   pixFmt, width, height, 1
+ * const buffer = Buffer.alloc(bufferSize);
+ * const written = avImageCopyToBuffer(
+ *   buffer, bufferSize,
+ *   srcPlanes, srcStrides,
+ *   AV_PIX_FMT_YUV420P, 1920, 1080, 1
  * );
- *
- * FFmpegError.throwIfError(ret, 'avImageCopyToBuffer');
- * console.log(`Copied ${ret} bytes to buffer`);
  * ```
  */
 export declare function avImageCopyToBuffer(dst: Buffer, dstSize: number, srcData: Buffer[] | null, srcLinesize: number[] | null, pixFmt: AVPixelFormat, width: number, height: number, align: number): number;
 /**
- * Convert timestamp to string
- * Direct mapping to av_ts2str()
+ * Convert timestamp to string.
+ *
+ * Converts a timestamp to a string representation.
+ *
+ * Direct mapping to av_ts2str().
+ *
+ * @param ts - Timestamp value
+ * @returns String representation
+ *
+ * @example
+ * ```typescript
+ * const str1 = avTs2Str(1234567n);  // Returns "1234567"
+ * const str2 = avTs2Str(null);      // Returns "NOPTS"
+ * ```
  */
 export declare function avTs2Str(ts: bigint | number | null): string;
 /**
- * Convert timestamp to time string
- * Direct mapping to av_ts2timestr()
+ * Convert timestamp to time string.
+ *
+ * Converts a timestamp to a time string using the specified time base.
+ *
+ * Direct mapping to av_ts2timestr().
+ *
+ * @param ts - Timestamp value
+ * @param timeBase - Time base for conversion
+ * @returns Time string representation
+ *
+ * @example
+ * ```typescript
+ * const timeStr = avTs2TimeStr(90000n, { num: 1, den: 90000 }); // Returns "1.000000"
+ * const nopts = avTs2TimeStr(null, { num: 1, den: 1000 });      // Returns "NOPTS"
+ * ```
  */
 export declare function avTs2TimeStr(ts: bigint | number | null, timeBase: IRational | null): string;
 /**
- * Helper to separate image allocation result into separate arrays
- * This is useful when you need separate data and linesize arrays
+ * Allocate image arrays.
+ *
+ * Allocates image data as separate plane arrays.
+ *
+ * @param width - Image width
+ * @param height - Image height
+ * @param pixFmt - Pixel format
+ * @param align - Buffer alignment
+ * @returns Object with data planes, line sizes, and total size
+ *
+ * @example
+ * ```typescript
+ * const { data, linesizes, size } = avImageAllocArrays(
+ *   1920, 1080, AV_PIX_FMT_YUV420P, 32
+ * );
+ * console.log(`Allocated ${data.length} planes, total ${size} bytes`);
+ * ```
  */
 export declare function avImageAllocArrays(width: number, height: number, pixFmt: AVPixelFormat, align: number): {
     data: Buffer[];
@@ -224,63 +351,116 @@ export declare function avImageAllocArrays(width: number, height: number, pixFmt
     size: number;
 };
 /**
- * Compare two timestamps
- * Direct mapping to av_compare_ts()
+ * Compare timestamps.
+ *
+ * Compares two timestamps with different time bases.
+ *
+ * Direct mapping to av_compare_ts().
+ *
+ * @param tsA - First timestamp
+ * @param tbA - First time base
+ * @param tsB - Second timestamp
+ * @param tbB - Second time base
+ * @returns -1 if A < B, 0 if A == B, 1 if A > B
  *
- * @returns -1 if tsA < tsB, 0 if tsA == tsB, 1 if tsA > tsB
+ * @example
+ * ```typescript
+ * const cmp = avCompareTs(
+ *   1000n, { num: 1, den: 1000 },  // 1 second
+ *   900n, { num: 1, den: 900 }      // 1 second
+ * );
+ * // Returns 0 (equal)
+ * ```
  */
 export declare function avCompareTs(tsA: bigint | number | null, tbA: IRational, tsB: bigint | number | null, tbB: IRational): number;
 /**
- * Rescale a timestamp from one timebase to another
- * Direct mapping to av_rescale_q()
- */
-export declare function avRescaleQ(a: bigint | number | null, bq: IRational, cq: IRational): bigint;
-/**
- * Sleep for a specified number of microseconds.
+ * Rescale timestamp.
  *
- * Provides a cross-platform microsecond sleep function.
- * Useful for timing operations or frame pacing.
+ * Rescales a timestamp from one time base to another.
  *
- * Direct mapping to av_usleep()
+ * Direct mapping to av_rescale_q().
  *
- * @param usec - Number of microseconds to sleep
+ * @param a - Timestamp to rescale
+ * @param bq - Source time base
+ * @param cq - Destination time base
+ * @returns Rescaled timestamp
  *
  * @example
  * ```typescript
- * import { avUsleep } from 'node-av';
+ * // Convert 1 second from 1000Hz to 90kHz
+ * const rescaled = avRescaleQ(
+ *   1000n,
+ *   { num: 1, den: 1000 },   // 1000 Hz
+ *   { num: 1, den: 90000 }   // 90 kHz
+ * );
+ * // Returns 90000n
+ * ```
+ */
+export declare function avRescaleQ(a: bigint | number | null, bq: IRational, cq: IRational): bigint;
+/**
+ * Sleep for microseconds.
+ *
+ * Suspends execution for the specified number of microseconds.
  *
- * // Sleep for 100ms (100,000 microseconds)
- * avUsleep(100000);
+ * Direct mapping to av_usleep().
  *
- * // Sleep for 1 second
- * avUsleep(1000000);
+ * @param usec - Microseconds to sleep
  *
- * // Frame pacing for 30fps (33.33ms per frame)
- * const frameTime = 1000000 / 30;
- * avUsleep(frameTime);
+ * @example
+ * ```typescript
+ * avUsleep(1000000); // Sleep for 1 second
+ * avUsleep(16667);   // Sleep for ~16.67ms (60fps frame time)
  * ```
  */
 export declare function avUsleep(usec: number): void;
 /**
- * Rescale a timestamp with rounding
- * Direct mapping to av_rescale_rnd()
+ * Rescale with rounding.
+ *
+ * Rescales a value with specified rounding behavior.
+ *
+ * Direct mapping to av_rescale_rnd().
  *
  * @param a - Value to rescale
- * @param b - Numerator of scale factor
- * @param c - Denominator of scale factor
- * @param rnd - Rounding mode (AVRounding enum)
+ * @param b - Multiplier
+ * @param c - Divisor
+ * @param rnd - Rounding mode (AV_ROUND_*)
  * @returns Rescaled value
+ *
+ * @example
+ * ```typescript
+ * import { AV_ROUND_NEAR_INF } from 'node-av/constants';
+ *
+ * const rescaled = avRescaleRnd(1000n, 90000n, 1000n, AV_ROUND_NEAR_INF);
+ * // Returns 90000n
+ * ```
  */
 export declare function avRescaleRnd(a: bigint | number, b: bigint | number, c: bigint | number, rnd: number): bigint;
 /**
- * Allocate audio sample buffers
- * Direct mapping to av_samples_alloc()
+ * Allocate audio samples buffer.
  *
- * @param nbChannels - Number of channels
+ * Allocates buffers for audio samples with the specified format.
+ *
+ * Direct mapping to av_samples_alloc().
+ *
+ * @param nbChannels - Number of audio channels
  * @param nbSamples - Number of samples per channel
  * @param sampleFmt - Sample format
- * @param align - Buffer alignment (0 for default)
- * @returns Object with allocated data buffers, linesize and total size, or error code
+ * @param align - Buffer alignment
+ * @returns Object with data buffers, line size, and total size
+ *
+ * @throws {FFmpegError} If allocation fails
+ *
+ * @example
+ * ```typescript
+ * import { AV_SAMPLE_FMT_FLTP } from 'node-av/constants';
+ *
+ * const { data, linesize, size } = avSamplesAlloc(
+ *   2, 1024, AV_SAMPLE_FMT_FLTP, 0
+ * );
+ * console.log(`Allocated ${data.length} buffers, ${size} bytes total`);
+ * ```
+ *
+ * @see {@link avSamplesGetBufferSize} To calculate size without allocating
  */
 export declare function avSamplesAlloc(nbChannels: number, nbSamples: number, sampleFmt: AVSampleFormat, align: number): {
     data: Buffer[];
@@ -288,59 +468,70 @@ export declare function avSamplesAlloc(nbChannels: number, nbSamples: number, sa
     size: number;
 };
 /**
- * Get the required buffer size for audio samples
- * Direct mapping to av_samples_get_buffer_size()
+ * Get audio samples buffer size.
+ *
+ * Calculates the required buffer size for audio samples.
+ *
+ * Direct mapping to av_samples_get_buffer_size().
  *
  * @param nbChannels - Number of channels
  * @param nbSamples - Number of samples per channel
  * @param sampleFmt - Sample format
- * @param align - Buffer alignment (0 for default)
- * @returns Object with size and linesize, or error code
+ * @param align - Buffer alignment
+ * @returns Object with size and line size
+ *
+ * @throws {FFmpegError} If parameters are invalid
+ *
+ * @example
+ * ```typescript
+ * import { AV_SAMPLE_FMT_S16 } from 'node-av/constants';
+ *
+ * const { size, linesize } = avSamplesGetBufferSize(
+ *   2, 1024, AV_SAMPLE_FMT_S16, 0
+ * );
+ * console.log(`Need ${size} bytes, ${linesize} per channel`);
+ * ```
+ *
+ * @see {@link avSamplesAlloc} To allocate the buffer
  */
 export declare function avSamplesGetBufferSize(nbChannels: number, nbSamples: number, sampleFmt: AVSampleFormat, align: number): {
     size: number;
     linesize: number;
 };
 /**
- * Get a string description of a channel layout.
- * Direct mapping to av_channel_layout_describe()
+ * Describe channel layout.
  *
- * @param channelLayout - The channel layout object with order, nbChannels, and mask
- * @returns String description of the channel layout, or null if invalid
+ * Returns a human-readable description of a channel layout.
+ *
+ * Direct mapping to av_channel_layout_describe().
+ *
+ * @param channelLayout - Channel layout to describe
+ * @returns Layout description string, or null
+ *
+ * @example
+ * ```typescript
+ * const stereo = { nbChannels: 2, order: 1, u: { mask: 3n } };
+ * const desc = avChannelLayoutDescribe(stereo); // Returns "stereo"
+ * ```
  */
 export declare function avChannelLayoutDescribe(channelLayout: Partial<ChannelLayout>): string | null;
 /**
- * Create an SDP (Session Description Protocol) string for RTP/RTSP streaming.
+ * Create SDP from format contexts.
  *
- * Generates an SDP description from one or more FormatContext objects.
- * Useful for RTP/RTSP streaming scenarios where you need to describe
- * the media streams to clients.
+ * Creates an SDP (Session Description Protocol) string from format contexts.
+ * Used for RTP/RTSP streaming.
  *
- * Direct mapping to av_sdp_create()
+ * Direct mapping to av_sdp_create().
  *
- * @param contexts - Array of FormatContext objects to describe
- * @returns SDP string on success, or null on failure
- *
- * @throws {FFmpegError} On invalid parameters or SDP creation failure
+ * @param contexts - Array of format contexts
+ * @returns SDP string, or null on error
  *
  * @example
  * ```typescript
- * import { avSdpCreate, FormatContext, FFmpegError } from 'node-av';
- *
- * // Create format contexts for RTP output
- * const contexts: FormatContext[] = [];
- *
- * const ctx = new FormatContext();
- * // ... configure context for RTP output ...
- * contexts.push(ctx);
- *
- * // Generate SDP
- * const sdp = avSdpCreate(contexts);
+ * const sdp = avSdpCreate([outputContext]);
  * if (sdp) {
- *   console.log('SDP:', result);
+ *   console.log('SDP:\n' + sdp);
  * }
- *
- * // Use the SDP string for RTSP server or save to .sdp file
  * ```
  */
 export declare function avSdpCreate(contexts: FormatContext[]): string | null;