mediabunny 1.0.2 → 1.0.4

package/dist/modules/output.d.ts

@@ -0,0 +1,134 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { Rotation } from './misc';
+import { OutputFormat } from './output-format';
+import { AudioSource, SubtitleSource, VideoSource } from './media-source';
+import { Target } from './target';
+/**
+ * The options for creating an Output object.
+ * @public
+ */
+export type OutputOptions<F extends OutputFormat = OutputFormat, T extends Target = Target> = {
+    /** The format of the output file. */
+    format: F;
+    /** The target to which the file will be written. */
+    target: T;
+};
+/**
+ * List of all track types.
+ * @public
+ */
+export declare const ALL_TRACK_TYPES: readonly ["video", "audio", "subtitle"];
+/**
+ * Union type of all track types.
+ * @public
+ */
+export type TrackType = typeof ALL_TRACK_TYPES[number];
+export type OutputTrack = {
+    id: number;
+    output: Output;
+    type: TrackType;
+} & ({
+    type: 'video';
+    source: VideoSource;
+    metadata: VideoTrackMetadata;
+} | {
+    type: 'audio';
+    source: AudioSource;
+    metadata: AudioTrackMetadata;
+} | {
+    type: 'subtitle';
+    source: SubtitleSource;
+    metadata: SubtitleTrackMetadata;
+});
+export type OutputVideoTrack = OutputTrack & {
+    type: 'video';
+};
+export type OutputAudioTrack = OutputTrack & {
+    type: 'audio';
+};
+export type OutputSubtitleTrack = OutputTrack & {
+    type: 'subtitle';
+};
+/**
+ * Base track metadata, applicable to all tracks.
+ * @public
+ */
+export type BaseTrackMetadata = {
+    /** The three-letter, ISO 639-2/T language code specifying the language of this track. */
+    languageCode?: string;
+};
+/**
+ * Additional metadata for video tracks.
+ * @public
+ */
+export type VideoTrackMetadata = BaseTrackMetadata & {
+    /** The angle in degrees by which the track's frames should be rotated (clockwise). */
+    rotation?: Rotation;
+    /**
+     * The expected video frame rate in hertz. If set, all timestamps and durations of this track will be snapped to
+     * this frame rate. You should avoid adding more frames than the rate allows, as this will lead to multiple frames
+     * with the same timestamp.
+     */
+    frameRate?: number;
+};
+/**
+ * Additional metadata for audio tracks.
+ * @public
+ */
+export type AudioTrackMetadata = BaseTrackMetadata & {};
+/**
+ * Additional metadata for subtitle tracks.
+ * @public
+ */
+export type SubtitleTrackMetadata = BaseTrackMetadata & {};
+/**
+ * Main class orchestrating the creation of a new media file.
+ * @public
+ */
+export declare class Output<F extends OutputFormat = OutputFormat, T extends Target = Target> {
+    /** The format of the output file. */
+    format: F;
+    /** The target to which the file will be written. */
+    target: T;
+    /** The current state of the output. */
+    state: 'pending' | 'started' | 'canceled' | 'finalizing' | 'finalized';
+    constructor(options: OutputOptions<F, T>);
+    /** Adds a video track to the output with the given source. Must be called before output is started. */
+    addVideoTrack(source: VideoSource, metadata?: VideoTrackMetadata): void;
+    /** Adds an audio track to the output with the given source. Must be called before output is started. */
+    addAudioTrack(source: AudioSource, metadata?: AudioTrackMetadata): void;
+    /** Adds a subtitle track to the output with the given source. Must be called before output is started. */
+    addSubtitleTrack(source: SubtitleSource, metadata?: SubtitleTrackMetadata): void;
+    /**
+     * Starts the creation of the output file. This method should be called after all tracks have been added. Only after
+     * the output has started can media samples be added to the tracks.
+     *
+     * @returns A promise that resolves when the output has successfully started and is ready to receive media samples.
+     */
+    start(): Promise<void>;
+    /**
+     * Resolves with the full MIME type of the output file, including track codecs.
+     *
+     * The returned promise will resolve only once the precise codec strings of all tracks are known.
+     */
+    getMimeType(): Promise<string>;
+    /**
+     * Cancels the creation of the output file, releasing internal resources like encoders and preventing further
+     * samples from being added.
+     *
+     * @returns A promise that resolves once all internal resources have been released.
+     */
+    cancel(): Promise<void>;
+    /**
+     * Finalizes the output file. This method must be called after all media samples across all tracks have been added.
+     * Once the Promise returned by this method completes, the output file is ready.
+     */
+    finalize(): Promise<void>;
+}
+//# sourceMappingURL=output.d.ts.map

