@kenzuya/mediabunny 1.26.0 → 1.28.6

package/dist/modules/shared/mp3-misc.js

@@ -1,147 +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/.
- */
-export const FRAME_HEADER_SIZE = 4;
-export const SAMPLING_RATES = [44100, 48000, 32000];
-export const KILOBIT_RATES = [
-    // lowSamplingFrequency === 0
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // layer = 0
-    -1, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, -1, // layer 1
-    -1, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, -1, // layer = 2
-    -1, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, -1, // layer = 3
-    // lowSamplingFrequency === 1
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // layer = 0
-    -1, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, -1, // layer = 1
-    -1, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, -1, // layer = 2
-    -1, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, -1, // layer = 3
-];
-/** 'Xing' */
-export const XING = 0x58696e67;
-/** 'Info' */
-export const INFO = 0x496e666f;
-export const computeMp3FrameSize = (lowSamplingFrequency, layer, bitrate, sampleRate, padding) => {
-    if (layer === 0) {
-        return 0; // Not expected that this is hit
-    }
-    else if (layer === 1) {
-        return Math.floor(144 * bitrate / (sampleRate << lowSamplingFrequency)) + padding;
-    }
-    else if (layer === 2) {
-        return Math.floor(144 * bitrate / sampleRate) + padding;
-    }
-    else { // layer === 3
-        return (Math.floor(12 * bitrate / sampleRate) + padding) * 4;
-    }
-};
-export const getXingOffset = (mpegVersionId, channel) => {
-    return mpegVersionId === 3
-        ? (channel === 3 ? 21 : 36)
-        : (channel === 3 ? 13 : 21);
-};
-export const readFrameHeader = (word, remainingBytes) => {
-    const firstByte = word >>> 24;
-    const secondByte = (word >>> 16) & 0xff;
-    const thirdByte = (word >>> 8) & 0xff;
-    const fourthByte = word & 0xff;
-    if (firstByte !== 0xff && secondByte !== 0xff && thirdByte !== 0xff && fourthByte !== 0xff) {
-        return {
-            header: null,
-            bytesAdvanced: 4,
-        };
-    }
-    if (firstByte !== 0xff) {
-        return { header: null, bytesAdvanced: 1 };
-    }
-    if ((secondByte & 0xe0) !== 0xe0) {
-        return { header: null, bytesAdvanced: 1 };
-    }
-    let lowSamplingFrequency = 0;
-    let mpeg25 = 0;
-    if (secondByte & (1 << 4)) {
-        lowSamplingFrequency = (secondByte & (1 << 3)) ? 0 : 1;
-    }
-    else {
-        lowSamplingFrequency = 1;
-        mpeg25 = 1;
-    }
-    const mpegVersionId = (secondByte >> 3) & 0x3;
-    const layer = (secondByte >> 1) & 0x3;
-    const bitrateIndex = (thirdByte >> 4) & 0xf;
-    const frequencyIndex = ((thirdByte >> 2) & 0x3) % 3;
-    const padding = (thirdByte >> 1) & 0x1;
-    const channel = (fourthByte >> 6) & 0x3;
-    const modeExtension = (fourthByte >> 4) & 0x3;
-    const copyright = (fourthByte >> 3) & 0x1;
-    const original = (fourthByte >> 2) & 0x1;
-    const emphasis = fourthByte & 0x3;
-    const kilobitRate = KILOBIT_RATES[lowSamplingFrequency * 16 * 4 + layer * 16 + bitrateIndex];
-    if (kilobitRate === -1) {
-        return { header: null, bytesAdvanced: 1 };
-    }
-    const bitrate = kilobitRate * 1000;
-    const sampleRate = SAMPLING_RATES[frequencyIndex] >> (lowSamplingFrequency + mpeg25);
-    const frameLength = computeMp3FrameSize(lowSamplingFrequency, layer, bitrate, sampleRate, padding);
-    if (remainingBytes !== null && remainingBytes < frameLength) {
-        // The frame doesn't fit into the rest of the file
-        return { header: null, bytesAdvanced: 1 };
-    }
-    let audioSamplesInFrame;
-    if (mpegVersionId === 3) {
-        audioSamplesInFrame = layer === 3 ? 384 : 1152;
-    }
-    else {
-        if (layer === 3) {
-            audioSamplesInFrame = 384;
-        }
-        else if (layer === 2) {
-            audioSamplesInFrame = 1152;
-        }
-        else {
-            audioSamplesInFrame = 576;
-        }
-    }
-    return {
-        header: {
-            totalSize: frameLength,
-            mpegVersionId,
-            layer,
-            bitrate,
-            frequencyIndex,
-            sampleRate,
-            channel,
-            modeExtension,
-            copyright,
-            original,
-            emphasis,
-            audioSamplesInFrame,
-        },
-        bytesAdvanced: 1,
-    };
-};
-export const encodeSynchsafe = (unsynchsafed) => {
-    let mask = 0x7f;
-    let synchsafed = 0;
-    let unsynchsafedRest = unsynchsafed;
-    while ((mask ^ 0x7fffffff) !== 0) {
-        synchsafed = unsynchsafedRest & ~mask;
-        synchsafed <<= 1;
-        synchsafed |= unsynchsafedRest & mask;
-        mask = ((mask + 1) << 8) - 1;
-        unsynchsafedRest = synchsafed;
-    }
-    return synchsafed;
-};
-export const decodeSynchsafe = (synchsafed) => {
-    let mask = 0x7f000000;
-    let unsynchsafed = 0;
-    while (mask !== 0) {
-        unsynchsafed >>= 1;
-        unsynchsafed |= synchsafed & mask;
-        mask >>= 8;
-    }
-    return unsynchsafed;
-};

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

