mediabunny 1.0.2 → 1.0.4

package/dist/modules/output-format.d.ts

@@ -0,0 +1,285 @@
+/*!
+ * 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 { AudioCodec, MediaCodec, SubtitleCodec, VideoCodec } from './codec';
+import { MediaSource } from './media-source';
+import { TrackType } from './output';
+/**
+ * Specifies an inclusive range of integers.
+ * @public
+ */
+export type InclusiveIntegerRange = {
+    /** The integer cannot be less than this. */
+    min: number;
+    /** The integer cannot be greater than this. */
+    max: number;
+};
+/**
+ * Specifies the number of tracks (for each track type and in total) that an output format supports.
+ * @public
+ */
+export type TrackCountLimits = {
+    [K in TrackType]: InclusiveIntegerRange;
+} & {
+    /** Specifies the overall allowed range of track counts for the output format. */
+    total: InclusiveIntegerRange;
+};
+/**
+ * Base class representing an output media file format.
+ * @public
+ */
+export declare abstract class OutputFormat {
+    /** The file extension used by this output format, beginning with a dot. */
+    abstract get fileExtension(): string;
+    /** The base MIME type of the output format. */
+    abstract get mimeType(): string;
+    /** Returns a list of media codecs that this output format can contain. */
+    abstract getSupportedCodecs(): MediaCodec[];
+    /** Returns the number of tracks that this output format supports. */
+    abstract getSupportedTrackCounts(): TrackCountLimits;
+    /** Whether this output format supports video rotation metadata. */
+    abstract get supportsVideoRotationMetadata(): boolean;
+    /** Returns a list of video codecs that this output format can contain. */
+    getSupportedVideoCodecs(): VideoCodec[];
+    /** Returns a list of audio codecs that this output format can contain. */
+    getSupportedAudioCodecs(): AudioCodec[];
+    /** Returns a list of subtitle codecs that this output format can contain. */
+    getSupportedSubtitleCodecs(): SubtitleCodec[];
+}
+/**
+ * ISOBMFF-specific output options.
+ * @public
+ */
+export type IsobmffOutputFormatOptions = {
+    /**
+     * Controls the placement of metadata in the file. Placing metadata at the start of the file is known as "Fast
+     * Start", which results in better playback at the cost of more required processing or memory.
+     *
+     * Use `false` to disable Fast Start, placing the metadata at the end of the file. Fastest and uses the least
+     * memory.
+     *
+     * Use `'in-memory'` to produce a file with Fast Start by keeping all media chunks in memory until the file is
+     * finalized. This produces a high-quality and compact output at the cost of a more expensive finalization step and
+     * higher memory requirements. Data will be written monotonically (in order) when this option is set.
+     *
+     * Use `'fragmented'` to place metadata at the start of the file by creating a fragmented file (fMP4). In a
+     * fragmented file, chunks of media and their metadata are written to the file in "fragments", eliminating the need
+     * to put all metadata in one place. Fragmented files are useful for streaming contexts, as each fragment can be
+     * played individually without requiring knowledge of the other fragments. Furthermore, they remain lightweight to
+     * create even for very large files, as they don't require all media to be kept in memory. However, fragmented files
+     * are not as widely and wholly supported as regular MP4/MOV files. Data will be written monotonically (in order)
+     * when this option is set.
+     *
+     * When this field is not defined, either `false` or `'in-memory'` will be used, automatically determined based on
+     * the type of output target used.
+     */
+    fastStart?: false | 'in-memory' | 'fragmented';
+    /**
+     * When using `fastStart: 'fragmented'`, this field controls the minimum duration of each fragment, in seconds.
+     * New fragments will only be created when the current fragment is longer than this value. Defaults to 1 second.
+     */
+    minimumFragmentDuration?: number;
+    /**
+     * Will be called once the ftyp (File Type) box of the output file has been written.
+     *
+     * @param data - The raw bytes.
+     * @param position - The byte offset of the data in the file.
+     */
+    onFtyp?: (data: Uint8Array, position: number) => unknown;
+    /**
+     * Will be called once the moov (Movie) box of the output file has been written.
+     *
+     * @param data - The raw bytes.
+     * @param position - The byte offset of the data in the file.
+     */
+    onMoov?: (data: Uint8Array, position: number) => unknown;
+    /**
+     * Will be called for each finalized mdat (Media Data) box of the output file. Usage of this callback is not
+     * recommended when not using `fastStart: 'fragmented'`, as there will be one monolithic mdat box which might
+     * require large amounts of memory.
+     *
+     * @param data - The raw bytes.
+     * @param position - The byte offset of the data in the file.
+     */
+    onMdat?: (data: Uint8Array, position: number) => unknown;
+    /**
+     * Will be called for each finalized moof (Movie Fragment) box of the output file.
+     *
+     * @param data - The raw bytes.
+     * @param position - The byte offset of the data in the file.
+     * @param timestamp - The start timestamp of the fragment in seconds.
+     */
+    onMoof?: (data: Uint8Array, position: number, timestamp: number) => unknown;
+};
+/**
+ * Format representing files compatible with the ISO base media file format (ISOBMFF), like MP4 or MOV files.
+ * @public
+ */
+export declare abstract class IsobmffOutputFormat extends OutputFormat {
+    constructor(options?: IsobmffOutputFormatOptions);
+    getSupportedTrackCounts(): TrackCountLimits;
+    get supportsVideoRotationMetadata(): boolean;
+}
+/**
+ * MPEG-4 Part 14 (MP4) file format. Supports all codecs except PCM audio codecs.
+ * @public
+ */
+export declare class Mp4OutputFormat extends IsobmffOutputFormat {
+    get fileExtension(): string;
+    get mimeType(): string;
+    getSupportedCodecs(): MediaCodec[];
+}
+/**
+ * QuickTime File Format (QTFF), often called MOV. Supports all video and audio codecs, but not subtitle codecs.
+ * @public
+ */
+export declare class MovOutputFormat extends IsobmffOutputFormat {
+    get fileExtension(): string;
+    get mimeType(): string;
+    getSupportedCodecs(): MediaCodec[];
+}
+/**
+ * Matroska-specific output options.
+ * @public
+ */
+export type MkvOutputFormatOptions = {
+    /**
+     * Configures the output to only append new data at the end, useful for live-streaming the file as it's being
+     * created. When enabled, some features such as storing duration and seeking will be disabled or impacted, so don't
+     * use this option when you want to write out a clean file for later use.
+     */
+    appendOnly?: boolean;
+    /**
+     * This field controls the minimum duration of each Matroska cluster, in seconds. New clusters will only be created
+     * when the current cluster is longer than this value. Defaults to 1 second.
+     */
+    minimumClusterDuration?: number;
+    /**
+     * Will be called once the EBML header of the output file has been written.
+     *
+     * @param data - The raw bytes.
+     * @param position - The byte offset of the data in the file.
+     */
+    onEbmlHeader?: (data: Uint8Array, position: number) => void;
+    /**
+     * Will be called once the header part of the Matroska Segment element has been written. The header data includes
+     * the Segment element and everything inside it, up to (but excluding) the first Matroska Cluster.
+     *
+     * @param data - The raw bytes.
+     * @param position - The byte offset of the data in the file.
+     */
+    onSegmentHeader?: (data: Uint8Array, position: number) => unknown;
+    /**
+     * Will be called for each finalized Matroska Cluster of the output file.
+     *
+     * @param data - The raw bytes.
+     * @param position - The byte offset of the data in the file.
+     * @param timestamp - The start timestamp of the cluster in seconds.
+     */
+    onCluster?: (data: Uint8Array, position: number, timestamp: number) => unknown;
+};
+/**
+ * Matroska file format.
+ * @public
+ */
+export declare class MkvOutputFormat extends OutputFormat {
+    constructor(options?: MkvOutputFormatOptions);
+    getSupportedTrackCounts(): TrackCountLimits;
+    get fileExtension(): string;
+    get mimeType(): string;
+    getSupportedCodecs(): MediaCodec[];
+    get supportsVideoRotationMetadata(): boolean;
+}
+/**
+ * WebM-specific output options.
+ * @public
+ */
+export type WebMOutputFormatOptions = MkvOutputFormatOptions;
+/**
+ * WebM file format, based on Matroska.
+ * @public
+ */
+export declare class WebMOutputFormat extends MkvOutputFormat {
+    getSupportedCodecs(): MediaCodec[];
+    get fileExtension(): string;
+    get mimeType(): string;
+}
+/**
+ * MP3-specific output options.
+ * @public
+ */
+export type Mp3OutputFormatOptions = {
+    /**
+     * Will be called once the Xing metadata frame is finalized.
+     *
+     * @param data - The raw bytes.
+     * @param position - The byte offset of the data in the file.
+     */
+    onXingFrame?: (data: Uint8Array, position: number) => unknown;
+};
+/**
+ * MP3 file format.
+ * @public
+ */
+export declare class Mp3OutputFormat extends OutputFormat {
+    constructor(options?: Mp3OutputFormatOptions);
+    getSupportedTrackCounts(): TrackCountLimits;
+    get fileExtension(): string;
+    get mimeType(): string;
+    getSupportedCodecs(): MediaCodec[];
+    get supportsVideoRotationMetadata(): boolean;
+}
+/**
+ * WAVE-specific output options.
+ * @public
+ */
+export type WavOutputFormatOptions = {
+    /**
+     * Will be called once the file header is written. The header consists of the RIFF header, the format chunk, and the
+     * start of the data chunk (with a placeholder size of 0).
+     */
+    onHeader?: (data: Uint8Array, position: number) => unknown;
+};
+/**
+ * WAVE file format, based on RIFF.
+ * @public
+ */
+export declare class WavOutputFormat extends OutputFormat {
+    constructor(options?: WavOutputFormatOptions);
+    getSupportedTrackCounts(): TrackCountLimits;
+    get fileExtension(): string;
+    get mimeType(): string;
+    getSupportedCodecs(): MediaCodec[];
+    get supportsVideoRotationMetadata(): boolean;
+}
+/**
+ * Ogg-specific output options.
+ * @public
+ */
+export type OggOutputFormatOptions = {
+    /**
+     * Will be called for each Ogg page that is written.
+     *
+     * @param data - The raw bytes.
+     * @param position - The byte offset of the data in the file.
+     * @param source - The media source backing the page's logical bitstream (track).
+     */
+    onPage?: (data: Uint8Array, position: number, source: MediaSource) => unknown;
+};
+/**
+ * Ogg file format.
+ * @public
+ */
+export declare class OggOutputFormat extends OutputFormat {
+    constructor(options?: OggOutputFormatOptions);
+    getSupportedTrackCounts(): TrackCountLimits;
+    get fileExtension(): string;
+    get mimeType(): string;
+    getSupportedCodecs(): MediaCodec[];
+    get supportsVideoRotationMetadata(): boolean;
+}
+//# sourceMappingURL=output-format.d.ts.map

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

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

