@kenzuya/mediabunny 1.26.0 → 1.28.5

package/dist/modules/src/mp3/mp3-demuxer.js

@@ -1,285 +0,0 @@
-/*!
- * 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 { Demuxer } from '../demuxer.js';
-import { InputAudioTrack } from '../input-track.js';
-import { DEFAULT_TRACK_DISPOSITION } from '../metadata.js';
-import { assert, AsyncMutex, binarySearchExact, binarySearchLessOrEqual, UNDETERMINED_LANGUAGE } from '../misc.js';
-import { EncodedPacket, PLACEHOLDER_DATA } from '../packet.js';
-import { getXingOffset, INFO, XING } from '../../shared/mp3-misc.js';
-import { ID3_V1_TAG_SIZE, ID3_V2_HEADER_SIZE, parseId3V1Tag, parseId3V2Tag, readId3V2Header, } from '../id3.js';
-import { readNextFrameHeader } from './mp3-reader.js';
-import { readAscii, readBytes, readU32Be } from '../reader.js';
-export class Mp3Demuxer extends Demuxer {
-    constructor(input) {
-        super(input);
-        this.metadataPromise = null;
-        this.firstFrameHeader = null;
-        this.loadedSamples = []; // All samples from the start of the file to lastLoadedPos
-        this.metadataTags = null;
-        this.tracks = [];
-        this.readingMutex = new AsyncMutex();
-        this.lastSampleLoaded = false;
-        this.lastLoadedPos = 0;
-        this.nextTimestampInSamples = 0;
-        this.reader = input._reader;
-    }
-    async readMetadata() {
-        return this.metadataPromise ??= (async () => {
-            // Keep loading until we find the first frame header
-            while (!this.firstFrameHeader && !this.lastSampleLoaded) {
-                await this.advanceReader();
-            }
-            if (!this.firstFrameHeader) {
-                throw new Error('No valid MP3 frame found.');
-            }
-            this.tracks = [new InputAudioTrack(this.input, new Mp3AudioTrackBacking(this))];
-        })();
-    }
-    async advanceReader() {
-        if (this.lastLoadedPos === 0) {
-            // Let's skip all ID3v2 tags at the start of the file
-            while (true) {
-                let slice = this.reader.requestSlice(this.lastLoadedPos, ID3_V2_HEADER_SIZE);
-                if (slice instanceof Promise)
-                    slice = await slice;
-                if (!slice) {
-                    this.lastSampleLoaded = true;
-                    return;
-                }
-                const id3V2Header = readId3V2Header(slice);
-                if (!id3V2Header) {
-                    break;
-                }
-                this.lastLoadedPos = slice.filePos + id3V2Header.size;
-            }
-        }
-        const result = await readNextFrameHeader(this.reader, this.lastLoadedPos, this.reader.fileSize);
-        if (!result) {
-            this.lastSampleLoaded = true;
-            return;
-        }
-        const header = result.header;
-        this.lastLoadedPos = result.startPos + header.totalSize - 1; // -1 in case the frame is 1 byte too short
-        const xingOffset = getXingOffset(header.mpegVersionId, header.channel);
-        let slice = this.reader.requestSlice(result.startPos + xingOffset, 4);
-        if (slice instanceof Promise)
-            slice = await slice;
-        if (slice) {
-            const word = readU32Be(slice);
-            const isXing = word === XING || word === INFO;
-            if (isXing) {
-                // There's no actual audio data in this frame, so let's skip it
-                return;
-            }
-        }
-        if (!this.firstFrameHeader) {
-            this.firstFrameHeader = header;
-        }
-        if (header.sampleRate !== this.firstFrameHeader.sampleRate) {
-            console.warn(`MP3 changed sample rate mid-file: ${this.firstFrameHeader.sampleRate} Hz to ${header.sampleRate} Hz.`
-                + ` Might be a bug, so please report this file.`);
-        }
-        const sampleDuration = header.audioSamplesInFrame / this.firstFrameHeader.sampleRate;
-        const sample = {
-            timestamp: this.nextTimestampInSamples / this.firstFrameHeader.sampleRate,
-            duration: sampleDuration,
-            dataStart: result.startPos,
-            dataSize: header.totalSize,
-        };
-        this.loadedSamples.push(sample);
-        this.nextTimestampInSamples += header.audioSamplesInFrame;
-        return;
-    }
-    async getMimeType() {
-        return 'audio/mpeg';
-    }
-    async getTracks() {
-        await this.readMetadata();
-        return this.tracks;
-    }
-    async computeDuration() {
-        await this.readMetadata();
-        const track = this.tracks[0];
-        assert(track);
-        return track.computeDuration();
-    }
-    async getMetadataTags() {
-        const release = await this.readingMutex.acquire();
-        try {
-            await this.readMetadata();
-            if (this.metadataTags) {
-                return this.metadataTags;
-            }
-            this.metadataTags = {};
-            let currentPos = 0;
-            let id3V2HeaderFound = false;
-            while (true) {
-                let headerSlice = this.reader.requestSlice(currentPos, ID3_V2_HEADER_SIZE);
-                if (headerSlice instanceof Promise)
-                    headerSlice = await headerSlice;
-                if (!headerSlice)
-                    break;
-                const id3V2Header = readId3V2Header(headerSlice);
-                if (!id3V2Header) {
-                    break;
-                }
-                id3V2HeaderFound = true;
-                let contentSlice = this.reader.requestSlice(headerSlice.filePos, id3V2Header.size);
-                if (contentSlice instanceof Promise)
-                    contentSlice = await contentSlice;
-                if (!contentSlice)
-                    break;
-                parseId3V2Tag(contentSlice, id3V2Header, this.metadataTags);
-                currentPos = headerSlice.filePos + id3V2Header.size;
-            }
-            if (!id3V2HeaderFound && this.reader.fileSize !== null && this.reader.fileSize >= ID3_V1_TAG_SIZE) {
-                // Try reading an ID3v1 tag at the end of the file
-                let slice = this.reader.requestSlice(this.reader.fileSize - ID3_V1_TAG_SIZE, ID3_V1_TAG_SIZE);
-                if (slice instanceof Promise)
-                    slice = await slice;
-                assert(slice);
-                const tag = readAscii(slice, 3);
-                if (tag === 'TAG') {
-                    parseId3V1Tag(slice, this.metadataTags);
-                }
-            }
-            return this.metadataTags;
-        }
-        finally {
-            release();
-        }
-    }
-}
-class Mp3AudioTrackBacking {
-    constructor(demuxer) {
-        this.demuxer = demuxer;
-    }
-    getId() {
-        return 1;
-    }
-    async getFirstTimestamp() {
-        return 0;
-    }
-    getTimeResolution() {
-        assert(this.demuxer.firstFrameHeader);
-        return this.demuxer.firstFrameHeader.sampleRate / this.demuxer.firstFrameHeader.audioSamplesInFrame;
-    }
-    async computeDuration() {
-        const lastPacket = await this.getPacket(Infinity, { metadataOnly: true });
-        return (lastPacket?.timestamp ?? 0) + (lastPacket?.duration ?? 0);
-    }
-    getName() {
-        return null;
-    }
-    getLanguageCode() {
-        return UNDETERMINED_LANGUAGE;
-    }
-    getCodec() {
-        return 'mp3';
-    }
-    getInternalCodecId() {
-        return null;
-    }
-    getNumberOfChannels() {
-        assert(this.demuxer.firstFrameHeader);
-        return this.demuxer.firstFrameHeader.channel === 3 ? 1 : 2;
-    }
-    getSampleRate() {
-        assert(this.demuxer.firstFrameHeader);
-        return this.demuxer.firstFrameHeader.sampleRate;
-    }
-    getDisposition() {
-        return {
-            ...DEFAULT_TRACK_DISPOSITION,
-        };
-    }
-    async getDecoderConfig() {
-        assert(this.demuxer.firstFrameHeader);
-        return {
-            codec: 'mp3',
-            numberOfChannels: this.demuxer.firstFrameHeader.channel === 3 ? 1 : 2,
-            sampleRate: this.demuxer.firstFrameHeader.sampleRate,
-        };
-    }
-    async getPacketAtIndex(sampleIndex, options) {
-        if (sampleIndex === -1) {
-            return null;
-        }
-        const rawSample = this.demuxer.loadedSamples[sampleIndex];
-        if (!rawSample) {
-            return null;
-        }
-        let data;
-        if (options.metadataOnly) {
-            data = PLACEHOLDER_DATA;
-        }
-        else {
-            let slice = this.demuxer.reader.requestSlice(rawSample.dataStart, rawSample.dataSize);
-            if (slice instanceof Promise)
-                slice = await slice;
-            if (!slice) {
-                return null; // Data didn't fit into the rest of the file
-            }
-            data = readBytes(slice, rawSample.dataSize);
-        }
-        return new EncodedPacket(data, 'key', rawSample.timestamp, rawSample.duration, sampleIndex, rawSample.dataSize);
-    }
-    getFirstPacket(options) {
-        return this.getPacketAtIndex(0, options);
-    }
-    async getNextPacket(packet, options) {
-        const release = await this.demuxer.readingMutex.acquire();
-        try {
-            const sampleIndex = binarySearchExact(this.demuxer.loadedSamples, packet.timestamp, x => x.timestamp);
-            if (sampleIndex === -1) {
-                throw new Error('Packet was not created from this track.');
-            }
-            const nextIndex = sampleIndex + 1;
-            // Ensure the next sample exists
-            while (nextIndex >= this.demuxer.loadedSamples.length
-                && !this.demuxer.lastSampleLoaded) {
-                await this.demuxer.advanceReader();
-            }
-            return this.getPacketAtIndex(nextIndex, options);
-        }
-        finally {
-            release();
-        }
-    }
-    async getPacket(timestamp, options) {
-        const release = await this.demuxer.readingMutex.acquire();
-        try {
-            while (true) {
-                const index = binarySearchLessOrEqual(this.demuxer.loadedSamples, timestamp, x => x.timestamp);
-                if (index === -1 && this.demuxer.loadedSamples.length > 0) {
-                    // We're before the first sample
-                    return null;
-                }
-                if (this.demuxer.lastSampleLoaded) {
-                    // All data is loaded, return what we found
-                    return this.getPacketAtIndex(index, options);
-                }
-                if (index >= 0 && index + 1 < this.demuxer.loadedSamples.length) {
-                    // The next packet also exists, we're done
-                    return this.getPacketAtIndex(index, options);
-                }
-                // Otherwise, keep loading data
-                await this.demuxer.advanceReader();
-            }
-        }
-        finally {
-            release();
-        }
-    }
-    getKeyPacket(timestamp, options) {
-        return this.getPacket(timestamp, options);
-    }
-    getNextKeyPacket(packet, options) {
-        return this.getNextPacket(packet, options);
-    }
-}

package/dist/modules/src/mp3/mp3-muxer.js

@@ -1,123 +0,0 @@
-/*!
- * 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 { assert, toDataView } from '../misc.js';
-import { metadataTagsAreEmpty } from '../metadata.js';
-import { Muxer } from '../muxer.js';
-import { getXingOffset, INFO, readFrameHeader, XING } from '../../shared/mp3-misc.js';
-import { Mp3Writer } from './mp3-writer.js';
-import { Id3V2Writer } from '../id3.js';
-export class Mp3Muxer extends Muxer {
-    constructor(output, format) {
-        super(output);
-        this.xingFrameData = null;
-        this.frameCount = 0;
-        this.framePositions = [];
-        this.xingFramePos = null;
-        this.format = format;
-        this.writer = output._writer;
-        this.mp3Writer = new Mp3Writer(output._writer);
-    }
-    async start() {
-        if (!metadataTagsAreEmpty(this.output._metadataTags)) {
-            const id3Writer = new Id3V2Writer(this.writer);
-            id3Writer.writeId3V2Tag(this.output._metadataTags);
-        }
-    }
-    async getMimeType() {
-        return 'audio/mpeg';
-    }
-    async addEncodedVideoPacket() {
-        throw new Error('MP3 does not support video.');
-    }
-    async addEncodedAudioPacket(track, packet) {
-        const release = await this.mutex.acquire();
-        try {
-            const writeXingHeader = this.format._options.xingHeader !== false;
-            if (!this.xingFrameData && writeXingHeader) {
-                const view = toDataView(packet.data);
-                if (view.byteLength < 4) {
-                    throw new Error('Invalid MP3 header in sample.');
-                }
-                const word = view.getUint32(0, false);
-                const header = readFrameHeader(word, null).header;
-                if (!header) {
-                    throw new Error('Invalid MP3 header in sample.');
-                }
-                const xingOffset = getXingOffset(header.mpegVersionId, header.channel);
-                if (view.byteLength >= xingOffset + 4) {
-                    const word = view.getUint32(xingOffset, false);
-                    const isXing = word === XING || word === INFO;
-                    if (isXing) {
-                        // This is not a data frame, so let's completely ignore this sample
-                        return;
-                    }
-                }
-                this.xingFrameData = {
-                    mpegVersionId: header.mpegVersionId,
-                    layer: header.layer,
-                    frequencyIndex: header.frequencyIndex,
-                    sampleRate: header.sampleRate,
-                    channel: header.channel,
-                    modeExtension: header.modeExtension,
-                    copyright: header.copyright,
-                    original: header.original,
-                    emphasis: header.emphasis,
-                    frameCount: null,
-                    fileSize: null,
-                    toc: null,
-                };
-                // Write a Xing frame because this muxer doesn't make any bitrate constraints, meaning we don't know if
-                // this will be a constant or variable bitrate file. Therefore, always write the Xing frame.
-                this.xingFramePos = this.writer.getPos();
-                this.mp3Writer.writeXingFrame(this.xingFrameData);
-                this.frameCount++;
-            }
-            this.validateAndNormalizeTimestamp(track, packet.timestamp, packet.type === 'key');
-            this.writer.write(packet.data);
-            this.frameCount++;
-            await this.writer.flush();
-            if (writeXingHeader) {
-                this.framePositions.push(this.writer.getPos());
-            }
-        }
-        finally {
-            release();
-        }
-    }
-    async addSubtitleCue() {
-        throw new Error('MP3 does not support subtitles.');
-    }
-    async finalize() {
-        if (!this.xingFrameData || this.xingFramePos === null) {
-            return;
-        }
-        const release = await this.mutex.acquire();
-        const endPos = this.writer.getPos();
-        this.writer.seek(this.xingFramePos);
-        const toc = new Uint8Array(100);
-        for (let i = 0; i < 100; i++) {
-            const index = Math.floor(this.framePositions.length * (i / 100));
-            assert(index !== -1 && index < this.framePositions.length);
-            const byteOffset = this.framePositions[index];
-            toc[i] = 256 * (byteOffset / endPos);
-        }
-        this.xingFrameData.frameCount = this.frameCount;
-        this.xingFrameData.fileSize = endPos;
-        this.xingFrameData.toc = toc;
-        if (this.format._options.onXingFrame) {
-            this.writer.startTrackingWrites();
-        }
-        this.mp3Writer.writeXingFrame(this.xingFrameData);
-        if (this.format._options.onXingFrame) {
-            const { data, start } = this.writer.stopTrackingWrites();
-            this.format._options.onXingFrame(data, start);
-        }
-        this.writer.seek(endPos);
-        release();
-    }
-}

package/dist/modules/src/mp3/mp3-reader.js

@@ -1,26 +0,0 @@
-/*!
- * 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 { FRAME_HEADER_SIZE, readFrameHeader } from '../../shared/mp3-misc.js';
-import { readU32Be } from '../reader.js';
-export const readNextFrameHeader = async (reader, startPos, until) => {
-    let currentPos = startPos;
-    while (until === null || currentPos < until) {
-        let slice = reader.requestSlice(currentPos, FRAME_HEADER_SIZE);
-        if (slice instanceof Promise)
-            slice = await slice;
-        if (!slice)
-            break;
-        const word = readU32Be(slice);
-        const result = readFrameHeader(word, reader.fileSize !== null ? reader.fileSize - currentPos : null);
-        if (result.header) {
-            return { header: result.header, startPos: currentPos };
-        }
-        currentPos += result.bytesAdvanced;
-    }
-    return null;
-};

package/dist/modules/src/mp3/mp3-writer.js

@@ -1,78 +0,0 @@
-/*!
- * 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 { computeMp3FrameSize, getXingOffset, KILOBIT_RATES, XING, } from '../../shared/mp3-misc.js';
-export class Mp3Writer {
-    constructor(writer) {
-        this.writer = writer;
-        this.helper = new Uint8Array(8);
-        this.helperView = new DataView(this.helper.buffer);
-    }
-    writeU32(value) {
-        this.helperView.setUint32(0, value, false);
-        this.writer.write(this.helper.subarray(0, 4));
-    }
-    writeXingFrame(data) {
-        const startPos = this.writer.getPos();
-        const firstByte = 0xff;
-        const secondByte = 0xe0 | (data.mpegVersionId << 3) | (data.layer << 1);
-        let lowSamplingFrequency;
-        if (data.mpegVersionId & 2) {
-            lowSamplingFrequency = (data.mpegVersionId & 1) ? 0 : 1;
-        }
-        else {
-            lowSamplingFrequency = 1;
-        }
-        const padding = 0;
-        const neededBytes = 155;
-        let bitrateIndex = -1;
-        const bitrateOffset = lowSamplingFrequency * 16 * 4 + data.layer * 16;
-        // Let's find the lowest bitrate for which the frame size is sufficiently large to fit all the data
-        for (let i = 0; i < 16; i++) {
-            const kbr = KILOBIT_RATES[bitrateOffset + i];
-            const size = computeMp3FrameSize(lowSamplingFrequency, data.layer, 1000 * kbr, data.sampleRate, padding);
-            if (size >= neededBytes) {
-                bitrateIndex = i;
-                break;
-            }
-        }
-        if (bitrateIndex === -1) {
-            throw new Error('No suitable bitrate found.');
-        }
-        const thirdByte = (bitrateIndex << 4) | (data.frequencyIndex << 2) | padding << 1;
-        const fourthByte = (data.channel << 6)
-            | (data.modeExtension << 4)
-            | (data.copyright << 3)
-            | (data.original << 2)
-            | data.emphasis;
-        this.helper[0] = firstByte;
-        this.helper[1] = secondByte;
-        this.helper[2] = thirdByte;
-        this.helper[3] = fourthByte;
-        this.writer.write(this.helper.subarray(0, 4));
-        const xingOffset = getXingOffset(data.mpegVersionId, data.channel);
-        this.writer.seek(startPos + xingOffset);
-        this.writeU32(XING);
-        let flags = 0;
-        if (data.frameCount !== null) {
-            flags |= 1;
-        }
-        if (data.fileSize !== null) {
-            flags |= 2;
-        }
-        if (data.toc !== null) {
-            flags |= 4;
-        }
-        this.writeU32(flags);
-        this.writeU32(data.frameCount ?? 0);
-        this.writeU32(data.fileSize ?? 0);
-        this.writer.write(data.toc ?? new Uint8Array(100));
-        const kilobitRate = KILOBIT_RATES[bitrateOffset + bitrateIndex];
-        const frameSize = computeMp3FrameSize(lowSamplingFrequency, data.layer, 1000 * kilobitRate, data.sampleRate, padding);
-        this.writer.seek(startPos + frameSize);
-    }
-}

package/dist/modules/src/muxer.js

@@ -1,50 +0,0 @@
-/*!
- * 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 } from './misc.js';
-export class Muxer {
-    constructor(output) {
-        this.mutex = new AsyncMutex();
-        /**
-         * This field is used to synchronize multiple MediaStreamTracks. They use the same time coordinate system across
-         * tracks, and to ensure correct audio-video sync, we must use the same offset for all of them. The reason an offset
-         * is needed at all is because the timestamps typically don't start at zero.
-         */
-        this.firstMediaStreamTimestamp = null;
-        this.trackTimestampInfo = new WeakMap();
-        this.output = output;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    onTrackClose(track) { }
-    validateAndNormalizeTimestamp(track, timestampInSeconds, isKeyPacket) {
-        timestampInSeconds += track.source._timestampOffset;
-        let timestampInfo = this.trackTimestampInfo.get(track);
-        if (!timestampInfo) {
-            if (!isKeyPacket) {
-                throw new Error('First packet must be a key packet.');
-            }
-            timestampInfo = {
-                maxTimestamp: timestampInSeconds,
-                maxTimestampBeforeLastKeyPacket: timestampInSeconds,
-            };
-            this.trackTimestampInfo.set(track, timestampInfo);
-        }
-        if (timestampInSeconds < 0) {
-            throw new Error(`Timestamps must be non-negative (got ${timestampInSeconds}s).`);
-        }
-        if (isKeyPacket) {
-            timestampInfo.maxTimestampBeforeLastKeyPacket = timestampInfo.maxTimestamp;
-        }
-        if (timestampInSeconds < timestampInfo.maxTimestampBeforeLastKeyPacket) {
-            throw new Error(`Timestamps cannot be smaller than the largest timestamp of the previous GOP (a GOP begins with a key`
-                + ` packet and ends right before the next key packet). Got ${timestampInSeconds}s, but largest`
-                + ` timestamp is ${timestampInfo.maxTimestampBeforeLastKeyPacket}s.`);
-        }
-        timestampInfo.maxTimestamp = Math.max(timestampInfo.maxTimestamp, timestampInSeconds);
-        return timestampInSeconds;
-    }
-}

package/dist/modules/src/node.js

@@ -1,9 +0,0 @@
-/*!
- * 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/.
- */
-// This file contains Node.js-specific code that does not run in a browser.
-export * as fs from 'node:fs/promises';