@@ -1,239 +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 { aacChannelMap, aacFrequencyTable } from '../codec.js';
-import { Demuxer } from '../demuxer.js';
-import { InputAudioTrack } from '../input-track.js';
-import { assert, AsyncMutex, binarySearchExact, binarySearchLessOrEqual, Bitstream, UNDETERMINED_LANGUAGE, } from '../misc.js';
-import { EncodedPacket, PLACEHOLDER_DATA } from '../packet.js';
-import { readBytes } from '../reader.js';
-import { DEFAULT_TRACK_DISPOSITION } from '../metadata.js';
-import { MAX_FRAME_HEADER_SIZE, MIN_FRAME_HEADER_SIZE, readFrameHeader } from './adts-reader.js';
-const SAMPLES_PER_AAC_FRAME = 1024;
-export class AdtsDemuxer extends Demuxer {
-    constructor(input) {
-        super(input);
-        this.metadataPromise = null;
-        this.firstFrameHeader = null;
-        this.loadedSamples = [];
-        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();
-            }
-            // There has to be a frame if this demuxer got selected
-            assert(this.firstFrameHeader);
-            // Create the single audio track
-            this.tracks = [new InputAudioTrack(this.input, new AdtsAudioTrackBacking(this))];
-        })();
-    }
-    async advanceReader() {
-        let slice = this.reader.requestSliceRange(this.lastLoadedPos, MIN_FRAME_HEADER_SIZE, MAX_FRAME_HEADER_SIZE);
-        if (slice instanceof Promise)
-            slice = await slice;
-        if (!slice) {
-            this.lastSampleLoaded = true;
-            return;
-        }
-        const header = readFrameHeader(slice);
-        if (!header) {
-            this.lastSampleLoaded = true;
-            return;
-        }
-        if (this.reader.fileSize !== null && header.startPos + header.frameLength > this.reader.fileSize) {
-            // Frame doesn't fit in the rest of the file
-            this.lastSampleLoaded = true;
-            return;
-        }
-        if (!this.firstFrameHeader) {
-            this.firstFrameHeader = header;
-        }
-        const sampleRate = aacFrequencyTable[header.samplingFrequencyIndex];
-        assert(sampleRate !== undefined);
-        const sampleDuration = SAMPLES_PER_AAC_FRAME / sampleRate;
-        const headerSize = header.crcCheck ? MAX_FRAME_HEADER_SIZE : MIN_FRAME_HEADER_SIZE;
-        const sample = {
-            timestamp: this.nextTimestampInSamples / sampleRate,
-            duration: sampleDuration,
-            dataStart: header.startPos + headerSize,
-            dataSize: header.frameLength - headerSize,
-        };
-        this.loadedSamples.push(sample);
-        this.nextTimestampInSamples += SAMPLES_PER_AAC_FRAME;
-        this.lastLoadedPos = header.startPos + header.frameLength;
-    }
-    async getMimeType() {
-        return 'audio/aac';
-    }
-    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() {
-        return {}; // No tags in this one
-    }
-}
-class AdtsAudioTrackBacking {
-    constructor(demuxer) {
-        this.demuxer = demuxer;
-    }
-    getId() {
-        return 1;
-    }
-    async getFirstTimestamp() {
-        return 0;
-    }
-    getTimeResolution() {
-        const sampleRate = this.getSampleRate();
-        return sampleRate / SAMPLES_PER_AAC_FRAME;
-    }
-    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 'aac';
-    }
-    getInternalCodecId() {
-        assert(this.demuxer.firstFrameHeader);
-        return this.demuxer.firstFrameHeader.objectType;
-    }
-    getNumberOfChannels() {
-        assert(this.demuxer.firstFrameHeader);
-        const numberOfChannels = aacChannelMap[this.demuxer.firstFrameHeader.channelConfiguration];
-        assert(numberOfChannels !== undefined);
-        return numberOfChannels;
-    }
-    getSampleRate() {
-        assert(this.demuxer.firstFrameHeader);
-        const sampleRate = aacFrequencyTable[this.demuxer.firstFrameHeader.samplingFrequencyIndex];
-        assert(sampleRate !== undefined);
-        return sampleRate;
-    }
-    getDisposition() {
-        return {
-            ...DEFAULT_TRACK_DISPOSITION,
-        };
-    }
-    async getDecoderConfig() {
-        assert(this.demuxer.firstFrameHeader);
-        const bytes = new Uint8Array(3); // 19 bits max
-        const bitstream = new Bitstream(bytes);
-        const { objectType, samplingFrequencyIndex, channelConfiguration } = this.demuxer.firstFrameHeader;
-        if (objectType > 31) {
-            bitstream.writeBits(5, 31);
-            bitstream.writeBits(6, objectType - 32);
-        }
-        else {
-            bitstream.writeBits(5, objectType);
-        }
-        bitstream.writeBits(4, samplingFrequencyIndex); // samplingFrequencyIndex === 15 is forbidden
-        bitstream.writeBits(4, channelConfiguration);
-        return {
-            codec: `mp4a.40.${this.demuxer.firstFrameHeader.objectType}`,
-            numberOfChannels: this.getNumberOfChannels(),
-            sampleRate: this.getSampleRate(),
-            description: bytes.subarray(0, Math.ceil((bitstream.pos - 1) / 8)),
-        };
-    }
-    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/adts/adts-muxer.js

