node-av 0.0.1

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

@@ -0,0 +1,104 @@
+/**
+ * Streaming Utilities
+ *
+ * Provides utilities for working with streaming protocols in FFmpeg.
+ * Includes SDP generation for RTP/RTSP streaming and helper methods.
+ *
+ * @module api/utilities/streaming
+ */
+import type { MediaInput } from '../media-input.js';
+import type { MediaOutput } from '../media-output.js';
+/**
+ * Streaming protocol utilities.
+ *
+ * Provides static methods for SDP generation, RTP URL building, and
+ * network streaming helpers for RTP/RTSP protocols.
+ *
+ * @example
+ * ```typescript
+ * import { StreamingUtils, MediaOutput } from 'node-av/api';
+ *
+ * // Create RTP outputs
+ * const videoOutput = await MediaOutput.create('rtp://127.0.0.1:5004');
+ * const audioOutput = await MediaOutput.create('rtp://127.0.0.1:5006');
+ *
+ * // Generate SDP for streaming
+ * const sdp = StreamingUtils.createSdp([videoOutput, audioOutput]);
+ * if (sdp) {
+ *   console.log('SDP for streaming:', sdp);
+ *   // Save to .sdp file or serve via RTSP server
+ * }
+ * ```
+ */
+export declare class StreamingUtils {
+    /**
+     * Create an SDP (Session Description Protocol) string from media inputs/outputs
+     *
+     * Generates an SDP description for RTP/RTSP streaming from one or more
+     * configured media inputs/outputs. The inputs/outputs should be configured with RTP
+     * format and have their streams set up before calling this method.
+     *
+     * @param inouts - Array of MediaInput or MediaOutput objects configured for RTP
+     * @returns SDP string if successful, null if failed
+     *
+     * @example
+     * ```typescript
+     * // Set up RTP outputs with streams
+     * const output1 = await MediaOutput.create('rtp://239.0.0.1:5004');
+     * await output1.addVideoStream(encoder1);
+     *
+     * const output2 = await MediaOutput.create('rtp://239.0.0.1:5006');
+     * await output2.addAudioStream(encoder2);
+     *
+     * // Generate SDP for multicast streaming
+     * const sdp = StreamingUtils.createSdp([output1, output2]);
+     * if (sdp) {
+     *   // Write to file for VLC or other players
+     *   await fs.writeFile('stream.sdp', sdp);
+     * }
+     * ```
+     */
+    static createSdp(inouts: MediaInput[] | MediaOutput[]): string | null;
+    /**
+     * Validate if an output is configured for RTP streaming
+     *
+     * @param output - MediaOutput to check
+     * @returns true if configured for RTP
+     *
+     * @example
+     * ```typescript
+     * const output = await MediaOutput.create('rtp://127.0.0.1:5004');
+     * if (StreamingUtils.isRtpOutput(output)) {
+     *   const sdp = StreamingUtils.createSdpForOutput(output);
+     * }
+     * ```
+     */
+    static isRtpOutput(output: MediaOutput): boolean;
+    /**
+     * Build RTP URL from components
+     *
+     * Helper to construct RTP URLs with proper formatting.
+     *
+     * @param host - IP address or hostname
+     * @param port - Port number
+     * @param options - Additional options
+     * @returns Formatted RTP URL
+     *
+     * @example
+     * ```typescript
+     * // Unicast
+     * const url1 = StreamingUtils.buildRtpUrl('127.0.0.1', 5004);
+     * // 'rtp://127.0.0.1:5004'
+     *
+     * // Multicast
+     * const url2 = StreamingUtils.buildRtpUrl('239.0.0.1', 5004, { ttl: 64 });
+     * // 'rtp://239.0.0.1:5004?ttl=64'
+     * ```
+     */
+    static buildRtpUrl(host: string, port: number, options?: {
+        ttl?: number;
+        localrtpport?: number;
+        localrtcpport?: number;
+        pkt_size?: number;
+    }): string;
+}

package/dist/api/utilities/streaming.js