package/dist/modules/output.d.ts.map

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

package/dist/modules/output.js

@@ -0,0 +1,269 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { AsyncMutex, isIso639Dash2LanguageCode } from './misc.js';
+import { OutputFormat } from './output-format.js';
+import { AudioSource, SubtitleSource, VideoSource } from './media-source.js';
+import { Target } from './target.js';
+/**
+ * List of all track types.
+ * @public
+ */
+export const ALL_TRACK_TYPES = ['video', 'audio', 'subtitle'];
+const validateBaseTrackMetadata = (metadata) => {
+    if (!metadata || typeof metadata !== 'object') {
+        throw new TypeError('metadata must be an object.');
+    }
+    if (metadata.languageCode !== undefined && !isIso639Dash2LanguageCode(metadata.languageCode)) {
+        throw new TypeError('metadata.languageCode must be a three-letter, ISO 639-2/T language code.');
+    }
+};
+/**
+ * Main class orchestrating the creation of a new media file.
+ * @public
+ */
+export class Output {
+    constructor(options) {
+        /** The current state of the output. */
+        this.state = 'pending';
+        /** @internal */
+        this._tracks = [];
+        /** @internal */
+        this._startPromise = null;
+        /** @internal */
+        this._cancelPromise = null;
+        /** @internal */
+        this._finalizePromise = null;
+        /** @internal */
+        this._mutex = new AsyncMutex();
+        if (!options || typeof options !== 'object') {
+            throw new TypeError('options must be an object.');
+        }
+        if (!(options.format instanceof OutputFormat)) {
+            throw new TypeError('options.format must be an OutputFormat.');
+        }
+        if (!(options.target instanceof Target)) {
+            throw new TypeError('options.target must be a Target.');
+        }
+        if (options.target._output) {
+            throw new Error('Target is already used for another output.');
+        }
+        options.target._output = this;
+        this.format = options.format;
+        this.target = options.target;
+        this._writer = options.target._createWriter();
+        this._muxer = options.format._createMuxer(this);
+    }
+    /** Adds a video track to the output with the given source. Must be called before output is started. */
+    addVideoTrack(source, metadata = {}) {
+        if (!(source instanceof VideoSource)) {
+            throw new TypeError('source must be a VideoSource.');
+        }
+        validateBaseTrackMetadata(metadata);
+        if (metadata.rotation !== undefined && ![0, 90, 180, 270].includes(metadata.rotation)) {
+            throw new TypeError(`Invalid video rotation: ${metadata.rotation}. Has to be 0, 90, 180 or 270.`);
+        }
+        if (!this.format.supportsVideoRotationMetadata && metadata.rotation) {
+            throw new Error(`${this.format._name} does not support video rotation metadata.`);
+        }
+        if (metadata.frameRate !== undefined
+            && (!Number.isFinite(metadata.frameRate) || metadata.frameRate <= 0)) {
+            throw new TypeError(`Invalid video frame rate: ${metadata.frameRate}. Must be a positive number.`);
+        }
+        this._addTrack('video', source, metadata);
+    }
+    /** Adds an audio track to the output with the given source. Must be called before output is started. */
+    addAudioTrack(source, metadata = {}) {
+        if (!(source instanceof AudioSource)) {
+            throw new TypeError('source must be an AudioSource.');
+        }
+        validateBaseTrackMetadata(metadata);
+        this._addTrack('audio', source, metadata);
+    }
+    /** Adds a subtitle track to the output with the given source. Must be called before output is started. */
+    addSubtitleTrack(source, metadata = {}) {
+        if (!(source instanceof SubtitleSource)) {
+            throw new TypeError('source must be a SubtitleSource.');
+        }
+        validateBaseTrackMetadata(metadata);
+        this._addTrack('subtitle', source, metadata);
+    }
+    /** @internal */
+    _addTrack(type, source, metadata) {
+        if (this.state !== 'pending') {
+            throw new Error('Cannot add track after output has been started or canceled.');
+        }
+        if (source._connectedTrack) {
+            throw new Error('Source is already used for a track.');
+        }
+        // Verify maximum track count constraints
+        const supportedTrackCounts = this.format.getSupportedTrackCounts();
+        const presentTracksOfThisType = this._tracks.reduce((count, track) => count + (track.type === type ? 1 : 0), 0);
+        const maxCount = supportedTrackCounts[type].max;
+        if (presentTracksOfThisType === maxCount) {
+            throw new Error(maxCount === 0
+                ? `${this.format._name} does not support ${type} tracks.`
+                : (`${this.format._name} does not support more than ${maxCount} ${type} track`
+                    + `${maxCount === 1 ? '' : 's'}.`));
+        }
+        const maxTotalCount = supportedTrackCounts.total.max;
+        if (this._tracks.length === maxTotalCount) {
+            throw new Error(`${this.format._name} does not support more than ${maxTotalCount} tracks`
+                + `${maxTotalCount === 1 ? '' : 's'} in total.`);
+        }
+        const track = {
+            id: this._tracks.length + 1,
+            output: this,
+            type,
+            source: source,
+            metadata,
+        };
+        if (track.type === 'video') {
+            const supportedVideoCodecs = this.format.getSupportedVideoCodecs();
+            if (supportedVideoCodecs.length === 0) {
+                throw new Error(`${this.format._name} does not support video tracks.`
+                    + this.format._codecUnsupportedHint(track.source._codec));
+            }
+            else if (!supportedVideoCodecs.includes(track.source._codec)) {
+                throw new Error(`Codec '${track.source._codec}' cannot be contained within ${this.format._name}. Supported`
+                    + ` video codecs are: ${supportedVideoCodecs.map(codec => `'${codec}'`).join(', ')}.`
+                    + this.format._codecUnsupportedHint(track.source._codec));
+            }
+        }
+        else if (track.type === 'audio') {
+            const supportedAudioCodecs = this.format.getSupportedAudioCodecs();
+            if (supportedAudioCodecs.length === 0) {
+                throw new Error(`${this.format._name} does not support audio tracks.`
+                    + this.format._codecUnsupportedHint(track.source._codec));
+            }
+            else if (!supportedAudioCodecs.includes(track.source._codec)) {
+                throw new Error(`Codec '${track.source._codec}' cannot be contained within ${this.format._name}. Supported`
+                    + ` audio codecs are: ${supportedAudioCodecs.map(codec => `'${codec}'`).join(', ')}.`
+                    + this.format._codecUnsupportedHint(track.source._codec));
+            }
+        }
+        else if (track.type === 'subtitle') {
+            const supportedSubtitleCodecs = this.format.getSupportedSubtitleCodecs();
+            if (supportedSubtitleCodecs.length === 0) {
+                throw new Error(`${this.format._name} does not support subtitle tracks.`
+                    + this.format._codecUnsupportedHint(track.source._codec));
+            }
+            else if (!supportedSubtitleCodecs.includes(track.source._codec)) {
+                throw new Error(`Codec '${track.source._codec}' cannot be contained within ${this.format._name}. Supported`
+                    + ` subtitle codecs are: ${supportedSubtitleCodecs.map(codec => `'${codec}'`).join(', ')}.`
+                    + this.format._codecUnsupportedHint(track.source._codec));
+            }
+        }
+        this._tracks.push(track);
+        source._connectedTrack = track;
+    }
+    /**
+     * Starts the creation of the output file. This method should be called after all tracks have been added. Only after
+     * the output has started can media samples be added to the tracks.
+     *
+     * @returns A promise that resolves when the output has successfully started and is ready to receive media samples.
+     */
+    async start() {
+        // Verify minimum track count constraints
+        const supportedTrackCounts = this.format.getSupportedTrackCounts();
+        for (const trackType of ALL_TRACK_TYPES) {
+            const presentTracksOfThisType = this._tracks.reduce((count, track) => count + (track.type === trackType ? 1 : 0), 0);
+            const minCount = supportedTrackCounts[trackType].min;
+            if (presentTracksOfThisType < minCount) {
+                throw new Error(minCount === supportedTrackCounts[trackType].max
+                    ? (`${this.format._name} requires exactly ${minCount} ${trackType}`
+                        + ` track${minCount === 1 ? '' : 's'}.`)
+                    : (`${this.format._name} requires at least ${minCount} ${trackType}`
+                        + ` track${minCount === 1 ? '' : 's'}.`));
+            }
+        }
+        const totalMinCount = supportedTrackCounts.total.min;
+        if (this._tracks.length < totalMinCount) {
+            throw new Error(totalMinCount === supportedTrackCounts.total.max
+                ? (`${this.format._name} requires exactly ${totalMinCount} track`
+                    + `${totalMinCount === 1 ? '' : 's'}.`)
+                : (`${this.format._name} requires at least ${totalMinCount} track`
+                    + `${totalMinCount === 1 ? '' : 's'}.`));
+        }
+        if (this.state === 'canceled') {
+            throw new Error('Output has been canceled.');
+        }
+        if (this._startPromise) {
+            console.warn('Output has already been started.');
+            return this._startPromise;
+        }
+        return this._startPromise = (async () => {
+            this.state = 'started';
+            this._writer.start();
+            const release = await this._mutex.acquire();
+            await this._muxer.start();
+            for (const track of this._tracks) {
+                track.source._start();
+            }
+            release();
+        })();
+    }
+    /**
+     * Resolves with the full MIME type of the output file, including track codecs.
+     *
+     * The returned promise will resolve only once the precise codec strings of all tracks are known.
+     */
+    getMimeType() {
+        return this._muxer.getMimeType();
+    }
+    /**
+     * Cancels the creation of the output file, releasing internal resources like encoders and preventing further
+     * samples from being added.
+     *
+     * @returns A promise that resolves once all internal resources have been released.
+     */
+    async cancel() {
+        if (this._cancelPromise) {
+            console.warn('Output has already been canceled.');
+            return this._cancelPromise;
+        }
+        else if (this.state === 'finalizing' || this.state === 'finalized') {
+            console.warn('Output has already been finalized.');
+            return;
+        }
+        return this._cancelPromise = (async () => {
+            this.state = 'canceled';
+            const release = await this._mutex.acquire();
+            const promises = this._tracks.map(x => x.source._flushOrWaitForClose());
+            await Promise.all(promises);
+            await this._writer.close();
+            release();
+        })();
+    }
+    /**
+     * Finalizes the output file. This method must be called after all media samples across all tracks have been added.
+     * Once the Promise returned by this method completes, the output file is ready.
+     */
+    async finalize() {
+        if (this.state === 'pending') {
+            throw new Error('Cannot finalize before starting.');
+        }
+        if (this.state === 'canceled') {
+            throw new Error('Cannot finalize after canceling.');
+        }
+        if (this._finalizePromise) {
+            console.warn('Output has already been finalized.');
+            return this._finalizePromise;
+        }
+        return this._finalizePromise = (async () => {
+            this.state = 'finalizing';
+            const release = await this._mutex.acquire();
+            const promises = this._tracks.map(x => x.source._flushOrWaitForClose());
+            await Promise.all(promises);
+            await this._muxer.finalize();
+            await this._writer.flush();
+            await this._writer.finalize();
+            this.state = 'finalized';
+            release();
+        })();
+    }
+}