@@ -1,80 +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 { parseAacAudioSpecificConfig, validateAudioChunkMetadata } from '../codec.js';
-import { assert, Bitstream, toUint8Array } from '../misc.js';
-import { Muxer } from '../muxer.js';
-export class AdtsMuxer extends Muxer {
-    constructor(output, format) {
-        super(output);
-        this.header = new Uint8Array(7);
-        this.headerBitstream = new Bitstream(this.header);
-        this.audioSpecificConfig = null;
-        this.format = format;
-        this.writer = output._writer;
-    }
-    async start() {
-        // Nothing needed here
-    }
-    async getMimeType() {
-        return 'audio/aac';
-    }
-    async addEncodedVideoPacket() {
-        throw new Error('ADTS does not support video.');
-    }
-    async addEncodedAudioPacket(track, packet, meta) {
-        // https://wiki.multimedia.cx/index.php/ADTS (last visited: 2025/08/17)
-        const release = await this.mutex.acquire();
-        try {
-            this.validateAndNormalizeTimestamp(track, packet.timestamp, packet.type === 'key');
-            if (!this.audioSpecificConfig) {
-                validateAudioChunkMetadata(meta);
-                const description = meta?.decoderConfig?.description;
-                assert(description);
-                this.audioSpecificConfig = parseAacAudioSpecificConfig(toUint8Array(description));
-                const { objectType, frequencyIndex, channelConfiguration } = this.audioSpecificConfig;
-                const profile = objectType - 1;
-                this.headerBitstream.writeBits(12, 0b1111_11111111); // Syncword
-                this.headerBitstream.writeBits(1, 0); // MPEG Version
-                this.headerBitstream.writeBits(2, 0); // Layer
-                this.headerBitstream.writeBits(1, 1); // Protection absence
-                this.headerBitstream.writeBits(2, profile); // Profile
-                this.headerBitstream.writeBits(4, frequencyIndex); // MPEG-4 Sampling Frequency Index
-                this.headerBitstream.writeBits(1, 0); // Private bit
-                this.headerBitstream.writeBits(3, channelConfiguration); // MPEG-4 Channel Configuration
-                this.headerBitstream.writeBits(1, 0); // Originality
-                this.headerBitstream.writeBits(1, 0); // Home
-                this.headerBitstream.writeBits(1, 0); // Copyright ID bit
-                this.headerBitstream.writeBits(1, 0); // Copyright ID start
-                this.headerBitstream.skipBits(13); // Frame length
-                this.headerBitstream.writeBits(11, 0x7ff); // Buffer fullness
-                this.headerBitstream.writeBits(2, 0); // Number of AAC frames minus 1
-                // Omit CRC check
-            }
-            const frameLength = packet.data.byteLength + this.header.byteLength;
-            this.headerBitstream.pos = 30;
-            this.headerBitstream.writeBits(13, frameLength);
-            const startPos = this.writer.getPos();
-            this.writer.write(this.header);
-            this.writer.write(packet.data);
-            if (this.format._options.onFrame) {
-                const frameBytes = new Uint8Array(frameLength);
-                frameBytes.set(this.header, 0);
-                frameBytes.set(packet.data, this.header.byteLength);
-                this.format._options.onFrame(frameBytes, startPos);
-            }
-            await this.writer.flush();
-        }
-        finally {
-            release();
-        }
-    }
-    async addSubtitleCue() {
-        throw new Error('ADTS does not support subtitles.');
-    }
-    async finalize() { }
-}

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