@@ -0,0 +1,137 @@
+/**
+ * Streaming Utilities
+ *
+ * Provides utilities for working with streaming protocols in FFmpeg.
+ * Includes SDP generation for RTP/RTSP streaming and helper methods.
+ *
+ * @module api/utilities/streaming
+ */
+import { avSdpCreate } from '../../lib/utilities.js';
+/**
+ * Streaming protocol utilities.
+ *
+ * Provides static methods for SDP generation, RTP URL building, and
+ * network streaming helpers for RTP/RTSP protocols.
+ *
+ * @example
+ * ```typescript
+ * import { StreamingUtils, MediaOutput } from 'node-av/api';
+ *
+ * // Create RTP outputs
+ * const videoOutput = await MediaOutput.create('rtp://127.0.0.1:5004');
+ * const audioOutput = await MediaOutput.create('rtp://127.0.0.1:5006');
+ *
+ * // Generate SDP for streaming
+ * const sdp = StreamingUtils.createSdp([videoOutput, audioOutput]);
+ * if (sdp) {
+ *   console.log('SDP for streaming:', sdp);
+ *   // Save to .sdp file or serve via RTSP server
+ * }
+ * ```
+ */
+export class StreamingUtils {
+    /**
+     * Create an SDP (Session Description Protocol) string from media inputs/outputs
+     *
+     * Generates an SDP description for RTP/RTSP streaming from one or more
+     * configured media inputs/outputs. The inputs/outputs should be configured with RTP
+     * format and have their streams set up before calling this method.
+     *
+     * @param inouts - Array of MediaInput or MediaOutput objects configured for RTP
+     * @returns SDP string if successful, null if failed
+     *
+     * @example
+     * ```typescript
+     * // Set up RTP outputs with streams
+     * const output1 = await MediaOutput.create('rtp://239.0.0.1:5004');
+     * await output1.addVideoStream(encoder1);
+     *
+     * const output2 = await MediaOutput.create('rtp://239.0.0.1:5006');
+     * await output2.addAudioStream(encoder2);
+     *
+     * // Generate SDP for multicast streaming
+     * const sdp = StreamingUtils.createSdp([output1, output2]);
+     * if (sdp) {
+     *   // Write to file for VLC or other players
+     *   await fs.writeFile('stream.sdp', sdp);
+     * }
+     * ```
+     */
+    static createSdp(inouts) {
+        if (!inouts || inouts.length === 0) {
+            return null;
+        }
+        // Extract FormatContext from each MediaOutput
+        const contexts = inouts
+            .map((inout) => {
+            return inout.getFormatContext();
+        })
+            .filter((ctx) => ctx != null);
+        if (contexts.length === 0) {
+            return null;
+        }
+        return avSdpCreate(contexts);
+    }
+    /**
+     * Validate if an output is configured for RTP streaming
+     *
+     * @param output - MediaOutput to check
+     * @returns true if configured for RTP
+     *
+     * @example
+     * ```typescript
+     * const output = await MediaOutput.create('rtp://127.0.0.1:5004');
+     * if (StreamingUtils.isRtpOutput(output)) {
+     *   const sdp = StreamingUtils.createSdpForOutput(output);
+     * }
+     * ```
+     */
+    static isRtpOutput(output) {
+        // Check if the output format is RTP
+        const formatContext = output.getFormatContext();
+        const oformat = formatContext?.oformat;
+        if (oformat) {
+            const name = oformat.name;
+            return name === 'rtp' || name === 'rtp_mpegts';
+        }
+        return false;
+    }
+    /**
+     * Build RTP URL from components
+     *
+     * Helper to construct RTP URLs with proper formatting.
+     *
+     * @param host - IP address or hostname
+     * @param port - Port number
+     * @param options - Additional options
+     * @returns Formatted RTP URL
+     *
+     * @example
+     * ```typescript
+     * // Unicast
+     * const url1 = StreamingUtils.buildRtpUrl('127.0.0.1', 5004);
+     * // 'rtp://127.0.0.1:5004'
+     *
+     * // Multicast
+     * const url2 = StreamingUtils.buildRtpUrl('239.0.0.1', 5004, { ttl: 64 });
+     * // 'rtp://239.0.0.1:5004?ttl=64'
+     * ```
+     */
+    static buildRtpUrl(host, port, options) {
+        let url = `rtp://${host}:${port}`;
+        if (options && Object.keys(options).length > 0) {
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(options)) {
+                if (value !== undefined) {
+                    params.append(key, String(value));
+                }
+            }
+            const queryString = params.toString();
+            if (queryString) {
+                url += `?${queryString}`;
+            }
+        }
+        return url;
+    }
+}
+//# sourceMappingURL=streaming.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.js","sourceRoot":"","sources":["../../../src/api/utilities/streaming.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAKrD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,cAAc;IACzB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,MAAM,CAAC,SAAS,CAAC,MAAoC;QACnD,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACnC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,8CAA8C;QAC9C,MAAM,QAAQ,GAAG,MAAM;aACpB,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;YACb,OAAO,KAAK,CAAC,gBAAgB,EAAE,CAAC;QAClC,CAAC,CAAC;aACD,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC;QAEhC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,WAAW,CAAC,MAAmB;QACpC,oCAAoC;QACpC,MAAM,aAAa,GAAG,MAAM,CAAC,gBAAgB,EAAE,CAAC;QAChD,MAAM,OAAO,GAAG,aAAa,EAAE,OAAO,CAAC;QACvC,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;YAC1B,OAAO,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,YAAY,CAAC;QACjD,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,WAAW,CAChB,IAAY,EACZ,IAAY,EACZ,OAKC;QAED,IAAI,GAAG,GAAG,SAAS,IAAI,IAAI,IAAI,EAAE,CAAC;QAElC,IAAI,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/C,MAAM,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;YACrC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;gBACnD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;oBACxB,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;gBACpC,CAAC;YACH,CAAC;YACD,MAAM,WAAW,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;YACtC,IAAI,WAAW,EAAE,CAAC;gBAChB,GAAG,IAAI,IAAI,WAAW,EAAE,CAAC;YAC3B,CAAC;QACH,CAAC;QAED,OAAO,GAAG,CAAC;IACb,CAAC;CACF"}

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

