mediabunny 1.0.2 → 1.0.4

package/dist/modules/ogg/ogg-misc.d.ts

@@ -0,0 +1,27 @@
+/*!
+ * 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 declare const OGGS = 1399285583;
+export declare const computeOggPageCrc: (bytes: Uint8Array) => number;
+export type OggCodecInfo = {
+    codec: 'vorbis' | 'opus' | null;
+    vorbisInfo: {
+        blocksizes: number[];
+        modeBlockflags: number[];
+    } | null;
+    opusInfo: {
+        preSkip: number;
+    } | null;
+};
+export declare const extractSampleMetadata: (data: Uint8Array, codecInfo: OggCodecInfo, vorbisLastBlocksize: number | null) => {
+    durationInSamples: number;
+    vorbisBlockSize: number | null;
+};
+export declare const buildOggMimeType: (info: {
+    codecStrings: string[];
+}) => string;
+//# sourceMappingURL=ogg-misc.d.ts.map

package/dist/modules/ogg/ogg-misc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ogg-misc.d.ts","sourceRoot":"","sources":["../../../src/ogg/ogg-misc.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,eAAO,MAAM,IAAI,aAAa,CAAC;AAgB/B,eAAO,MAAM,iBAAiB,GAAI,OAAO,UAAU,WAelD,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IAC1B,KAAK,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI,CAAC;IAChC,UAAU,EAAE;QACX,UAAU,EAAE,MAAM,EAAE,CAAC;QACrB,cAAc,EAAE,MAAM,EAAE,CAAC;KACzB,GAAG,IAAI,CAAC;IACT,QAAQ,EAAE;QACT,OAAO,EAAE,MAAM,CAAC;KAChB,GAAG,IAAI,CAAC;CACT,CAAC;AAEF,eAAO,MAAM,qBAAqB,GACjC,MAAM,UAAU,EAChB,WAAW,YAAY,EACvB,qBAAqB,MAAM,GAAG,IAAI;;;CA4ClC,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,MAAM;IACtC,YAAY,EAAE,MAAM,EAAE,CAAC;CACvB,WASA,CAAC"}

package/dist/modules/ogg/ogg-misc.js

@@ -0,0 +1,78 @@
+/*!
+ * 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 { parseOpusTocByte } from '../codec-data.js';
+import { assert, ilog, toDataView } from '../misc.js';
+export const OGGS = 0x5367674f; // 'OggS'
+const OGG_CRC_POLYNOMIAL = 0x04c11db7;
+const OGG_CRC_TABLE = new Uint32Array(256);
+for (let n = 0; n < 256; n++) {
+    let crc = n << 24;
+    for (let k = 0; k < 8; k++) {
+        crc = (crc & 0x80000000)
+            ? ((crc << 1) ^ OGG_CRC_POLYNOMIAL)
+            : (crc << 1);
+    }
+    OGG_CRC_TABLE[n] = (crc >>> 0) & 0xffffffff;
+}
+export const computeOggPageCrc = (bytes) => {
+    const view = toDataView(bytes);
+    const originalChecksum = view.getUint32(22, true);
+    view.setUint32(22, 0, true); // Zero out checksum field
+    let crc = 0;
+    for (let i = 0; i < bytes.length; i++) {
+        const byte = bytes[i];
+        crc = ((crc << 8) ^ OGG_CRC_TABLE[(crc >>> 24) ^ byte]) >>> 0;
+    }
+    view.setUint32(22, originalChecksum, true); // Restore checksum field
+    return crc;
+};
+export const extractSampleMetadata = (data, codecInfo, vorbisLastBlocksize) => {
+    let durationInSamples = 0;
+    let currentBlocksize = null;
+    if (data.length > 0) {
+        // To know sample duration, we'll need to peak inside the packet
+        if (codecInfo.codec === 'vorbis') {
+            assert(codecInfo.vorbisInfo);
+            const vorbisModeCount = codecInfo.vorbisInfo.modeBlockflags.length;
+            const bitCount = ilog(vorbisModeCount - 1);
+            const modeMask = ((1 << bitCount) - 1) << 1;
+            const modeNumber = (data[0] & modeMask) >> 1;
+            if (modeNumber >= codecInfo.vorbisInfo.modeBlockflags.length) {
+                throw new Error('Invalid mode number.');
+            }
+            // In Vorbis, packet duration also depends on the blocksize of the previous packet
+            let prevBlocksize = vorbisLastBlocksize;
+            const blockflag = codecInfo.vorbisInfo.modeBlockflags[modeNumber];
+            currentBlocksize = codecInfo.vorbisInfo.blocksizes[blockflag];
+            if (blockflag === 1) {
+                const prevMask = (modeMask | 0x1) + 1;
+                const flag = data[0] & prevMask ? 1 : 0;
+                prevBlocksize = codecInfo.vorbisInfo.blocksizes[flag];
+            }
+            durationInSamples = prevBlocksize !== null
+                ? (prevBlocksize + currentBlocksize) >> 2
+                : 0; // The first sample outputs no audio data and therefore has a duration of 0
+        }
+        else if (codecInfo.codec === 'opus') {
+            const toc = parseOpusTocByte(data);
+            durationInSamples = toc.durationInSamples;
+        }
+    }
+    return {
+        durationInSamples,
+        vorbisBlockSize: currentBlocksize,
+    };
+};
+export const buildOggMimeType = (info) => {
+    let string = 'audio/ogg';
+    if (info.codecStrings) {
+        const uniqueCodecMimeTypes = [...new Set(info.codecStrings)];
+        string += `; codecs="${uniqueCodecMimeTypes.join(', ')}"`;
+    }
+    return string;
+};

package/dist/modules/ogg/ogg-muxer.d.ts

@@ -0,0 +1,58 @@
+/*!
+ * 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 { Muxer } from '../muxer';
+import { Output, OutputAudioTrack } from '../output';
+import { OggOutputFormat } from '../output-format';
+import { EncodedPacket } from '../packet';
+import { OggCodecInfo } from './ogg-misc';
+type OggTrackData = {
+    track: OutputAudioTrack;
+    serialNumber: number;
+    internalSampleRate: number;
+    codecInfo: OggCodecInfo;
+    vorbisLastBlocksize: number | null;
+    packetQueue: Packet[];
+    currentTimestampInSamples: number;
+    pagesWritten: number;
+    currentGranulePosition: number;
+    currentLacingValues: number[];
+    currentPageData: Uint8Array[];
+    currentPageSize: number;
+    currentPageStartsWithFreshPacket: boolean;
+};
+type Packet = {
+    data: Uint8Array;
+    endGranulePosition: number;
+    timestamp: number;
+    forcePageFlush: boolean;
+};
+export declare class OggMuxer extends Muxer {
+    private format;
+    private writer;
+    private trackDatas;
+    private bosPagesWritten;
+    private allTracksKnown;
+    private pageBytes;
+    private pageView;
+    constructor(output: Output, format: OggOutputFormat);
+    start(): Promise<void>;
+    getMimeType(): Promise<string>;
+    addEncodedVideoPacket(): never;
+    private getTrackData;
+    private queueHeaderPackets;
+    addEncodedAudioPacket(track: OutputAudioTrack, packet: EncodedPacket, meta?: EncodedAudioChunkMetadata): Promise<void>;
+    addSubtitleCue(): never;
+    allTracksAreKnown(): boolean;
+    interleavePages(isFinalCall?: boolean): Promise<void>;
+    writePacket(trackData: OggTrackData, packet: Packet, isFinalPacket: boolean): void;
+    writePage(trackData: OggTrackData, isEos: boolean): void;
+    onTrackClose(): Promise<void>;
+    finalize(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=ogg-muxer.d.ts.map

package/dist/modules/ogg/ogg-muxer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ogg-muxer.d.ts","sourceRoot":"","sources":["../../../src/ogg/ogg-muxer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE1C,OAAO,EAIN,YAAY,EAEZ,MAAM,YAAY,CAAC;AAKpB,KAAK,YAAY,GAAG;IACnB,KAAK,EAAE,gBAAgB,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,YAAY,CAAC;IACxB,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,yBAAyB,EAAE,MAAM,CAAC;IAClC,YAAY,EAAE,MAAM,CAAC;IAErB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,eAAe,EAAE,UAAU,EAAE,CAAC;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,gCAAgC,EAAE,OAAO,CAAC;CAC1C,CAAC;AAEF,KAAK,MAAM,GAAG;IACb,IAAI,EAAE,UAAU,CAAC;IACjB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,qBAAa,QAAS,SAAQ,KAAK;IAClC,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,cAAc,CAA0B;IAEhD,OAAO,CAAC,SAAS,CAAiC;IAClD,OAAO,CAAC,QAAQ,CAAuC;gBAE3C,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe;IAS7C,KAAK;IAIL,WAAW;IAQjB,qBAAqB,IAAI,KAAK;IAI9B,OAAO,CAAC,YAAY;IAqDpB,OAAO,CAAC,kBAAkB;IAoGpB,qBAAqB,CAAC,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,yBAAyB;IA+B5G,cAAc,IAAI,KAAK;IAIvB,iBAAiB;IAUX,eAAe,CAAC,WAAW,UAAQ;IA4DzC,WAAW,CAAC,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO;IAgD3E,SAAS,CAAC,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO;IA0DlC,YAAY;IAarB,QAAQ;CAed"}

package/dist/modules/ogg/ogg-muxer.js

@@ -0,0 +1,345 @@
+/*!
+ * 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 { OPUS_INTERNAL_SAMPLE_RATE, validateAudioChunkMetadata } from '../codec.js';
+import { parseModesFromVorbisSetupPacket, parseOpusIdentificationHeader } from '../codec-data.js';
+import { assert, promiseWithResolvers, setInt64, toDataView, toUint8Array } from '../misc.js';
+import { Muxer } from '../muxer.js';
+import { buildOggMimeType, computeOggPageCrc, extractSampleMetadata, OGGS, } from './ogg-misc.js';
+import { MAX_PAGE_SIZE } from './ogg-reader.js';
+const PAGE_SIZE_TARGET = 8192;
+export class OggMuxer extends Muxer {
+    constructor(output, format) {
+        super(output);
+        this.trackDatas = [];
+        this.bosPagesWritten = false;
+        this.allTracksKnown = promiseWithResolvers();
+        this.pageBytes = new Uint8Array(MAX_PAGE_SIZE);
+        this.pageView = new DataView(this.pageBytes.buffer);
+        this.format = format;
+        this.writer = output._writer;
+        this.writer.ensureMonotonicity = true; // Ogg is always monotonically written!
+    }
+    async start() {
+        // Nothin'
+    }
+    async getMimeType() {
+        await this.allTracksKnown.promise;
+        return buildOggMimeType({
+            codecStrings: this.trackDatas.map(x => x.codecInfo.codec),
+        });
+    }
+    addEncodedVideoPacket() {
+        throw new Error('Video tracks are not supported.');
+    }
+    getTrackData(track, meta) {
+        const existingTrackData = this.trackDatas.find(td => td.track === track);
+        if (existingTrackData) {
+            return existingTrackData;
+        }
+        // Give the track a unique random serial number
+        let serialNumber;
+        do {
+            serialNumber = Math.floor(2 ** 32 * Math.random());
+        } while (this.trackDatas.some(td => td.serialNumber === serialNumber));
+        assert(track.source._codec === 'vorbis' || track.source._codec === 'opus');
+        validateAudioChunkMetadata(meta);
+        assert(meta);
+        assert(meta.decoderConfig);
+        const newTrackData = {
+            track,
+            serialNumber,
+            internalSampleRate: track.source._codec === 'opus'
+                ? OPUS_INTERNAL_SAMPLE_RATE
+                : meta.decoderConfig.sampleRate,
+            codecInfo: {
+                codec: track.source._codec,
+                vorbisInfo: null,
+                opusInfo: null,
+            },
+            vorbisLastBlocksize: null,
+            packetQueue: [],
+            currentTimestampInSamples: 0,
+            pagesWritten: 0,
+            currentGranulePosition: 0,
+            currentLacingValues: [],
+            currentPageData: [],
+            currentPageSize: 27,
+            currentPageStartsWithFreshPacket: true,
+        };
+        this.queueHeaderPackets(newTrackData, meta);
+        this.trackDatas.push(newTrackData);
+        if (this.allTracksAreKnown()) {
+            this.allTracksKnown.resolve();
+        }
+        return newTrackData;
+    }
+    queueHeaderPackets(trackData, meta) {
+        assert(meta.decoderConfig);
+        if (trackData.track.source._codec === 'vorbis') {
+            assert(meta.decoderConfig.description);
+            const bytes = toUint8Array(meta.decoderConfig.description);
+            if (bytes[0] !== 2) {
+                throw new TypeError('First byte of Vorbis decoder description must be 2.');
+            }
+            let pos = 1;
+            const readPacketLength = () => {
+                let length = 0;
+                while (true) {
+                    const value = bytes[pos++];
+                    if (value === undefined) {
+                        throw new TypeError('Vorbis decoder description is too short.');
+                    }
+                    length += value;
+                    if (value < 255) {
+                        return length;
+                    }
+                }
+            };
+            const identificationHeaderLength = readPacketLength();
+            const commentHeaderLength = readPacketLength();
+            const setupHeaderLength = bytes.length - pos; // Setup header fills the remaining bytes
+            if (setupHeaderLength <= 0) {
+                throw new TypeError('Vorbis decoder description is too short.');
+            }
+            const identificationHeader = bytes.subarray(pos, pos += identificationHeaderLength);
+            const commentHeader = bytes.subarray(pos, pos += commentHeaderLength);
+            const setupHeader = bytes.subarray(pos);
+            trackData.packetQueue.push({
+                data: identificationHeader,
+                endGranulePosition: 0,
+                timestamp: 0,
+                forcePageFlush: true,
+            }, {
+                data: commentHeader,
+                endGranulePosition: 0,
+                timestamp: 0,
+                forcePageFlush: false,
+            }, {
+                data: setupHeader,
+                endGranulePosition: 0,
+                timestamp: 0,
+                forcePageFlush: true, // The last header packet must flush the page
+            });
+            const view = toDataView(identificationHeader);
+            const blockSizeByte = view.getUint8(28);
+            trackData.codecInfo.vorbisInfo = {
+                blocksizes: [
+                    1 << (blockSizeByte & 0xf),
+                    1 << (blockSizeByte >> 4),
+                ],
+                modeBlockflags: parseModesFromVorbisSetupPacket(setupHeader).modeBlockflags,
+            };
+        }
+        else if (trackData.track.source._codec === 'opus') {
+            if (!meta.decoderConfig.description) {
+                throw new TypeError('For Ogg, Opus decoder description is required.');
+            }
+            const identificationHeader = toUint8Array(meta.decoderConfig.description);
+            const commentHeader = new Uint8Array(8 + 4 + 4);
+            const view = new DataView(commentHeader.buffer);
+            view.setUint32(0, 0x4f707573, false); // 'Opus'
+            view.setUint32(4, 0x54616773, false); // 'Tags'
+            view.setUint32(8, 0, true); // Vendor String Length
+            view.setUint32(12, 0, true); // User Comment List Length
+            trackData.packetQueue.push({
+                data: identificationHeader,
+                endGranulePosition: 0,
+                timestamp: 0,
+                forcePageFlush: true,
+            }, {
+                data: commentHeader,
+                endGranulePosition: 0,
+                timestamp: 0,
+                forcePageFlush: true, // The last header packet must flush the page
+            });
+            trackData.codecInfo.opusInfo = {
+                preSkip: parseOpusIdentificationHeader(identificationHeader).preSkip,
+            };
+        }
+    }
+    async addEncodedAudioPacket(track, packet, meta) {
+        const release = await this.mutex.acquire();
+        try {
+            const trackData = this.getTrackData(track, meta);
+            this.validateAndNormalizeTimestamp(trackData.track, packet.timestamp, packet.type === 'key');
+            const currentTimestampInSamples = trackData.currentTimestampInSamples;
+            const { durationInSamples, vorbisBlockSize } = extractSampleMetadata(packet.data, trackData.codecInfo, trackData.vorbisLastBlocksize);
+            trackData.currentTimestampInSamples += durationInSamples;
+            trackData.vorbisLastBlocksize = vorbisBlockSize;
+            trackData.packetQueue.push({
+                data: packet.data,
+                endGranulePosition: trackData.currentTimestampInSamples,
+                timestamp: currentTimestampInSamples / trackData.internalSampleRate,
+                forcePageFlush: false,
+            });
+            await this.interleavePages();
+        }
+        finally {
+            release();
+        }
+    }
+    addSubtitleCue() {
+        throw new Error('Subtitle tracks are not supported.');
+    }
+    allTracksAreKnown() {
+        for (const track of this.output._tracks) {
+            if (!track.source._closed && !this.trackDatas.some(x => x.track === track)) {
+                return false; // We haven't seen a sample from this open track yet
+            }
+        }
+        return true;
+    }
+    async interleavePages(isFinalCall = false) {
+        if (!this.bosPagesWritten) {
+            if (!this.allTracksAreKnown()) {
+                return; // We can't interleave yet as we don't yet know how many tracks we'll truly have
+            }
+            // Write the header page for all bitstreams
+            for (const trackData of this.trackDatas) {
+                while (trackData.packetQueue.length > 0) {
+                    const packet = trackData.packetQueue.shift();
+                    this.writePacket(trackData, packet, false);
+                    if (packet.forcePageFlush) {
+                        // We say the header page ends once the first packet is encountered that forces a page flush
+                        break;
+                    }
+                }
+            }
+            this.bosPagesWritten = true;
+        }
+        outer: while (true) {
+            let trackWithMinTimestamp = null;
+            let minTimestamp = Infinity;
+            for (const trackData of this.trackDatas) {
+                if (!isFinalCall
+                    && trackData.packetQueue.length <= 1 // Limit is 1, not 0, for correct EOS flag logic
+                    && !trackData.track.source._closed) {
+                    break outer;
+                }
+                if (trackData.packetQueue.length > 0
+                    && trackData.packetQueue[0].timestamp < minTimestamp) {
+                    trackWithMinTimestamp = trackData;
+                    minTimestamp = trackData.packetQueue[0].timestamp;
+                }
+            }
+            if (!trackWithMinTimestamp) {
+                break;
+            }
+            const packet = trackWithMinTimestamp.packetQueue.shift();
+            const isFinalPacket = trackWithMinTimestamp.packetQueue.length === 0;
+            this.writePacket(trackWithMinTimestamp, packet, isFinalPacket);
+        }
+        if (!isFinalCall) {
+            await this.writer.flush();
+        }
+    }
+    writePacket(trackData, packet, isFinalPacket) {
+        let remainingLength = packet.data.length;
+        let dataStartOffset = 0;
+        let dataOffset = 0;
+        while (true) {
+            if (trackData.currentLacingValues.length === 0 && dataStartOffset > 0) {
+                // This is a packet spanning multiple pages
+                trackData.currentPageStartsWithFreshPacket = false;
+            }
+            const segmentSize = Math.min(255, remainingLength);
+            trackData.currentLacingValues.push(segmentSize);
+            trackData.currentPageSize++;
+            dataOffset += segmentSize;
+            const segmentIsLastOfPacket = remainingLength < 255;
+            if (trackData.currentLacingValues.length === 255) {
+                // The page is full, we need to add part of the packet data and then flush the page
+                const slice = packet.data.subarray(dataStartOffset, dataOffset);
+                dataStartOffset = dataOffset;
+                trackData.currentPageData.push(slice);
+                trackData.currentPageSize += slice.length;
+                this.writePage(trackData, isFinalPacket && segmentIsLastOfPacket);
+                if (segmentIsLastOfPacket) {
+                    return;
+                }
+            }
+            if (segmentIsLastOfPacket) {
+                break;
+            }
+            remainingLength -= 255;
+        }
+        const slice = packet.data.subarray(dataStartOffset);
+        trackData.currentPageData.push(slice);
+        trackData.currentPageSize += slice.length;
+        trackData.currentGranulePosition = packet.endGranulePosition;
+        if (trackData.currentPageSize >= PAGE_SIZE_TARGET || packet.forcePageFlush) {
+            this.writePage(trackData, isFinalPacket);
+        }
+    }
+    writePage(trackData, isEos) {
+        this.pageView.setUint32(0, OGGS, true); // Capture pattern
+        this.pageView.setUint8(4, 0); // Version
+        let headerType = 0;
+        if (!trackData.currentPageStartsWithFreshPacket) {
+            headerType |= 1;
+        }
+        if (trackData.pagesWritten === 0) {
+            headerType |= 2; // Beginning of stream
+        }
+        if (isEos) {
+            headerType |= 4; // End of stream
+        }
+        this.pageView.setUint8(5, headerType); // Header type
+        const granulePosition = trackData.currentLacingValues.every(x => x === 255)
+            ? -1 // No packets end on this page
+            : trackData.currentGranulePosition;
+        setInt64(this.pageView, 6, granulePosition, true); // Granule position
+        this.pageView.setUint32(14, trackData.serialNumber, true); // Serial number
+        this.pageView.setUint32(18, trackData.pagesWritten, true); // Page sequence number
+        this.pageView.setUint32(22, 0, true); // Checksum placeholder
+        this.pageView.setUint8(26, trackData.currentLacingValues.length); // Number of page segments
+        this.pageBytes.set(trackData.currentLacingValues, 27);
+        let pos = 27 + trackData.currentLacingValues.length;
+        for (const data of trackData.currentPageData) {
+            this.pageBytes.set(data, pos);
+            pos += data.length;
+        }
+        const slice = this.pageBytes.subarray(0, pos);
+        const crc = computeOggPageCrc(slice);
+        this.pageView.setUint32(22, crc, true); // Checksum
+        trackData.pagesWritten++;
+        trackData.currentLacingValues.length = 0;
+        trackData.currentPageData.length = 0;
+        trackData.currentPageSize = 27;
+        trackData.currentPageStartsWithFreshPacket = true;
+        if (this.format._options.onPage) {
+            this.writer.startTrackingWrites();
+        }
+        this.writer.write(slice);
+        if (this.format._options.onPage) {
+            const { data, start } = this.writer.stopTrackingWrites();
+            this.format._options.onPage(data, start, trackData.track.source);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    async onTrackClose() {
+        const release = await this.mutex.acquire();
+        if (this.allTracksAreKnown()) {
+            this.allTracksKnown.resolve();
+        }
+        // Since a track is now closed, we may be able to write out chunks that were previously waiting
+        await this.interleavePages();
+        release();
+    }
+    async finalize() {
+        const release = await this.mutex.acquire();
+        this.allTracksKnown.resolve();
+        await this.interleavePages(true);
+        for (const trackData of this.trackDatas) {
+            if (trackData.currentLacingValues.length > 0) {
+                this.writePage(trackData, true);
+            }
+        }
+        release();
+    }
+}

package/dist/modules/ogg/ogg-reader.d.ts

@@ -0,0 +1,37 @@
+/*!
+ * 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 { Reader } from '../reader';
+export declare const MIN_PAGE_HEADER_SIZE = 27;
+export declare const MAX_PAGE_HEADER_SIZE: number;
+export declare const MAX_PAGE_SIZE: number;
+export type Page = {
+    headerStartPos: number;
+    totalSize: number;
+    dataStartPos: number;
+    dataSize: number;
+    headerType: number;
+    granulePosition: number;
+    serialNumber: number;
+    sequenceNumber: number;
+    checksum: number;
+    lacingValues: Uint8Array;
+};
+export declare class OggReader {
+    reader: Reader;
+    pos: number;
+    constructor(reader: Reader);
+    readBytes(length: number): Uint8Array<ArrayBufferLike>;
+    readU8(): number;
+    readU32(): number;
+    readI32(): number;
+    readI64(): number;
+    readAscii(length: number): string;
+    readPageHeader(): Page | null;
+    findNextPageHeader(until: number): boolean;
+}
+//# sourceMappingURL=ogg-reader.d.ts.map

package/dist/modules/ogg/ogg-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ogg-reader.d.ts","sourceRoot":"","sources":["../../../src/ogg/ogg-reader.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGnC,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,oBAAoB,QAAW,CAAC;AAC7C,eAAO,MAAM,aAAa,QAAmC,CAAC;AAE9D,MAAM,MAAM,IAAI,GAAG;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,UAAU,CAAC;CACzB,CAAC;AAEF,qBAAa,SAAS;IAEF,MAAM,EAAE,MAAM;IADjC,GAAG,SAAK;gBACW,MAAM,EAAE,MAAM;IAEjC,SAAS,CAAC,MAAM,EAAE,MAAM;IAOxB,MAAM;IAON,OAAO;IAOP,OAAO;IAOP,OAAO;IAMP,SAAS,CAAC,MAAM,EAAE,MAAM;IAWxB,cAAc,IAAI,IAAI,GAAG,IAAI;IAwC7B,kBAAkB,CAAC,KAAK,EAAE,MAAM;CAyBhC"}

package/dist/modules/ogg/ogg-reader.js

@@ -0,0 +1,104 @@
+/*!
+ * 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 { OGGS } from './ogg-misc.js';
+export const MIN_PAGE_HEADER_SIZE = 27;
+export const MAX_PAGE_HEADER_SIZE = 27 + 255;
+export const MAX_PAGE_SIZE = MAX_PAGE_HEADER_SIZE + 255 * 255;
+export class OggReader {
+    constructor(reader) {
+        this.reader = reader;
+        this.pos = 0;
+    }
+    readBytes(length) {
+        const { view, offset } = this.reader.getViewAndOffset(this.pos, this.pos + length);
+        this.pos += length;
+        return new Uint8Array(view.buffer, offset, length);
+    }
+    readU8() {
+        const { view, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 1);
+        this.pos += 1;
+        return view.getUint8(offset);
+    }
+    readU32() {
+        const { view, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 4);
+        this.pos += 4;
+        return view.getUint32(offset, true);
+    }
+    readI32() {
+        const { view, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 4);
+        this.pos += 4;
+        return view.getInt32(offset, true);
+    }
+    readI64() {
+        const low = this.readU32();
+        const high = this.readI32();
+        return high * 0x100000000 + low;
+    }
+    readAscii(length) {
+        const { view, offset } = this.reader.getViewAndOffset(this.pos, this.pos + length);
+        this.pos += length;
+        let str = '';
+        for (let i = 0; i < length; i++) {
+            str += String.fromCharCode(view.getUint8(offset + i));
+        }
+        return str;
+    }
+    readPageHeader() {
+        const startPos = this.pos;
+        const capturePattern = this.readU32();
+        if (capturePattern !== OGGS) {
+            return null;
+        }
+        this.pos += 1; // Version
+        const headerType = this.readU8();
+        const granulePosition = this.readI64();
+        const serialNumber = this.readU32();
+        const sequenceNumber = this.readU32();
+        const checksum = this.readU32();
+        const numberPageSegments = this.readU8();
+        const lacingValues = new Uint8Array(numberPageSegments);
+        for (let i = 0; i < numberPageSegments; i++) {
+            lacingValues[i] = this.readU8();
+        }
+        const headerSize = 27 + numberPageSegments;
+        const dataSize = lacingValues.reduce((a, b) => a + b, 0);
+        const totalSize = headerSize + dataSize;
+        return {
+            headerStartPos: startPos,
+            totalSize,
+            dataStartPos: startPos + headerSize,
+            dataSize,
+            headerType,
+            granulePosition,
+            serialNumber,
+            sequenceNumber,
+            checksum,
+            lacingValues,
+        };
+    }
+    findNextPageHeader(until) {
+        while (this.pos < until - (4 - 1)) { // Size of word minus 1
+            const word = this.readU32();
+            const firstByte = word & 0xff;
+            const secondByte = (word >>> 8) & 0xff;
+            const thirdByte = (word >>> 16) & 0xff;
+            const fourthByte = (word >>> 24) & 0xff;
+            const O = 0x4f; // 'O'
+            if (firstByte !== O && secondByte !== O && thirdByte !== O && fourthByte !== O) {
+                continue;
+            }
+            this.pos -= 4;
+            if (word === OGGS) {
+                // We have found the capture pattern
+                return true;
+            }
+            this.pos += 1;
+        }
+        return false;
+    }
+}