@kenzuya/mediabunny 1.26.0 → 1.28.6

package/dist/modules/src/target.js

@@ -1,140 +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 { BufferTargetWriter, NullTargetWriter, StreamTargetWriter } from './writer.js';
-import * as nodeAlias from './node.js';
-import { assert } from './misc.js';
-const node = typeof nodeAlias !== 'undefined'
-    ? nodeAlias // Aliasing it prevents some bundler warnings
-    : undefined;
-/**
- * Base class for targets, specifying where output files are written.
- * @group Output targets
- * @public
- */
-export class Target {
-    constructor() {
-        /** @internal */
-        this._output = null;
-        /**
-         * Called each time data is written to the target. Will be called with the byte range into which data was written.
-         *
-         * Use this callback to track the size of the output file as it grows. But be warned, this function is chatty and
-         * gets called *extremely* often.
-         */
-        this.onwrite = null;
-    }
-}
-/**
- * A target that writes data directly into an ArrayBuffer in memory. Great for performance, but not suitable for very
- * large files. The buffer will be available once the output has been finalized.
- * @group Output targets
- * @public
- */
-export class BufferTarget extends Target {
-    constructor() {
-        super(...arguments);
-        /** Stores the final output buffer. Until the output is finalized, this will be `null`. */
-        this.buffer = null;
-    }
-    /** @internal */
-    _createWriter() {
-        return new BufferTargetWriter(this);
-    }
-}
-/**
- * This target writes data to a [`WritableStream`](https://developer.mozilla.org/en-US/docs/Web/API/WritableStream),
- * making it a general-purpose target for writing data anywhere. It is also compatible with
- * [`FileSystemWritableFileStream`](https://developer.mozilla.org/en-US/docs/Web/API/FileSystemWritableFileStream) for
- * use with the [File System Access API](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API). The
- * `WritableStream` can also apply backpressure, which will propagate to the output and throttle the encoders.
- * @group Output targets
- * @public
- */
-export class StreamTarget extends Target {
-    /** Creates a new {@link StreamTarget} which writes to the specified `writable`. */
-    constructor(writable, options = {}) {
-        super();
-        if (!(writable instanceof WritableStream)) {
-            throw new TypeError('StreamTarget requires a WritableStream instance.');
-        }
-        if (options != null && typeof options !== 'object') {
-            throw new TypeError('StreamTarget options, when provided, must be an object.');
-        }
-        if (options.chunked !== undefined && typeof options.chunked !== 'boolean') {
-            throw new TypeError('options.chunked, when provided, must be a boolean.');
-        }
-        if (options.chunkSize !== undefined && (!Number.isInteger(options.chunkSize) || options.chunkSize < 1024)) {
-            throw new TypeError('options.chunkSize, when provided, must be an integer and not smaller than 1024.');
-        }
-        this._writable = writable;
-        this._options = options;
-    }
-    /** @internal */
-    _createWriter() {
-        return new StreamTargetWriter(this);
-    }
-}
-/**
- * A target that writes to a file at the specified path. Intended for server-side usage in Node, Bun, or Deno.
- *
- * Writing is chunked by default. The internally held file handle will be closed when `.finalize()` or `.cancel()` are
- * called on the corresponding {@link Output}.
- * @group Output targets
- * @public
- */
-export class FilePathTarget extends Target {
-    /** Creates a new {@link FilePathTarget} that writes to the file at the specified file path. */
-    constructor(filePath, options = {}) {
-        if (typeof filePath !== 'string') {
-            throw new TypeError('filePath must be a string.');
-        }
-        if (!options || typeof options !== 'object') {
-            throw new TypeError('options must be an object.');
-        }
-        super();
-        /** @internal */
-        this._fileHandle = null;
-        // Let's back this target with a StreamTarget, makes the implementation very simple
-        const writable = new WritableStream({
-            start: async () => {
-                this._fileHandle = await node.fs.open(filePath, 'w');
-            },
-            write: async (chunk) => {
-                assert(this._fileHandle);
-                await this._fileHandle.write(chunk.data, 0, chunk.data.byteLength, chunk.position);
-            },
-            close: async () => {
-                if (this._fileHandle) {
-                    await this._fileHandle.close();
-                    this._fileHandle = null;
-                }
-            },
-        });
-        this._streamTarget = new StreamTarget(writable, {
-            chunked: true,
-            ...options,
-        });
-        this._streamTarget._output = this._output;
-    }
-    /** @internal */
-    _createWriter() {
-        return this._streamTarget._createWriter();
-    }
-}
-/**
- * This target just discards all incoming data. It is useful for when you need an {@link Output} but extract data from
- * it differently, for example through format-specific callbacks (`onMoof`, `onMdat`, ...) or encoder events.
- * @group Output targets
- * @public
- */
-export class NullTarget extends Target {
-    /** @internal */
-    _createWriter() {
-        return new NullTargetWriter(this);
-    }
-}