@@ -0,0 +1,187 @@
+/**
+ * Timestamp Utilities
+ *
+ * Provides utilities for working with timestamps in FFmpeg.
+ * All methods are static and map directly to FFmpeg's libavutil functions.
+ *
+ * @module lib/timestamp-utils
+ */
+import type { AVRounding } from '../../lib/constants.js';
+import type { IRational } from '../../lib/types.js';
+/**
+ * Timestamp and time base utilities.
+ *
+ * Provides static methods for converting, rescaling, and comparing timestamps.
+ * These utilities are essential for working with different time bases in
+ * multimedia streams.
+ *
+ * @example
+ * ```typescript
+ * import { TimestampUtils } from 'node-av';
+ * import { AV_ROUND_NEAR_INF } from 'node-av/constants';
+ *
+ * // Convert timestamp to string representations
+ * const pts = 450000n;
+ * console.log(TimestampUtils.toString(pts));                    // "450000"
+ *
+ * const timebase = { num: 1, den: 90000 };
+ * console.log(TimestampUtils.toTimeString(pts, timebase));      // "5.000000"
+ *
+ * // Rescale between time bases
+ * const srcTb = { num: 1, den: 90000 };
+ * const dstTb = { num: 1, den: 1000 };
+ * const rescaled = TimestampUtils.rescale(pts, srcTb, dstTb);
+ * console.log(rescaled);                                         // 5000n
+ * ```
+ */
+export declare class TimestampUtils {
+    private constructor();
+    /**
+     * Convert timestamp to string.
+     *
+     * Converts a timestamp value to its string representation.
+     * Handles special values like AV_NOPTS_VALUE.
+     * Direct mapping to av_ts2str()
+     *
+     * @param ts - Timestamp value (bigint or number), or null
+     * @returns String representation
+     *
+     * @example
+     * ```typescript
+     * import { TimestampUtils } from 'node-av';
+     * import { AV_NOPTS_VALUE } from 'node-av/constants';
+     *
+     * console.log(TimestampUtils.toString(12345n));        // "12345"
+     * console.log(TimestampUtils.toString(AV_NOPTS_VALUE)); // "NOPTS"
+     * console.log(TimestampUtils.toString(null));          // "NOPTS"
+     * ```
+     */
+    static toString(ts: bigint | number | null): string;
+    /**
+     * Convert timestamp to time string.
+     *
+     * Converts a timestamp to a time string in seconds using the provided time base.
+     * Direct mapping to av_ts2timestr()
+     *
+     * @param ts - Timestamp value
+     * @param timeBase - Time base for conversion
+     * @returns Time string in seconds with decimal places
+     *
+     * @example
+     * ```typescript
+     * import { TimestampUtils } from 'node-av';
+     *
+     * const pts = 450000n;
+     * const timebase = { num: 1, den: 90000 }; // 90kHz
+     *
+     * console.log(TimestampUtils.toTimeString(pts, timebase));     // "5.000000"
+     * console.log(TimestampUtils.toTimeString(90000n, timebase));  // "1.000000"
+     * ```
+     */
+    static toTimeString(ts: bigint | number | null, timeBase: IRational): string;
+    /**
+     * Compare timestamps from different time bases.
+     *
+     * Compares two timestamps that may have different time bases.
+     * Direct mapping to av_compare_ts()
+     *
+     * @param tsA - First timestamp
+     * @param tbA - Time base of first timestamp
+     * @param tsB - Second timestamp
+     * @param tbB - Time base of second timestamp
+     * @returns -1 if tsA < tsB, 0 if equal, 1 if tsA > tsB
+     *
+     * @example
+     * ```typescript
+     * import { TimestampUtils } from 'node-av';
+     *
+     * // Compare timestamps from different time bases
+     * const pts1 = 90000n;
+     * const tb1 = { num: 1, den: 90000 };  // 1 second in 90kHz
+     *
+     * const pts2 = 1000n;
+     * const tb2 = { num: 1, den: 1000 };   // 1 second in 1kHz
+     *
+     * const result = TimestampUtils.compare(pts1, tb1, pts2, tb2);
+     * console.log(result); // 0 (equal - both represent 1 second)
+     * ```
+     */
+    static compare(tsA: bigint | number | null, tbA: IRational, tsB: bigint | number | null, tbB: IRational): number;
+    /**
+     * Rescale timestamp from one time base to another.
+     *
+     * Converts a timestamp from source time base to destination time base.
+     * Uses AV_ROUND_NEAR_INF rounding.
+     * Direct mapping to av_rescale_q()
+     *
+     * @param a - Timestamp to rescale
+     * @param bq - Source time base
+     * @param cq - Destination time base
+     * @returns Rescaled timestamp
+     *
+     * @example
+     * ```typescript
+     * import { TimestampUtils } from 'node-av';
+     *
+     * // Convert from 90kHz to milliseconds
+     * const pts = 450000n;
+     * const srcTb = { num: 1, den: 90000 };
+     * const dstTb = { num: 1, den: 1000 };
+     *
+     * const rescaled = TimestampUtils.rescale(pts, srcTb, dstTb);
+     * console.log(rescaled); // 5000n (5000 milliseconds = 5 seconds)
+     * ```
+     */
+    static rescale(a: bigint | number | null, bq: IRational, cq: IRational): bigint;
+    /**
+     * Rescale with specified rounding.
+     *
+     * Rescales a value with explicit rounding mode.
+     * More general than rescale() as it doesn't use time bases.
+     * Direct mapping to av_rescale_rnd()
+     *
+     * @param a - Value to rescale
+     * @param b - Multiplier
+     * @param c - Divisor
+     * @param rnd - Rounding mode
+     * @returns Rescaled value: a * b / c
+     *
+     * @example
+     * ```typescript
+     * import { TimestampUtils } from 'node-av';
+     * import { AV_ROUND_UP, AV_ROUND_DOWN } from 'node-av/constants';
+     *
+     * // Scale with different rounding modes
+     * const value = 100n;
+     * const mul = 3n;
+     * const div = 7n;
+     *
+     * const roundUp = TimestampUtils.rescaleRounded(value, mul, div, AV_ROUND_UP);
+     * const roundDown = TimestampUtils.rescaleRounded(value, mul, div, AV_ROUND_DOWN);
+     *
+     * console.log(roundUp);   // 43n (rounds up)
+     * console.log(roundDown); // 42n (rounds down)
+     * ```
+     */
+    static rescaleRounded(a: bigint | number, b: bigint | number, c: bigint | number, rnd: AVRounding): bigint;
+    /**
+     * Sleep for specified microseconds.
+     *
+     * Sleeps for the specified number of microseconds.
+     * Direct mapping to av_usleep()
+     *
+     * @param usec - Microseconds to sleep
+     *
+     * @example
+     * ```typescript
+     * import { TimestampUtils } from 'node-av';
+     *
+     * // Sleep for 100 milliseconds
+     * TimestampUtils.sleep(100000);
+     *
+     * // Sleep for 1 second
+     * TimestampUtils.sleep(1000000);
+     * ```
+     */
+    static sleep(usec: number): void;
+}

