mediabunny 1.0.2 → 1.0.4

package/dist/modules/input-format.js

@@ -0,0 +1,333 @@
+/*!
+ * 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 { IsobmffDemuxer } from './isobmff/isobmff-demuxer.js';
+import { IsobmffReader } from './isobmff/isobmff-reader.js';
+import { EBMLId, EBMLReader } from './matroska/ebml.js';
+import { MatroskaDemuxer } from './matroska/matroska-demuxer.js';
+import { Mp3Demuxer } from './mp3/mp3-demuxer.js';
+import { Mp3Reader } from './mp3/mp3-reader.js';
+import { OggDemuxer } from './ogg/ogg-demuxer.js';
+import { OggReader } from './ogg/ogg-reader.js';
+import { RiffReader } from './wave/riff-reader.js';
+import { WaveDemuxer } from './wave/wave-demuxer.js';
+/**
+ * Base class representing an input media file format.
+ * @public
+ */
+export class InputFormat {
+}
+/**
+ * Format representing files compatible with the ISO base media file format (ISOBMFF), like MP4 or MOV files.
+ * @public
+ */
+export class IsobmffInputFormat extends InputFormat {
+    /** @internal */
+    async _getMajorBrand(input) {
+        const sourceSize = await input._mainReader.source.getSize();
+        if (sourceSize < 12) {
+            return null;
+        }
+        const isobmffReader = new IsobmffReader(input._mainReader);
+        isobmffReader.pos = 4;
+        const fourCc = isobmffReader.readAscii(4);
+        if (fourCc !== 'ftyp') {
+            return null;
+        }
+        return isobmffReader.readAscii(4);
+    }
+    /** @internal */
+    _createDemuxer(input) {
+        return new IsobmffDemuxer(input);
+    }
+}
+/**
+ * MPEG-4 Part 14 (MP4) file format.
+ * @public
+ */
+export class Mp4InputFormat extends IsobmffInputFormat {
+    /** @internal */
+    async _canReadInput(input) {
+        const majorBrand = await this._getMajorBrand(input);
+        return !!majorBrand && majorBrand !== 'qt  ';
+    }
+    get name() {
+        return 'MP4';
+    }
+    get mimeType() {
+        return 'video/mp4';
+    }
+}
+/**
+ * QuickTime File Format (QTFF), often called MOV.
+ * @public
+ */
+export class QuickTimeInputFormat extends IsobmffInputFormat {
+    /** @internal */
+    async _canReadInput(input) {
+        const majorBrand = await this._getMajorBrand(input);
+        return majorBrand === 'qt  ';
+    }
+    get name() {
+        return 'QuickTime File Format';
+    }
+    get mimeType() {
+        return 'video/quicktime';
+    }
+}
+/**
+ * Matroska file format.
+ * @public
+ */
+export class MatroskaInputFormat extends InputFormat {
+    /** @internal */
+    async isSupportedEBMLOfDocType(input, desiredDocType) {
+        const sourceSize = await input._mainReader.source.getSize();
+        if (sourceSize < 8) {
+            return false;
+        }
+        const ebmlReader = new EBMLReader(input._mainReader);
+        const varIntSize = ebmlReader.readVarIntSize();
+        if (varIntSize < 1 || varIntSize > 8) {
+            return false;
+        }
+        const id = ebmlReader.readUnsignedInt(varIntSize);
+        if (id !== EBMLId.EBML) {
+            return false;
+        }
+        const dataSize = ebmlReader.readElementSize();
+        if (dataSize === null) {
+            return false; // Miss me with that shit
+        }
+        const startPos = ebmlReader.pos;
+        while (ebmlReader.pos < startPos + dataSize) {
+            const { id, size } = ebmlReader.readElementHeader();
+            const dataStartPos = ebmlReader.pos;
+            if (size === null)
+                return false;
+            switch (id) {
+                case EBMLId.EBMLVersion:
+                    {
+                        const ebmlVersion = ebmlReader.readUnsignedInt(size);
+                        if (ebmlVersion !== 1) {
+                            return false;
+                        }
+                    }
+                    ;
+                    break;
+                case EBMLId.EBMLReadVersion:
+                    {
+                        const ebmlReadVersion = ebmlReader.readUnsignedInt(size);
+                        if (ebmlReadVersion !== 1) {
+                            return false;
+                        }
+                    }
+                    ;
+                    break;
+                case EBMLId.DocType:
+                    {
+                        const docType = ebmlReader.readString(size);
+                        if (docType !== desiredDocType) {
+                            return false;
+                        }
+                    }
+                    ;
+                    break;
+                case EBMLId.DocTypeVersion:
+                    {
+                        const docTypeVersion = ebmlReader.readUnsignedInt(size);
+                        if (docTypeVersion > 4) { // Support up to Matroska v4
+                            return false;
+                        }
+                    }
+                    ;
+                    break;
+            }
+            ebmlReader.pos = dataStartPos + size;
+        }
+        return true;
+    }
+    /** @internal */
+    _canReadInput(input) {
+        return this.isSupportedEBMLOfDocType(input, 'matroska');
+    }
+    /** @internal */
+    _createDemuxer(input) {
+        return new MatroskaDemuxer(input);
+    }
+    get name() {
+        return 'Matroska';
+    }
+    get mimeType() {
+        return 'video/x-matroska';
+    }
+}
+/**
+ * WebM file format, based on Matroska.
+ * @public
+ */
+export class WebMInputFormat extends MatroskaInputFormat {
+    /** @internal */
+    _canReadInput(input) {
+        return this.isSupportedEBMLOfDocType(input, 'webm');
+    }
+    get name() {
+        return 'WebM';
+    }
+    get mimeType() {
+        return 'video/webm';
+    }
+}
+/**
+ * MP3 file format.
+ * @public
+ */
+export class Mp3InputFormat extends InputFormat {
+    /** @internal */
+    async _canReadInput(input) {
+        const sourceSize = await input._mainReader.source.getSize();
+        if (sourceSize < 4) {
+            return false;
+        }
+        const mp3Reader = new Mp3Reader(input._mainReader);
+        mp3Reader.fileSize = sourceSize;
+        const id3Tag = mp3Reader.readId3();
+        if (id3Tag) {
+            mp3Reader.pos += id3Tag.size;
+        }
+        const framesStartPos = mp3Reader.pos;
+        await mp3Reader.reader.loadRange(mp3Reader.pos, mp3Reader.pos + 4096);
+        const firstHeader = mp3Reader.readNextFrameHeader(Math.min(framesStartPos + 4096, sourceSize));
+        if (!firstHeader) {
+            return false;
+        }
+        if (id3Tag) {
+            // If there was an ID3 tag at the start, we can be pretty sure this is MP3 by now
+            return true;
+        }
+        // Fine, we found one frame header, but we're still not entirely sure this is MP3. Let's check if we can find
+        // another header nearby:
+        mp3Reader.pos = firstHeader.startPos + firstHeader.totalSize;
+        const secondHeader = mp3Reader.readNextFrameHeader(Math.min(framesStartPos + 4096, sourceSize));
+        if (!secondHeader) {
+            return false;
+        }
+        // In a well-formed MP3 file, we'd expect these two frames to share some similarities:
+        if (firstHeader.channel !== secondHeader.channel || firstHeader.sampleRate !== secondHeader.sampleRate) {
+            return false;
+        }
+        // We have found two matching MP3 frames, a strong indicator that this is an MP3 file
+        return true;
+    }
+    /** @internal */
+    _createDemuxer(input) {
+        return new Mp3Demuxer(input);
+    }
+    get name() {
+        return 'MP3';
+    }
+    get mimeType() {
+        return 'audio/mpeg';
+    }
+}
+/**
+ * WAVE file format, based on RIFF.
+ * @public
+ */
+export class WaveInputFormat extends InputFormat {
+    /** @internal */
+    async _canReadInput(input) {
+        const sourceSize = await input._mainReader.source.getSize();
+        if (sourceSize < 12) {
+            return false;
+        }
+        const riffReader = new RiffReader(input._mainReader);
+        const riffType = riffReader.readAscii(4);
+        if (riffType !== 'RIFF' && riffType !== 'RIFX') {
+            return false;
+        }
+        riffReader.pos = 8;
+        const format = riffReader.readAscii(4);
+        return format === 'WAVE';
+    }
+    /** @internal */
+    _createDemuxer(input) {
+        return new WaveDemuxer(input);
+    }
+    get name() {
+        return 'WAVE';
+    }
+    get mimeType() {
+        return 'audio/wav';
+    }
+}
+/**
+ * Ogg file format.
+ * @public
+ */
+export class OggInputFormat extends InputFormat {
+    /** @internal */
+    async _canReadInput(input) {
+        const sourceSize = await input._mainReader.source.getSize();
+        if (sourceSize < 4) {
+            return false;
+        }
+        const oggReader = new OggReader(input._mainReader);
+        return oggReader.readAscii(4) === 'OggS';
+    }
+    /** @internal */
+    _createDemuxer(input) {
+        return new OggDemuxer(input);
+    }
+    get name() {
+        return 'Ogg';
+    }
+    get mimeType() {
+        return 'application/ogg';
+    }
+}
+/**
+ * MP4 input format singleton.
+ * @public
+ */
+export const MP4 = new Mp4InputFormat();
+/**
+ * QuickTime File Format input format singleton.
+ * @public
+ */
+export const QTFF = new QuickTimeInputFormat();
+/**
+ * Matroska input format singleton.
+ * @public
+ */
+export const MATROSKA = new MatroskaInputFormat();
+/**
+ * WebM input format singleton.
+ * @public
+ */
+export const WEBM = new WebMInputFormat();
+/**
+ * MP3 input format singleton.
+ * @public
+ */
+export const MP3 = new Mp3InputFormat();
+/**
+ * WAVE input format singleton.
+ * @public
+ */
+export const WAVE = new WaveInputFormat();
+/**
+ * Ogg input format singleton.
+ * @public
+ */
+export const OGG = new OggInputFormat();
+/**
+ * List of all input format singletons. If you don't need to support all input formats, you should specify the
+ * formats individually for better tree shaking.
+ * @public
+ */
+export const ALL_FORMATS = [MP4, QTFF, MATROSKA, WEBM, WAVE, OGG, MP3];