package/dist/modules/packet.d.ts

@@ -0,0 +1,86 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+export declare const PLACEHOLDER_DATA: Uint8Array<ArrayBuffer>;
+/**
+ * The type of a packet. Key packets can be decoded without previous packets, while delta packets depend on previous
+ * packets.
+ * @public
+ */
+export type PacketType = 'key' | 'delta';
+/**
+ * Represents an encoded chunk of media. Mainly used as an expressive wrapper around WebCodecs API's EncodedVideoChunk
+ * and EncodedAudioChunk, but can also be used standalone.
+ * @public
+ */
+export declare class EncodedPacket {
+    /** The encoded data of this packet. */
+    readonly data: Uint8Array;
+    /** The type of this packet. */
+    readonly type: PacketType;
+    /**
+     * The presentation timestamp of this packet in seconds. May be negative. Samples with negative end timestamps
+     * should not be presented.
+     */
+    readonly timestamp: number;
+    /** The duration of this packet in seconds. */
+    readonly duration: number;
+    /**
+     * The sequence number indicates the decode order of the packets. Packet A  must be decoded before packet B if A
+     * has a lower sequence number than B. If two packets have the same sequence number, they are the same packet.
+     * Otherwise, sequence numbers are arbitrary and are not guaranteed to have any meaning besides their relative
+     * ordering. Negative sequence numbers mean the sequence number is undefined.
+     */
+    readonly sequenceNumber: number;
+    /**
+     * The actual byte length of the data in this packet. This field is useful for metadata-only packets where the
+     * `data` field contains no bytes.
+     */
+    readonly byteLength: number;
+    constructor(
+    /** The encoded data of this packet. */
+    data: Uint8Array, 
+    /** The type of this packet. */
+    type: PacketType, 
+    /**
+     * The presentation timestamp of this packet in seconds. May be negative. Samples with negative end timestamps
+     * should not be presented.
+     */
+    timestamp: number, 
+    /** The duration of this packet in seconds. */
+    duration: number, 
+    /**
+     * The sequence number indicates the decode order of the packets. Packet A  must be decoded before packet B if A
+     * has a lower sequence number than B. If two packets have the same sequence number, they are the same packet.
+     * Otherwise, sequence numbers are arbitrary and are not guaranteed to have any meaning besides their relative
+     * ordering. Negative sequence numbers mean the sequence number is undefined.
+     */
+    sequenceNumber?: number, byteLength?: number);
+    /** If this packet is a metadata-only packet. Metadata-only packets don't contain their packet data. */
+    get isMetadataOnly(): boolean;
+    /** The timestamp of this packet in microseconds. */
+    get microsecondTimestamp(): number;
+    /** The duration of this packet in microseconds. */
+    get microsecondDuration(): number;
+    /** Converts this packet to an EncodedVideoChunk for use with the WebCodecs API. */
+    toEncodedVideoChunk(): EncodedVideoChunk;
+    /** Converts this packet to an EncodedAudioChunk for use with the WebCodecs API. */
+    toEncodedAudioChunk(): EncodedAudioChunk;
+    /**
+     * Creates an EncodedPacket from an EncodedVideoChunk or EncodedAudioChunk. This method is useful for converting
+     * chunks from the WebCodecs API to EncodedPackets.
+     */
+    static fromEncodedChunk(chunk: EncodedVideoChunk | EncodedAudioChunk): EncodedPacket;
+    /** Clones this packet while optionally updating timing information. */
+    clone(options?: {
+        /** The timestamp of the cloned packet in seconds. */
+        timestamp?: number;
+        /** The duration of the cloned packet in seconds. */
+        duration?: number;
+    }): EncodedPacket;
+}
+//# sourceMappingURL=packet.d.ts.map