package/dist/api/utilities/timestamp.js

@@ -0,0 +1,200 @@
+/**
+ * Timestamp Utilities
+ *
+ * Provides utilities for working with timestamps in FFmpeg.
+ * All methods are static and map directly to FFmpeg's libavutil functions.
+ *
+ * @module lib/timestamp-utils
+ */
+import { bindings } from '../../lib/binding.js';
+/**
+ * Timestamp and time base utilities.
+ *
+ * Provides static methods for converting, rescaling, and comparing timestamps.
+ * These utilities are essential for working with different time bases in
+ * multimedia streams.
+ *
+ * @example
+ * ```typescript
+ * import { TimestampUtils } from 'node-av';
+ * import { AV_ROUND_NEAR_INF } from 'node-av/constants';
+ *
+ * // Convert timestamp to string representations
+ * const pts = 450000n;
+ * console.log(TimestampUtils.toString(pts));                    // "450000"
+ *
+ * const timebase = { num: 1, den: 90000 };
+ * console.log(TimestampUtils.toTimeString(pts, timebase));      // "5.000000"
+ *
+ * // Rescale between time bases
+ * const srcTb = { num: 1, den: 90000 };
+ * const dstTb = { num: 1, den: 1000 };
+ * const rescaled = TimestampUtils.rescale(pts, srcTb, dstTb);
+ * console.log(rescaled);                                         // 5000n
+ * ```
+ */
+export class TimestampUtils {
+    // Private constructor to prevent instantiation
+    constructor() { }
+    /**
+     * Convert timestamp to string.
+     *
+     * Converts a timestamp value to its string representation.
+     * Handles special values like AV_NOPTS_VALUE.
+     * Direct mapping to av_ts2str()
+     *
+     * @param ts - Timestamp value (bigint or number), or null
+     * @returns String representation
+     *
+     * @example
+     * ```typescript
+     * import { TimestampUtils } from 'node-av';
+     * import { AV_NOPTS_VALUE } from 'node-av/constants';
+     *
+     * console.log(TimestampUtils.toString(12345n));        // "12345"
+     * console.log(TimestampUtils.toString(AV_NOPTS_VALUE)); // "NOPTS"
+     * console.log(TimestampUtils.toString(null));          // "NOPTS"
+     * ```
+     */
+    static toString(ts) {
+        return bindings.avTs2Str(ts);
+    }
+    /**
+     * Convert timestamp to time string.
+     *
+     * Converts a timestamp to a time string in seconds using the provided time base.
+     * Direct mapping to av_ts2timestr()
+     *
+     * @param ts - Timestamp value
+     * @param timeBase - Time base for conversion
+     * @returns Time string in seconds with decimal places
+     *
+     * @example
+     * ```typescript
+     * import { TimestampUtils } from 'node-av';
+     *
+     * const pts = 450000n;
+     * const timebase = { num: 1, den: 90000 }; // 90kHz
+     *
+     * console.log(TimestampUtils.toTimeString(pts, timebase));     // "5.000000"
+     * console.log(TimestampUtils.toTimeString(90000n, timebase));  // "1.000000"
+     * ```
+     */
+    static toTimeString(ts, timeBase) {
+        return bindings.avTs2TimeStr(ts, timeBase);
+    }
+    /**
+     * Compare timestamps from different time bases.
+     *
+     * Compares two timestamps that may have different time bases.
+     * Direct mapping to av_compare_ts()
+     *
+     * @param tsA - First timestamp
+     * @param tbA - Time base of first timestamp
+     * @param tsB - Second timestamp
+     * @param tbB - Time base of second timestamp
+     * @returns -1 if tsA < tsB, 0 if equal, 1 if tsA > tsB
+     *
+     * @example
+     * ```typescript
+     * import { TimestampUtils } from 'node-av';
+     *
+     * // Compare timestamps from different time bases
+     * const pts1 = 90000n;
+     * const tb1 = { num: 1, den: 90000 };  // 1 second in 90kHz
+     *
+     * const pts2 = 1000n;
+     * const tb2 = { num: 1, den: 1000 };   // 1 second in 1kHz
+     *
+     * const result = TimestampUtils.compare(pts1, tb1, pts2, tb2);
+     * console.log(result); // 0 (equal - both represent 1 second)
+     * ```
+     */
+    static compare(tsA, tbA, tsB, tbB) {
+        return bindings.avCompareTs(tsA, tbA, tsB, tbB);
+    }
+    /**
+     * Rescale timestamp from one time base to another.
+     *
+     * Converts a timestamp from source time base to destination time base.
+     * Uses AV_ROUND_NEAR_INF rounding.
+     * Direct mapping to av_rescale_q()
+     *
+     * @param a - Timestamp to rescale
+     * @param bq - Source time base
+     * @param cq - Destination time base
+     * @returns Rescaled timestamp
+     *
+     * @example
+     * ```typescript
+     * import { TimestampUtils } from 'node-av';
+     *
+     * // Convert from 90kHz to milliseconds
+     * const pts = 450000n;
+     * const srcTb = { num: 1, den: 90000 };
+     * const dstTb = { num: 1, den: 1000 };
+     *
+     * const rescaled = TimestampUtils.rescale(pts, srcTb, dstTb);
+     * console.log(rescaled); // 5000n (5000 milliseconds = 5 seconds)
+     * ```
+     */
+    static rescale(a, bq, cq) {
+        return bindings.avRescaleQ(a, bq, cq);
+    }
+    /**
+     * Rescale with specified rounding.
+     *
+     * Rescales a value with explicit rounding mode.
+     * More general than rescale() as it doesn't use time bases.
+     * Direct mapping to av_rescale_rnd()
+     *
+     * @param a - Value to rescale
+     * @param b - Multiplier
+     * @param c - Divisor
+     * @param rnd - Rounding mode
+     * @returns Rescaled value: a * b / c
+     *
+     * @example
+     * ```typescript
+     * import { TimestampUtils } from 'node-av';
+     * import { AV_ROUND_UP, AV_ROUND_DOWN } from 'node-av/constants';
+     *
+     * // Scale with different rounding modes
+     * const value = 100n;
+     * const mul = 3n;
+     * const div = 7n;
+     *
+     * const roundUp = TimestampUtils.rescaleRounded(value, mul, div, AV_ROUND_UP);
+     * const roundDown = TimestampUtils.rescaleRounded(value, mul, div, AV_ROUND_DOWN);
+     *
+     * console.log(roundUp);   // 43n (rounds up)
+     * console.log(roundDown); // 42n (rounds down)
+     * ```
+     */
+    static rescaleRounded(a, b, c, rnd) {
+        return bindings.avRescaleRnd(a, b, c, rnd);
+    }
+    /**
+     * Sleep for specified microseconds.
+     *
+     * Sleeps for the specified number of microseconds.
+     * Direct mapping to av_usleep()
+     *
+     * @param usec - Microseconds to sleep
+     *
+     * @example
+     * ```typescript
+     * import { TimestampUtils } from 'node-av';
+     *
+     * // Sleep for 100 milliseconds
+     * TimestampUtils.sleep(100000);
+     *
+     * // Sleep for 1 second
+     * TimestampUtils.sleep(1000000);
+     * ```
+     */
+    static sleep(usec) {
+        bindings.avUsleep(usec);
+    }
+}
+//# sourceMappingURL=timestamp.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp.js","sourceRoot":"","sources":["../../../src/api/utilities/timestamp.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAKhD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,OAAO,cAAc;IACzB,+CAA+C;IAC/C,gBAAuB,CAAC;IAExB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,QAAQ,CAAC,EAA0B;QACxC,OAAO,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,YAAY,CAAC,EAA0B,EAAE,QAAmB;QACjE,OAAO,QAAQ,CAAC,YAAY,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,MAAM,CAAC,OAAO,CAAC,GAA2B,EAAE,GAAc,EAAE,GAA2B,EAAE,GAAc;QACrG,OAAO,QAAQ,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IAClD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,OAAO,CAAC,CAAyB,EAAE,EAAa,EAAE,EAAa;QACpE,OAAO,QAAQ,CAAC,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,MAAM,CAAC,cAAc,CAAC,CAAkB,EAAE,CAAkB,EAAE,CAAkB,EAAE,GAAe;QAC/F,OAAO,QAAQ,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,KAAK,CAAC,IAAY;QACvB,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;CACF"}