package/dist/modules/input-track.d.ts

@@ -0,0 +1,138 @@
+/*!
+ * 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, VideoCodec } from './codec';
+import { PacketRetrievalOptions } from './media-sink';
+import { Rotation } from './misc';
+import { TrackType } from './output';
+import { EncodedPacket } from './packet';
+/**
+ * Contains aggregate statistics about the encoded packets of a track.
+ * @public
+ */
+export type PacketStats = {
+    /** The total number of packets. */
+    packetCount: number;
+    /** The average number of packets per second. For video tracks, this will equal the average frame rate (FPS). */
+    averagePacketRate: number;
+    /** The average number of bits per second. */
+    averageBitrate: number;
+};
+export interface InputTrackBacking {
+    getId(): number;
+    getCodec(): MediaCodec | null;
+    getLanguageCode(): string;
+    getTimeResolution(): number;
+    getFirstTimestamp(): Promise<number>;
+    computeDuration(): Promise<number>;
+    getFirstPacket(options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+    getPacket(timestamp: number, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+    getNextPacket(packet: EncodedPacket, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+    getKeyPacket(timestamp: number, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+    getNextKeyPacket(packet: EncodedPacket, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+}
+/**
+ * Represents a media track in an input file.
+ * @public
+ */
+export declare abstract class InputTrack {
+    /** The type of the track. */
+    abstract get type(): TrackType;
+    /** The codec of the track's packets. */
+    abstract get codec(): MediaCodec | null;
+    /** Returns the full codec parameter string for this track. */
+    abstract getCodecParameterString(): Promise<string | null>;
+    /** Checks if this track's packets can be decoded by the browser. */
+    abstract canDecode(): Promise<boolean>;
+    /** Returns true iff this track is a video track. */
+    isVideoTrack(): this is InputVideoTrack;
+    /** Returns true iff this track is an audio track. */
+    isAudioTrack(): this is InputAudioTrack;
+    /** The unique ID of this track in the input file. */
+    get id(): number;
+    /** The ISO 639-2/T language code for this track. If the language is unknown, this field is 'und' (undetermined). */
+    get languageCode(): string;
+    /**
+     * A positive number x such that all timestamps and durations of all packets of this track are
+     * integer multiples of 1/x.
+     */
+    get timeResolution(): number;
+    /**
+     * Returns the start timestamp of the first packet of this track, in seconds. While often near zero, this value
+     * may be positive or even negative. A negative starting timestamp means the track's timing has been offset. Samples
+     * with a negative timestamp should not be presented.
+     */
+    getFirstTimestamp(): Promise<number>;
+    /** Returns the end timestamp of the last packet of this track, in seconds. */
+    computeDuration(): Promise<number>;
+    /**
+     * Computes aggregate packet statistics for this track, such as average packet rate or bitrate.
+     *
+     * @param targetPacketCount - This optional parameter sets a target for how many packets this method must have
+     * looked at before it can return early; this means, you can use it to aggregate only a subset (prefix) of all
+     * packets. This is very useful for getting a great estimate of video frame rate without having to scan through the
+     * entire file.
+     */
+    computePacketStats(targetPacketCount?: number): Promise<PacketStats>;
+}
+export interface InputVideoTrackBacking extends InputTrackBacking {
+    getCodec(): VideoCodec | null;
+    getCodedWidth(): number;
+    getCodedHeight(): number;
+    getRotation(): Rotation;
+    getColorSpace(): Promise<VideoColorSpaceInit>;
+    getDecoderConfig(): Promise<VideoDecoderConfig | null>;
+}
+/**
+ * Represents a video track in an input file.
+ * @public
+ */
+export declare class InputVideoTrack extends InputTrack {
+    get type(): TrackType;
+    get codec(): "avc" | "hevc" | "vp9" | "av1" | "vp8" | null;
+    /** The width in pixels of the track's coded samples, before any transformations or rotations. */
+    get codedWidth(): number;
+    /** The height in pixels of the track's coded samples, before any transformations or rotations. */
+    get codedHeight(): number;
+    /** The angle in degrees by which the track's frames should be rotated (clockwise). */
+    get rotation(): Rotation;
+    /** The width in pixels of the track's frames after rotation. */
+    get displayWidth(): number;
+    /** The height in pixels of the track's frames after rotation. */
+    get displayHeight(): number;
+    /** Returns the color space of the track's samples. */
+    getColorSpace(): Promise<VideoColorSpaceInit>;
+    /** If this method returns true, the track's samples use a high dynamic range (HDR). */
+    hasHighDynamicRange(): Promise<boolean>;
+    /** Returns the decoder configuration for decoding the track's packets using a VideoDecoder. */
+    getDecoderConfig(): Promise<VideoDecoderConfig | null>;
+    getCodecParameterString(): Promise<string | null>;
+    canDecode(): Promise<boolean>;
+}
+export interface InputAudioTrackBacking extends InputTrackBacking {
+    getCodec(): AudioCodec | null;
+    getNumberOfChannels(): number;
+    getSampleRate(): number;
+    getDecoderConfig(): Promise<AudioDecoderConfig | null>;
+}
+/**
+ * Represents an audio track in an input file.
+ * @public
+ */
+export declare class InputAudioTrack extends InputTrack {
+    get type(): TrackType;
+    get codec(): AudioCodec | null;
+    /** The number of audio channels in the track. */
+    get numberOfChannels(): number;
+    /** The track's audio sample rate in hertz. */
+    get sampleRate(): number;
+    /** Returns the decoder configuration for decoding the track's packets using an AudioDecoder. */
+    getDecoderConfig(): Promise<AudioDecoderConfig | null>;
+    getCodecParameterString(): Promise<string | null>;
+    canDecode(): Promise<boolean>;
+}
+//# sourceMappingURL=input-track.d.ts.map

package/dist/modules/input-track.d.ts.map

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