package/dist/modules/src/wave/riff-writer.js

@@ -1,30 +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 class RiffWriter {
-    constructor(writer) {
-        this.writer = writer;
-        this.helper = new Uint8Array(8);
-        this.helperView = new DataView(this.helper.buffer);
-    }
-    writeU16(value) {
-        this.helperView.setUint16(0, value, true);
-        this.writer.write(this.helper.subarray(0, 2));
-    }
-    writeU32(value) {
-        this.helperView.setUint32(0, value, true);
-        this.writer.write(this.helper.subarray(0, 4));
-    }
-    writeU64(value) {
-        this.helperView.setUint32(0, value, true);
-        this.helperView.setUint32(4, Math.floor(value / 2 ** 32), true);
-        this.writer.write(this.helper);
-    }
-    writeAscii(text) {
-        this.writer.write(new TextEncoder().encode(text));
-    }
-}

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

@@ -1,447 +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, UNDETERMINED_LANGUAGE } from '../misc.js';
-import { EncodedPacket, PLACEHOLDER_DATA } from '../packet.js';
-import { readAscii, readBytes, readU16, readU32, readU64 } from '../reader.js';
-import { parseId3V2Tag, readId3V2Header } from '../id3.js';
-export var WaveFormat;
-(function (WaveFormat) {
-    WaveFormat[WaveFormat["PCM"] = 1] = "PCM";
-    WaveFormat[WaveFormat["IEEE_FLOAT"] = 3] = "IEEE_FLOAT";
-    WaveFormat[WaveFormat["ALAW"] = 6] = "ALAW";
-    WaveFormat[WaveFormat["MULAW"] = 7] = "MULAW";
-    WaveFormat[WaveFormat["EXTENSIBLE"] = 65534] = "EXTENSIBLE";
-})(WaveFormat || (WaveFormat = {}));
-export class WaveDemuxer extends Demuxer {
-    constructor(input) {
-        super(input);
-        this.metadataPromise = null;
-        this.dataStart = -1;
-        this.dataSize = -1;
-        this.audioInfo = null;
-        this.tracks = [];
-        this.lastKnownPacketIndex = 0;
-        this.metadataTags = {};
-        this.reader = input._reader;
-    }
-    async readMetadata() {
-        return this.metadataPromise ??= (async () => {
-            let slice = this.reader.requestSlice(0, 12);
-            if (slice instanceof Promise)
-                slice = await slice;
-            assert(slice);
-            const riffType = readAscii(slice, 4);
-            const littleEndian = riffType !== 'RIFX';
-            const isRf64 = riffType === 'RF64';
-            const outerChunkSize = readU32(slice, littleEndian);
-            let totalFileSize = isRf64
-                ? this.reader.fileSize
-                : Math.min(outerChunkSize + 8, this.reader.fileSize ?? Infinity);
-            const format = readAscii(slice, 4);
-            if (format !== 'WAVE') {
-                throw new Error('Invalid WAVE file - wrong format');
-            }
-            let chunksRead = 0;
-            let dataChunkSize = null;
-            let currentPos = slice.filePos;
-            while (totalFileSize === null || currentPos < totalFileSize) {
-                let slice = this.reader.requestSlice(currentPos, 8);
-                if (slice instanceof Promise)
-                    slice = await slice;
-                if (!slice)
-                    break;
-                const chunkId = readAscii(slice, 4);
-                const chunkSize = readU32(slice, littleEndian);
-                const startPos = slice.filePos;
-                if (isRf64 && chunksRead === 0 && chunkId !== 'ds64') {
-                    throw new Error('Invalid RF64 file: First chunk must be "ds64".');
-                }
-                if (chunkId === 'fmt ') {
-                    await this.parseFmtChunk(startPos, chunkSize, littleEndian);
-                }
-                else if (chunkId === 'data') {
-                    dataChunkSize ??= chunkSize;
-                    this.dataStart = slice.filePos;
-                    this.dataSize = Math.min(dataChunkSize, (totalFileSize ?? Infinity) - this.dataStart);
-                    if (this.reader.fileSize === null) {
-                        break; // Stop once we hit the data chunk
-                    }
-                }
-                else if (chunkId === 'ds64') {
-                    // File and data chunk sizes are defined in here instead
-                    let ds64Slice = this.reader.requestSlice(startPos, chunkSize);
-                    if (ds64Slice instanceof Promise)
-                        ds64Slice = await ds64Slice;
-                    if (!ds64Slice)
-                        break;
-                    const riffChunkSize = readU64(ds64Slice, littleEndian);
-                    dataChunkSize = readU64(ds64Slice, littleEndian);
-                    totalFileSize = Math.min(riffChunkSize + 8, this.reader.fileSize ?? Infinity);
-                }
-                else if (chunkId === 'LIST') {
-                    await this.parseListChunk(startPos, chunkSize, littleEndian);
-                }
-                else if (chunkId === 'ID3 ' || chunkId === 'id3 ') {
-                    await this.parseId3Chunk(startPos, chunkSize);
-                }
-                currentPos = startPos + chunkSize + (chunkSize & 1); // Handle padding
-                chunksRead++;
-            }
-            if (!this.audioInfo) {
-                throw new Error('Invalid WAVE file - missing "fmt " chunk');
-            }
-            if (this.dataStart === -1) {
-                throw new Error('Invalid WAVE file - missing "data" chunk');
-            }
-            const blockSize = this.audioInfo.blockSizeInBytes;
-            this.dataSize = Math.floor(this.dataSize / blockSize) * blockSize;
-            this.tracks.push(new InputAudioTrack(this.input, new WaveAudioTrackBacking(this)));
-        })();
-    }
-    async parseFmtChunk(startPos, size, littleEndian) {
-        let slice = this.reader.requestSlice(startPos, size);
-        if (slice instanceof Promise)
-            slice = await slice;
-        if (!slice)
-            return; // File too short
-        let formatTag = readU16(slice, littleEndian);
-        const numChannels = readU16(slice, littleEndian);
-        const sampleRate = readU32(slice, littleEndian);
-        slice.skip(4); // Bytes per second
-        const blockAlign = readU16(slice, littleEndian);
-        let bitsPerSample;
-        if (size === 14) { // Plain WAVEFORMAT
-            bitsPerSample = 8;
-        }
-        else {
-            bitsPerSample = readU16(slice, littleEndian);
-        }
-        // Handle WAVEFORMATEXTENSIBLE
-        if (size >= 18 && formatTag !== 0x0165) {
-            const cbSize = readU16(slice, littleEndian);
-            const remainingSize = size - 18;
-            const extensionSize = Math.min(remainingSize, cbSize);
-            if (extensionSize >= 22 && formatTag === WaveFormat.EXTENSIBLE) {
-                // Parse WAVEFORMATEXTENSIBLE
-                slice.skip(2 + 4);
-                const subFormat = readBytes(slice, 16);
-                // Get actual format from subFormat GUID
-                formatTag = subFormat[0] | (subFormat[1] << 8);
-            }
-        }
-        if (formatTag === WaveFormat.MULAW || formatTag === WaveFormat.ALAW) {
-            bitsPerSample = 8;
-        }
-        this.audioInfo = {
-            format: formatTag,
-            numberOfChannels: numChannels,
-            sampleRate,
-            sampleSizeInBytes: Math.ceil(bitsPerSample / 8),
-            blockSizeInBytes: blockAlign,
-        };
-    }
-    async parseListChunk(startPos, size, littleEndian) {
-        let slice = this.reader.requestSlice(startPos, size);
-        if (slice instanceof Promise)
-            slice = await slice;
-        if (!slice)
-            return; // File too short
-        const infoType = readAscii(slice, 4);
-        if (infoType !== 'INFO' && infoType !== 'INF0') { // exiftool.org claims INF0 can happen
-            return; // Not an INFO chunk
-        }
-        let currentPos = slice.filePos;
-        while (currentPos <= startPos + size - 8) {
-            slice.filePos = currentPos;
-            const chunkName = readAscii(slice, 4);
-            const chunkSize = readU32(slice, littleEndian);
-            const bytes = readBytes(slice, chunkSize);
-            let stringLength = 0;
-            for (let i = 0; i < bytes.length; i++) {
-                if (bytes[i] === 0) {
-                    break;
-                }
-                stringLength++;
-            }
-            const value = String.fromCharCode(...bytes.subarray(0, stringLength));
-            this.metadataTags.raw ??= {};
-            this.metadataTags.raw[chunkName] = value;
-            switch (chunkName) {
-                case 'INAM':
-                case 'TITL':
-                    {
-                        this.metadataTags.title ??= value;
-                    }
-                    ;
-                    break;
-                case 'TIT3':
-                    {
-                        this.metadataTags.description ??= value;
-                    }
-                    ;
-                    break;
-                case 'IART':
-                    {
-                        this.metadataTags.artist ??= value;
-                    }
-                    ;
-                    break;
-                case 'IPRD':
-                    {
-                        this.metadataTags.album ??= value;
-                    }
-                    ;
-                    break;
-                case 'IPRT':
-                case 'ITRK':
-                case 'TRCK':
-                    {
-                        const parts = value.split('/');
-                        const trackNum = Number.parseInt(parts[0], 10);
-                        const tracksTotal = parts[1] && Number.parseInt(parts[1], 10);
-                        if (Number.isInteger(trackNum) && trackNum > 0) {
-                            this.metadataTags.trackNumber ??= trackNum;
-                        }
-                        if (tracksTotal && Number.isInteger(tracksTotal) && tracksTotal > 0) {
-                            this.metadataTags.tracksTotal ??= tracksTotal;
-                        }
-                    }
-                    ;
-                    break;
-                case 'ICRD':
-                case 'IDIT':
-                    {
-                        const date = new Date(value);
-                        if (!Number.isNaN(date.getTime())) {
-                            this.metadataTags.date ??= date;
-                        }
-                    }
-                    ;
-                    break;
-                case 'YEAR':
-                    {
-                        const year = Number.parseInt(value, 10);
-                        if (Number.isInteger(year) && year > 0) {
-                            this.metadataTags.date ??= new Date(year, 0, 1);
-                        }
-                    }
-                    ;
-                    break;
-                case 'IGNR':
-                case 'GENR':
-                    {
-                        this.metadataTags.genre ??= value;
-                    }
-                    ;
-                    break;
-                case 'ICMT':
-                case 'CMNT':
-                case 'COMM':
-                    {
-                        this.metadataTags.comment ??= value;
-                    }
-                    ;
-                    break;
-            }
-            currentPos += 8 + chunkSize + (chunkSize & 1); // Handle padding
-        }
-    }
-    async parseId3Chunk(startPos, size) {
-        // Parse ID3 tag embedded in WAV file (non-default, but used a lot in practice anyway)
-        let slice = this.reader.requestSlice(startPos, size);
-        if (slice instanceof Promise)
-            slice = await slice;
-        if (!slice)
-            return; // File too short
-        const id3V2Header = readId3V2Header(slice);
-        if (id3V2Header) {
-            // Extract the content portion (skip the 10-byte header)
-            const contentSlice = slice.slice(startPos + 10, id3V2Header.size);
-            parseId3V2Tag(contentSlice, id3V2Header, this.metadataTags);
-        }
-    }
-    getCodec() {
-        assert(this.audioInfo);
-        if (this.audioInfo.format === WaveFormat.MULAW) {
-            return 'ulaw';
-        }
-        if (this.audioInfo.format === WaveFormat.ALAW) {
-            return 'alaw';
-        }
-        if (this.audioInfo.format === WaveFormat.PCM) {
-            // All formats are little-endian
-            if (this.audioInfo.sampleSizeInBytes === 1) {
-                return 'pcm-u8';
-            }
-            else if (this.audioInfo.sampleSizeInBytes === 2) {
-                return 'pcm-s16';
-            }
-            else if (this.audioInfo.sampleSizeInBytes === 3) {
-                return 'pcm-s24';
-            }
-            else if (this.audioInfo.sampleSizeInBytes === 4) {
-                return 'pcm-s32';
-            }
-        }
-        if (this.audioInfo.format === WaveFormat.IEEE_FLOAT) {
-            if (this.audioInfo.sampleSizeInBytes === 4) {
-                return 'pcm-f32';
-            }
-        }
-        return null;
-    }
-    async getMimeType() {
-        return 'audio/wav';
-    }
-    async computeDuration() {
-        await this.readMetadata();
-        const track = this.tracks[0];
-        assert(track);
-        return track.computeDuration();
-    }
-    async getTracks() {
-        await this.readMetadata();
-        return this.tracks;
-    }
-    async getMetadataTags() {
-        await this.readMetadata();
-        return this.metadataTags;
-    }
-}
-const PACKET_SIZE_IN_FRAMES = 2048;
-class WaveAudioTrackBacking {
-    constructor(demuxer) {
-        this.demuxer = demuxer;
-    }
-    getId() {
-        return 1;
-    }
-    getCodec() {
-        return this.demuxer.getCodec();
-    }
-    getInternalCodecId() {
-        assert(this.demuxer.audioInfo);
-        return this.demuxer.audioInfo.format;
-    }
-    async getDecoderConfig() {
-        const codec = this.demuxer.getCodec();
-        if (!codec) {
-            return null;
-        }
-        assert(this.demuxer.audioInfo);
-        return {
-            codec,
-            numberOfChannels: this.demuxer.audioInfo.numberOfChannels,
-            sampleRate: this.demuxer.audioInfo.sampleRate,
-        };
-    }
-    async computeDuration() {
-        const lastPacket = await this.getPacket(Infinity, { metadataOnly: true });
-        return (lastPacket?.timestamp ?? 0) + (lastPacket?.duration ?? 0);
-    }
-    getNumberOfChannels() {
-        assert(this.demuxer.audioInfo);
-        return this.demuxer.audioInfo.numberOfChannels;
-    }
-    getSampleRate() {
-        assert(this.demuxer.audioInfo);
-        return this.demuxer.audioInfo.sampleRate;
-    }
-    getTimeResolution() {
-        assert(this.demuxer.audioInfo);
-        return this.demuxer.audioInfo.sampleRate;
-    }
-    getName() {
-        return null;
-    }
-    getLanguageCode() {
-        return UNDETERMINED_LANGUAGE;
-    }
-    getDisposition() {
-        return {
-            ...DEFAULT_TRACK_DISPOSITION,
-        };
-    }
-    async getFirstTimestamp() {
-        return 0;
-    }
-    async getPacketAtIndex(packetIndex, options) {
-        assert(this.demuxer.audioInfo);
-        const startOffset = packetIndex * PACKET_SIZE_IN_FRAMES * this.demuxer.audioInfo.blockSizeInBytes;
-        if (startOffset >= this.demuxer.dataSize) {
-            return null;
-        }
-        const sizeInBytes = Math.min(PACKET_SIZE_IN_FRAMES * this.demuxer.audioInfo.blockSizeInBytes, this.demuxer.dataSize - startOffset);
-        if (this.demuxer.reader.fileSize === null) {
-            // If the file size is unknown, we weren't able to cap the dataSize in the init logic and we instead have to
-            // rely on the headers telling us how large the file is. But, these might be wrong, so let's check if the
-            // requested slice actually exists.
-            let slice = this.demuxer.reader.requestSlice(this.demuxer.dataStart + startOffset, sizeInBytes);
-            if (slice instanceof Promise)
-                slice = await slice;
-            if (!slice) {
-                return null;
-            }
-        }
-        let data;
-        if (options.metadataOnly) {
-            data = PLACEHOLDER_DATA;
-        }
-        else {
-            let slice = this.demuxer.reader.requestSlice(this.demuxer.dataStart + startOffset, sizeInBytes);
-            if (slice instanceof Promise)
-                slice = await slice;
-            assert(slice);
-            data = readBytes(slice, sizeInBytes);
-        }
-        const timestamp = packetIndex * PACKET_SIZE_IN_FRAMES / this.demuxer.audioInfo.sampleRate;
-        const duration = sizeInBytes / this.demuxer.audioInfo.blockSizeInBytes / this.demuxer.audioInfo.sampleRate;
-        this.demuxer.lastKnownPacketIndex = Math.max(packetIndex, timestamp);
-        return new EncodedPacket(data, 'key', timestamp, duration, packetIndex, sizeInBytes);
-    }
-    getFirstPacket(options) {
-        return this.getPacketAtIndex(0, options);
-    }
-    async getPacket(timestamp, options) {
-        assert(this.demuxer.audioInfo);
-        const packetIndex = Math.floor(Math.min(timestamp * this.demuxer.audioInfo.sampleRate / PACKET_SIZE_IN_FRAMES, (this.demuxer.dataSize - 1) / (PACKET_SIZE_IN_FRAMES * this.demuxer.audioInfo.blockSizeInBytes)));
-        const packet = await this.getPacketAtIndex(packetIndex, options);
-        if (packet) {
-            return packet;
-        }
-        if (packetIndex === 0) {
-            return null; // Empty data chunk
-        }
-        assert(this.demuxer.reader.fileSize === null);
-        // The file is shorter than we thought, meaning the packet we were looking for doesn't exist. So, let's find
-        // the last packet by doing a sequential scan, instead.
-        let currentPacket = await this.getPacketAtIndex(this.demuxer.lastKnownPacketIndex, options);
-        while (currentPacket) {
-            const nextPacket = await this.getNextPacket(currentPacket, options);
-            if (!nextPacket) {
-                break;
-            }
-            currentPacket = nextPacket;
-        }
-        return currentPacket;
-    }
-    getNextPacket(packet, options) {
-        assert(this.demuxer.audioInfo);
-        const packetIndex = Math.round(packet.timestamp * this.demuxer.audioInfo.sampleRate / PACKET_SIZE_IN_FRAMES);
-        return this.getPacketAtIndex(packetIndex + 1, options);
-    }
-    getKeyPacket(timestamp, options) {
-        return this.getPacket(timestamp, options);
-    }
-    getNextKeyPacket(packet, options) {
-        return this.getNextPacket(packet, options);
-    }
-}