@@ -1,63 +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 { Bitstream } from '../misc.js';
-import { readBytes } from '../reader.js';
-export const MIN_FRAME_HEADER_SIZE = 7;
-export const MAX_FRAME_HEADER_SIZE = 9;
-export const readFrameHeader = (slice) => {
-    // https://wiki.multimedia.cx/index.php/ADTS (last visited: 2025/08/17)
-    const startPos = slice.filePos;
-    const bytes = readBytes(slice, 9); // 9 with CRC, 7 without CRC
-    const bitstream = new Bitstream(bytes);
-    const syncword = bitstream.readBits(12);
-    if (syncword !== 0b1111_11111111) {
-        return null;
-    }
-    bitstream.skipBits(1); // MPEG version
-    const layer = bitstream.readBits(2);
-    if (layer !== 0) {
-        return null;
-    }
-    const protectionAbsence = bitstream.readBits(1);
-    const objectType = bitstream.readBits(2) + 1;
-    const samplingFrequencyIndex = bitstream.readBits(4);
-    if (samplingFrequencyIndex === 15) {
-        return null;
-    }
-    bitstream.skipBits(1); // Private bit
-    const channelConfiguration = bitstream.readBits(3);
-    if (channelConfiguration === 0) {
-        throw new Error('ADTS frames with channel configuration 0 are not supported.');
-    }
-    bitstream.skipBits(1); // Originality
-    bitstream.skipBits(1); // Home
-    bitstream.skipBits(1); // Copyright ID bit
-    bitstream.skipBits(1); // Copyright ID start
-    const frameLength = bitstream.readBits(13);
-    bitstream.skipBits(11); // Buffer fullness
-    const numberOfAacFrames = bitstream.readBits(2) + 1;
-    if (numberOfAacFrames !== 1) {
-        throw new Error('ADTS frames with more than one AAC frame are not supported.');
-    }
-    let crcCheck = null;
-    if (protectionAbsence === 1) { // No CRC
-        slice.filePos -= 2;
-    }
-    else { // CRC
-        crcCheck = bitstream.readBits(16);
-    }
-    return {
-        objectType,
-        samplingFrequencyIndex,
-        channelConfiguration,
-        frameLength,
-        numberOfAacFrames,
-        crcCheck,
-        startPos,
-    };
-};