package/dist/modules/output-format.js

@@ -0,0 +1,385 @@
+/*!
+ * 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 { AUDIO_CODECS, NON_PCM_AUDIO_CODECS, PCM_AUDIO_CODECS, SUBTITLE_CODECS, VIDEO_CODECS, } from './codec.js';
+import { IsobmffMuxer } from './isobmff/isobmff-muxer.js';
+import { MatroskaMuxer } from './matroska/matroska-muxer.js';
+import { Mp3Muxer } from './mp3/mp3-muxer.js';
+import { OggMuxer } from './ogg/ogg-muxer.js';
+import { WaveMuxer } from './wave/wave-muxer.js';
+/**
+ * Base class representing an output media file format.
+ * @public
+ */
+export class OutputFormat {
+    /** Returns a list of video codecs that this output format can contain. */
+    getSupportedVideoCodecs() {
+        return this.getSupportedCodecs()
+            .filter(codec => VIDEO_CODECS.includes(codec));
+    }
+    /** Returns a list of audio codecs that this output format can contain. */
+    getSupportedAudioCodecs() {
+        return this.getSupportedCodecs()
+            .filter(codec => AUDIO_CODECS.includes(codec));
+    }
+    /** Returns a list of subtitle codecs that this output format can contain. */
+    getSupportedSubtitleCodecs() {
+        return this.getSupportedCodecs()
+            .filter(codec => SUBTITLE_CODECS.includes(codec));
+    }
+    /** @internal */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _codecUnsupportedHint(codec) {
+        return '';
+    }
+}
+/**
+ * Format representing files compatible with the ISO base media file format (ISOBMFF), like MP4 or MOV files.
+ * @public
+ */
+export class IsobmffOutputFormat extends OutputFormat {
+    constructor(options = {}) {
+        if (!options || typeof options !== 'object') {
+            throw new TypeError('options must be an object.');
+        }
+        if (options.fastStart !== undefined && ![false, 'in-memory', 'fragmented'].includes(options.fastStart)) {
+            throw new TypeError('options.fastStart, when provided, must be false, "in-memory", or "fragmented".');
+        }
+        if (options.minimumFragmentDuration !== undefined
+            && (!Number.isFinite(options.minimumFragmentDuration) || options.minimumFragmentDuration < 0)) {
+            throw new TypeError('options.minimumFragmentDuration, when provided, must be a non-negative number.');
+        }
+        if (options.onFtyp !== undefined && typeof options.onFtyp !== 'function') {
+            throw new TypeError('options.onFtyp, when provided, must be a function.');
+        }
+        if (options.onMoov !== undefined && typeof options.onMoov !== 'function') {
+            throw new TypeError('options.onMoov, when provided, must be a function.');
+        }
+        if (options.onMdat !== undefined && typeof options.onMdat !== 'function') {
+            throw new TypeError('options.onMdat, when provided, must be a function.');
+        }
+        if (options.onMoof !== undefined && typeof options.onMoof !== 'function') {
+            throw new TypeError('options.onMoof, when provided, must be a function.');
+        }
+        super();
+        this._options = options;
+    }
+    getSupportedTrackCounts() {
+        return {
+            video: { min: 0, max: Infinity },
+            audio: { min: 0, max: Infinity },
+            subtitle: { min: 0, max: Infinity },
+            total: { min: 1, max: 2 ** 32 - 1 }, // Have fun reaching this one
+        };
+    }
+    get supportsVideoRotationMetadata() {
+        return true;
+    }
+    /** @internal */
+    _createMuxer(output) {
+        return new IsobmffMuxer(output, this);
+    }
+}
+/**
+ * MPEG-4 Part 14 (MP4) file format. Supports all codecs except PCM audio codecs.
+ * @public
+ */
+export class Mp4OutputFormat extends IsobmffOutputFormat {
+    /** @internal */
+    get _name() {
+        return 'MP4';
+    }
+    get fileExtension() {
+        return '.mp4';
+    }
+    get mimeType() {
+        return 'video/mp4';
+    }
+    getSupportedCodecs() {
+        return [
+            ...VIDEO_CODECS,
+            ...NON_PCM_AUDIO_CODECS,
+            // These are supported via ISO/IEC 23003-5
+            'pcm-s16',
+            'pcm-s16be',
+            'pcm-s24',
+            'pcm-s24be',
+            'pcm-s32',
+            'pcm-s32be',
+            'pcm-f32',
+            'pcm-f32be',
+            'pcm-f64',
+            'pcm-f64be',
+            ...SUBTITLE_CODECS,
+        ];
+    }
+    /** @internal */
+    _codecUnsupportedHint(codec) {
+        if (new MovOutputFormat().getSupportedCodecs().includes(codec)) {
+            return ' Switching to MOV will grant support for this codec.';
+        }
+        return '';
+    }
+}
+/**
+ * QuickTime File Format (QTFF), often called MOV. Supports all video and audio codecs, but not subtitle codecs.
+ * @public
+ */
+export class MovOutputFormat extends IsobmffOutputFormat {
+    /** @internal */
+    get _name() {
+        return 'MOV';
+    }
+    get fileExtension() {
+        return '.mov';
+    }
+    get mimeType() {
+        return 'video/quicktime';
+    }
+    getSupportedCodecs() {
+        return [
+            ...VIDEO_CODECS,
+            ...AUDIO_CODECS,
+        ];
+    }
+    /** @internal */
+    _codecUnsupportedHint(codec) {
+        if (new Mp4OutputFormat().getSupportedCodecs().includes(codec)) {
+            return ' Switching to MP4 will grant support for this codec.';
+        }
+        return '';
+    }
+}
+/**
+ * Matroska file format.
+ * @public
+ */
+export class MkvOutputFormat extends OutputFormat {
+    constructor(options = {}) {
+        if (!options || typeof options !== 'object') {
+            throw new TypeError('options must be an object.');
+        }
+        if (options.appendOnly !== undefined && typeof options.appendOnly !== 'boolean') {
+            throw new TypeError('options.appendOnly, when provided, must be a boolean.');
+        }
+        if (options.minimumClusterDuration !== undefined
+            && (!Number.isFinite(options.minimumClusterDuration) || options.minimumClusterDuration < 0)) {
+            throw new TypeError('options.minimumClusterDuration, when provided, must be a non-negative number.');
+        }
+        if (options.onEbmlHeader !== undefined && typeof options.onEbmlHeader !== 'function') {
+            throw new TypeError('options.onEbmlHeader, when provided, must be a function.');
+        }
+        if (options.onSegmentHeader !== undefined && typeof options.onSegmentHeader !== 'function') {
+            throw new TypeError('options.onHeader, when provided, must be a function.');
+        }
+        if (options.onCluster !== undefined && typeof options.onCluster !== 'function') {
+            throw new TypeError('options.onCluster, when provided, must be a function.');
+        }
+        super();
+        this._options = options;
+    }
+    /** @internal */
+    _createMuxer(output) {
+        return new MatroskaMuxer(output, this);
+    }
+    /** @internal */
+    get _name() {
+        return 'Matroska';
+    }
+    getSupportedTrackCounts() {
+        return {
+            video: { min: 0, max: Infinity },
+            audio: { min: 0, max: Infinity },
+            subtitle: { min: 0, max: Infinity },
+            total: { min: 1, max: 127 },
+        };
+    }
+    get fileExtension() {
+        return '.mkv';
+    }
+    get mimeType() {
+        return 'video/x-matroska';
+    }
+    getSupportedCodecs() {
+        return [
+            ...VIDEO_CODECS,
+            ...NON_PCM_AUDIO_CODECS,
+            ...PCM_AUDIO_CODECS.filter(codec => !['pcm-s8', 'pcm-f32be', 'pcm-f64be', 'ulaw', 'alaw'].includes(codec)),
+            ...SUBTITLE_CODECS,
+        ];
+    }
+    get supportsVideoRotationMetadata() {
+        // While it technically does support it with ProjectionPoseRoll, many players appear to ignore this value
+        return false;
+    }
+}
+/**
+ * WebM file format, based on Matroska.
+ * @public
+ */
+export class WebMOutputFormat extends MkvOutputFormat {
+    getSupportedCodecs() {
+        return [
+            ...VIDEO_CODECS.filter(codec => ['vp8', 'vp9', 'av1'].includes(codec)),
+            ...AUDIO_CODECS.filter(codec => ['opus', 'vorbis'].includes(codec)),
+            ...SUBTITLE_CODECS,
+        ];
+    }
+    /** @internal */
+    get _name() {
+        return 'WebM';
+    }
+    get fileExtension() {
+        return '.webm';
+    }
+    get mimeType() {
+        return 'video/webm';
+    }
+    /** @internal */
+    _codecUnsupportedHint(codec) {
+        if (new MkvOutputFormat().getSupportedCodecs().includes(codec)) {
+            return ' Switching to MKV will grant support for this codec.';
+        }
+        return '';
+    }
+}
+/**
+ * MP3 file format.
+ * @public
+ */
+export class Mp3OutputFormat extends OutputFormat {
+    constructor(options = {}) {
+        if (!options || typeof options !== 'object') {
+            throw new TypeError('options must be an object.');
+        }
+        if (options.onXingFrame !== undefined && typeof options.onXingFrame !== 'function') {
+            throw new TypeError('options.onXingFrame, when provided, must be a function.');
+        }
+        super();
+        this._options = options;
+    }
+    /** @internal */
+    _createMuxer(output) {
+        return new Mp3Muxer(output, this);
+    }
+    /** @internal */
+    get _name() {
+        return 'MP3';
+    }
+    getSupportedTrackCounts() {
+        return {
+            video: { min: 0, max: 0 },
+            audio: { min: 1, max: 1 },
+            subtitle: { min: 0, max: 0 },
+            total: { min: 1, max: 1 },
+        };
+    }
+    get fileExtension() {
+        return '.mp3';
+    }
+    get mimeType() {
+        return 'audio/mpeg';
+    }
+    getSupportedCodecs() {
+        return ['mp3'];
+    }
+    get supportsVideoRotationMetadata() {
+        return false;
+    }
+}
+/**
+ * WAVE file format, based on RIFF.
+ * @public
+ */
+export class WavOutputFormat extends OutputFormat {
+    constructor(options = {}) {
+        if (!options || typeof options !== 'object') {
+            throw new TypeError('options must be an object.');
+        }
+        if (options.onHeader !== undefined && typeof options.onHeader !== 'function') {
+            throw new TypeError('options.onHeader, when provided, must be a function.');
+        }
+        super();
+        this._options = options;
+    }
+    /** @internal */
+    _createMuxer(output) {
+        return new WaveMuxer(output, this);
+    }
+    /** @internal */
+    get _name() {
+        return 'WAVE';
+    }
+    getSupportedTrackCounts() {
+        return {
+            video: { min: 0, max: 0 },
+            audio: { min: 1, max: 1 },
+            subtitle: { min: 0, max: 0 },
+            total: { min: 1, max: 1 },
+        };
+    }
+    get fileExtension() {
+        return '.wav';
+    }
+    get mimeType() {
+        return 'audio/wav';
+    }
+    getSupportedCodecs() {
+        return [
+            ...PCM_AUDIO_CODECS.filter(codec => ['pcm-s16', 'pcm-s24', 'pcm-s32', 'pcm-f32', 'pcm-u8', 'ulaw', 'alaw'].includes(codec)),
+        ];
+    }
+    get supportsVideoRotationMetadata() {
+        return false;
+    }
+}
+/**
+ * Ogg file format.
+ * @public
+ */
+export class OggOutputFormat extends OutputFormat {
+    constructor(options = {}) {
+        if (!options || typeof options !== 'object') {
+            throw new TypeError('options must be an object.');
+        }
+        if (options.onPage !== undefined && typeof options.onPage !== 'function') {
+            throw new TypeError('options.onPage, when provided, must be a function.');
+        }
+        super();
+        this._options = options;
+    }
+    /** @internal */
+    _createMuxer(output) {
+        return new OggMuxer(output, this);
+    }
+    /** @internal */
+    get _name() {
+        return 'Ogg';
+    }
+    getSupportedTrackCounts() {
+        return {
+            video: { min: 0, max: 0 },
+            audio: { min: 0, max: Infinity },
+            subtitle: { min: 0, max: 0 },
+            total: { min: 1, max: 2 ** 32 },
+        };
+    }
+    get fileExtension() {
+        return '.ogg';
+    }
+    get mimeType() {
+        return 'application/ogg';
+    }
+    getSupportedCodecs() {
+        return [
+            ...AUDIO_CODECS.filter(codec => ['vorbis', 'opus'].includes(codec)),
+        ];
+    }
+    get supportsVideoRotationMetadata() {
+        return false;
+    }
+}