package/dist/api/utils.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Parse bitrate string to bigint.
+ *
+ * Supports suffixes: K (kilo), M (mega), G (giga).
+ *
+ * Converts human-readable bitrate strings to numeric values.
+ *
+ * @param str - Bitrate string (e.g., '5M', '192k')
+ *
+ * @returns Bitrate as bigint
+ *
+ * @example
+ * ```typescript
+ * parseBitrate('5M')   // 5000000n
+ * parseBitrate('192k') // 192000n
+ * parseBitrate('1.5G') // 1500000000n
+ * ```
+ */
+export declare function parseBitrate(str: string): bigint;
+export interface Extension {
+    id: number;
+    payload: Buffer;
+}
+export declare const ExtensionProfiles: {
+    readonly OneByte: 48862;
+    readonly TwoByte: 4096;
+};
+type ExtensionProfile = (typeof ExtensionProfiles)[keyof typeof ExtensionProfiles];
+export declare class RtpHeader {
+    version: number;
+    padding: boolean;
+    paddingSize: number;
+    extension: boolean;
+    marker: boolean;
+    payloadOffset: number;
+    payloadType: number;
+    sequenceNumber: number;
+    timestamp: number;
+    ssrc: number;
+    csrcLength: number;
+    csrc: number[];
+    extensionProfile: ExtensionProfile;
+    /** deserialize only */
+    extensionLength?: number;
+    extensions: Extension[];
+    constructor(props?: Partial<RtpHeader>);
+    static deSerialize(rawPacket: Buffer): RtpHeader;
+    get serializeSize(): number;
+    serialize(size: number): Buffer<ArrayBuffer>;
+}
+export declare class RtpPacket {
+    header: RtpHeader;
+    payload: Buffer;
+    constructor(header: RtpHeader, payload: Buffer);
+    get serializeSize(): number;
+    clone(): RtpPacket;
+    serialize(): Buffer<ArrayBuffer>;
+    static deSerialize(buf: Buffer): RtpPacket;
+    clear(): void;
+}
+export {};