package/dist/modules/packet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packet.d.ts","sourceRoot":"","sources":["../../src/packet.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,eAAO,MAAM,gBAAgB,yBAAoB,CAAC;AAElD;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,OAAO,CAAC;AAEzC;;;;GAIG;AACH,qBAAa,aAAa;IAQxB,uCAAuC;aACvB,IAAI,EAAE,UAAU;IAChC,+BAA+B;aACf,IAAI,EAAE,UAAU;IAChC;;;OAGG;aACa,SAAS,EAAE,MAAM;IACjC,8CAA8C;aAC9B,QAAQ,EAAE,MAAM;IAChC;;;;;OAKG;aACa,cAAc;IAxB/B;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;;IAG3B,uCAAuC;IACvB,IAAI,EAAE,UAAU;IAChC,+BAA+B;IACf,IAAI,EAAE,UAAU;IAChC;;;OAGG;IACa,SAAS,EAAE,MAAM;IACjC,8CAA8C;IAC9B,QAAQ,EAAE,MAAM;IAChC;;;;;OAKG;IACa,cAAc,SAAK,EACnC,UAAU,CAAC,EAAE,MAAM;IAkCpB,uGAAuG;IACvG,IAAI,cAAc,YAEjB;IAED,oDAAoD;IACpD,IAAI,oBAAoB,WAEvB;IAED,mDAAmD;IACnD,IAAI,mBAAmB,WAEtB;IAED,mFAAmF;IACnF,mBAAmB;IAgBnB,mFAAmF;IACnF,mBAAmB;IAgBnB;;;OAGG;IACH,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,GAAG,iBAAiB,GAAG,aAAa;IAgBpF,uEAAuE;IACvE,KAAK,CAAC,OAAO,CAAC,EAAE;QACf,qDAAqD;QACrD,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,oDAAoD;QACpD,QAAQ,CAAC,EAAE,MAAM,CAAC;KAClB,GAAG,aAAa;CAoBjB"}

package/dist/modules/packet.js

@@ -0,0 +1,133 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { SECOND_TO_MICROSECOND_FACTOR } from './misc.js';
+export const PLACEHOLDER_DATA = new Uint8Array(0);
+/**
+ * Represents an encoded chunk of media. Mainly used as an expressive wrapper around WebCodecs API's EncodedVideoChunk
+ * and EncodedAudioChunk, but can also be used standalone.
+ * @public
+ */
+export class EncodedPacket {
+    constructor(
+    /** The encoded data of this packet. */
+    data, 
+    /** The type of this packet. */
+    type, 
+    /**
+     * The presentation timestamp of this packet in seconds. May be negative. Samples with negative end timestamps
+     * should not be presented.
+     */
+    timestamp, 
+    /** The duration of this packet in seconds. */
+    duration, 
+    /**
+     * The sequence number indicates the decode order of the packets. Packet A  must be decoded before packet B if A
+     * has a lower sequence number than B. If two packets have the same sequence number, they are the same packet.
+     * Otherwise, sequence numbers are arbitrary and are not guaranteed to have any meaning besides their relative
+     * ordering. Negative sequence numbers mean the sequence number is undefined.
+     */
+    sequenceNumber = -1, byteLength) {
+        this.data = data;
+        this.type = type;
+        this.timestamp = timestamp;
+        this.duration = duration;
+        this.sequenceNumber = sequenceNumber;
+        if (data === PLACEHOLDER_DATA && byteLength === undefined) {
+            throw new Error('Internal error: byteLength must be explicitly provided when constructing metadata-only packets.');
+        }
+        if (byteLength === undefined) {
+            byteLength = data.byteLength;
+        }
+        if (!(data instanceof Uint8Array)) {
+            throw new TypeError('data must be a Uint8Array.');
+        }
+        if (type !== 'key' && type !== 'delta') {
+            throw new TypeError('type must be either "key" or "delta".');
+        }
+        if (!Number.isFinite(timestamp)) {
+            throw new TypeError('timestamp must be a number.');
+        }
+        if (!Number.isFinite(duration) || duration < 0) {
+            throw new TypeError('duration must be a non-negative number.');
+        }
+        if (!Number.isFinite(sequenceNumber)) {
+            throw new TypeError('sequenceNumber must be a number.');
+        }
+        if (!Number.isInteger(byteLength) || byteLength < 0) {
+            throw new TypeError('byteLength must be a non-negative integer.');
+        }
+        this.byteLength = byteLength;
+    }
+    /** If this packet is a metadata-only packet. Metadata-only packets don't contain their packet data. */
+    get isMetadataOnly() {
+        return this.data === PLACEHOLDER_DATA;
+    }
+    /** The timestamp of this packet in microseconds. */
+    get microsecondTimestamp() {
+        return Math.trunc(SECOND_TO_MICROSECOND_FACTOR * this.timestamp);
+    }
+    /** The duration of this packet in microseconds. */
+    get microsecondDuration() {
+        return Math.trunc(SECOND_TO_MICROSECOND_FACTOR * this.duration);
+    }
+    /** Converts this packet to an EncodedVideoChunk for use with the WebCodecs API. */
+    toEncodedVideoChunk() {
+        if (this.isMetadataOnly) {
+            throw new TypeError('Metadata-only packets cannot be converted to a video chunk.');
+        }
+        if (typeof EncodedVideoChunk === 'undefined') {
+            throw new Error('Your browser does not support EncodedVideoChunk.');
+        }
+        return new EncodedVideoChunk({
+            data: this.data,
+            type: this.type,
+            timestamp: this.microsecondTimestamp,
+            duration: this.microsecondDuration,
+        });
+    }
+    /** Converts this packet to an EncodedAudioChunk for use with the WebCodecs API. */
+    toEncodedAudioChunk() {
+        if (this.isMetadataOnly) {
+            throw new TypeError('Metadata-only packets cannot be converted to an audio chunk.');
+        }
+        if (typeof EncodedAudioChunk === 'undefined') {
+            throw new Error('Your browser does not support EncodedAudioChunk.');
+        }
+        return new EncodedAudioChunk({
+            data: this.data,
+            type: this.type,
+            timestamp: this.microsecondTimestamp,
+            duration: this.microsecondDuration,
+        });
+    }
+    /**
+     * Creates an EncodedPacket from an EncodedVideoChunk or EncodedAudioChunk. This method is useful for converting
+     * chunks from the WebCodecs API to EncodedPackets.
+     */
+    static fromEncodedChunk(chunk) {
+        if (!(chunk instanceof EncodedVideoChunk || chunk instanceof EncodedAudioChunk)) {
+            throw new TypeError('chunk must be an EncodedVideoChunk or EncodedAudioChunk.');
+        }
+        const data = new Uint8Array(chunk.byteLength);
+        chunk.copyTo(data);
+        return new EncodedPacket(data, chunk.type, chunk.timestamp / 1e6, (chunk.duration ?? 0) / 1e6);
+    }
+    /** Clones this packet while optionally updating timing information. */
+    clone(options) {
+        if (options !== undefined && (typeof options !== 'object' || options === null)) {
+            throw new TypeError('options, when provided, must be an object.');
+        }
+        if (options?.timestamp !== undefined && !Number.isFinite(options.timestamp)) {
+            throw new TypeError('options.timestamp, when provided, must be a number.');
+        }
+        if (options?.duration !== undefined && !Number.isFinite(options.duration)) {
+            throw new TypeError('options.duration, when provided, must be a number.');
+        }
+        return new EncodedPacket(this.data, this.type, options?.timestamp ?? this.timestamp, options?.duration ?? this.duration, this.sequenceNumber, this.byteLength);
+    }
+}

package/dist/modules/pcm.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+export declare const toUlaw: (s16: number) => number;
+export declare const fromUlaw: (u8: number) => number;
+export declare const toAlaw: (s16: number) => number;
+export declare const fromAlaw: (u8: number) => number;
+//# sourceMappingURL=pcm.d.ts.map

package/dist/modules/pcm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcm.d.ts","sourceRoot":"","sources":["../../src/pcm.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,eAAO,MAAM,MAAM,GAAI,KAAK,MAAM,WA6BjC,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,IAAI,MAAM,WAkBlC,CAAC;AAEF,eAAO,MAAM,MAAM,GAAI,KAAK,MAAM,WA0BjC,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,IAAI,MAAM,WAsBlC,CAAC"}