@remotion/media-parser 4.0.192 → 4.0.193

package/dist/get-audio-codec.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioCodec = exports.hasAudioCodec = void 0;
+const get_fps_1 = require("./get-fps");
+const hasAudioCodec = (boxes) => {
+    try {
+        return (0, exports.getAudioCodec)(boxes) !== null;
+    }
+    catch (e) {
+        return false;
+    }
+};
+exports.hasAudioCodec = hasAudioCodec;
+const onEsdsBox = (child) => {
+    if (child && child.type === 'esds-box') {
+        const descriptor = child.descriptors.find((d) => d.type === 'decoder-config-descriptor');
+        if (descriptor && descriptor.type === 'decoder-config-descriptor') {
+            return descriptor.objectTypeIndication;
+        }
+    }
+    return null;
+};
+const onSample = (sample) => {
+    if (!sample) {
+        return null;
+    }
+    if (sample.type !== 'audio') {
+        return null;
+    }
+    if (sample.format === 'sowt') {
+        return 'aiff';
+    }
+    const child = sample.children.find((c) => c.type === 'esds-box');
+    if (child && child.type === 'esds-box') {
+        const ret = onEsdsBox(child);
+        if (ret) {
+            return ret;
+        }
+    }
+};
+const getAudioCodec = (boxes) => {
+    const moovBox = boxes.find((b) => b.type === 'moov-box');
+    if (moovBox && moovBox.type === 'moov-box') {
+        const trakBox = moovBox.children.find((b) => b.type === 'trak-box' && (0, get_fps_1.trakBoxContainsAudio)(b));
+        if (trakBox && trakBox.type === 'trak-box') {
+            const mdiaBox = trakBox.children.find((b) => b.type === 'regular-box' && b.boxType === 'mdia');
+            if (mdiaBox &&
+                mdiaBox.type === 'regular-box' &&
+                mdiaBox.boxType === 'mdia') {
+                const minfBox = mdiaBox === null || mdiaBox === void 0 ? void 0 : mdiaBox.children.find((b) => b.type === 'regular-box' && b.boxType === 'minf');
+                if (minfBox &&
+                    minfBox.type === 'regular-box' &&
+                    minfBox.boxType === 'minf') {
+                    const stblBox = minfBox === null || minfBox === void 0 ? void 0 : minfBox.children.find((b) => b.type === 'regular-box' && b.boxType === 'stbl');
+                    if (stblBox && stblBox.type === 'regular-box') {
+                        const stsdBox = stblBox === null || stblBox === void 0 ? void 0 : stblBox.children.find((b) => b.type === 'stsd-box');
+                        if (stsdBox && stsdBox.type === 'stsd-box') {
+                            const sample = stsdBox.samples.find((s) => s.type === 'audio');
+                            if (sample && sample.type === 'audio') {
+                                const ret = onSample(sample);
+                                if (ret) {
+                                    return ret;
+                                }
+                                const waveBox = sample.children.find((b) => b.type === 'regular-box' && b.boxType === 'wave');
+                                if (waveBox &&
+                                    waveBox.type === 'regular-box' &&
+                                    waveBox.boxType === 'wave') {
+                                    const esdsBox = waveBox.children.find((b) => b.type === 'esds-box');
+                                    if (esdsBox && esdsBox.type === 'esds-box') {
+                                        const ret2 = onEsdsBox(esdsBox);
+                                        if (ret2) {
+                                            return ret2;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    const mainSegment = boxes.find((b) => b.type === 'main-segment');
+    if (!mainSegment || mainSegment.type !== 'main-segment') {
+        return null;
+    }
+    const tracksSegment = mainSegment.children.find((b) => b.type === 'tracks-segment');
+    if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+        return null;
+    }
+    for (const track of tracksSegment.children) {
+        if (track.type === 'track-entry-segment') {
+            const trackType = track.children.find((b) => b.type === 'codec-segment');
+            if (trackType && trackType.type === 'codec-segment') {
+                if (trackType.codec === 'A_OPUS') {
+                    return 'opus';
+                }
+                if (trackType.codec === 'A_PCM/INT/LIT') {
+                    return 'pcm';
+                }
+            }
+        }
+    }
+    return null;
+};
+exports.getAudioCodec = getAudioCodec;

package/dist/get-dimensions.js

@@ -6,8 +6,12 @@ const getDimensionsFromMatroska = (segments) => {
     if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
         throw new Error('No tracks segment');
     }
-    // TODO: What if there are multiple video tracks, or audio track is first?
-    const trackEntrySegment = tracksSegment.children.find((b) => b.type === 'track-entry-segment');
+    const trackEntrySegment = tracksSegment.children.find((b) => {
+        if (b.type !== 'track-entry-segment') {
+            return false;
+        }
+        return (b.children.find((c) => c.type === 'codec-segment' && c.codec.startsWith('V_')) !== undefined);
+    });
     if (!trackEntrySegment || trackEntrySegment.type !== 'track-entry-segment') {
         throw new Error('No track entry segment');
     }

package/dist/get-fps.d.ts

@@ -3,6 +3,7 @@ type TimescaleAndDuration = {
     timescale: number;
     duration: number;
 };
+export declare const trakBoxContainsAudio: (trakBox: AnySegment) => boolean;
 export declare const trakBoxContainsVideo: (trakBox: AnySegment) => boolean;
 export declare const getTimescaleAndDuration: (boxes: AnySegment[]) => TimescaleAndDuration | null;
 export declare const getFps: (segments: AnySegment[]) => number | null;

package/dist/get-fps.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasFps = exports.getFps = exports.getTimescaleAndDuration = exports.trakBoxContainsVideo = void 0;
+exports.hasFps = exports.getFps = exports.getTimescaleAndDuration = exports.trakBoxContainsVideo = exports.trakBoxContainsAudio = void 0;
 const calculateFps = ({ sttsBox, timeScale, durationInSamples, }) => {
     let totalSamples = 0;
     for (const sample of sttsBox.sampleDistribution) {
@@ -10,6 +10,39 @@ const calculateFps = ({ sttsBox, timeScale, durationInSamples, }) => {
     const fps = totalSamples / durationInSeconds;
     return fps;
 };
+const trakBoxContainsAudio = (trakBox) => {
+    if (trakBox.type !== 'trak-box') {
+        return false;
+    }
+    const { children } = trakBox;
+    const mediaBoxes = children.filter((c) => c.type === 'regular-box' && c.boxType === 'mdia');
+    if (!mediaBoxes || mediaBoxes.length === 0) {
+        return false;
+    }
+    const firstMediaBox = mediaBoxes[0];
+    if (firstMediaBox.type !== 'regular-box' ||
+        firstMediaBox.boxType !== 'mdia') {
+        return false;
+    }
+    const minf = firstMediaBox.children.find((c) => c.type === 'regular-box' && c.boxType === 'minf');
+    if (!minf || minf.type !== 'regular-box' || minf.boxType !== 'minf') {
+        return false;
+    }
+    const stbl = minf.children.find((c) => c.type === 'regular-box' && c.boxType === 'stbl');
+    if (!stbl || stbl.type !== 'regular-box' || stbl.boxType !== 'stbl') {
+        return false;
+    }
+    const stsd = stbl.children.find((c) => c.type === 'stsd-box');
+    if (!stsd || stsd.type !== 'stsd-box') {
+        return false;
+    }
+    const videoSample = stsd.samples.find((s) => s.type === 'audio');
+    if (!videoSample || videoSample.type !== 'audio') {
+        return false;
+    }
+    return true;
+};
+exports.trakBoxContainsAudio = trakBoxContainsAudio;
 const trakBoxContainsVideo = (trakBox) => {
     if (trakBox.type !== 'trak-box') {
         return false;

package/dist/get-video-codec.js

@@ -68,6 +68,9 @@ const getVideoCodec = (boxes) => {
                 if (trackType.codec === 'V_AV1') {
                     return 'av1';
                 }
+                if (trackType.codec === 'V_MPEG4/ISO/AVC') {
+                    return 'h264';
+                }
             }
         }
     }

package/dist/get-video-metadata.d.ts

@@ -0,0 +1,2 @@
+import type { ParseMedia } from './options';
+export declare const parseMedia: ParseMedia;

package/dist/get-video-metadata.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMedia = void 0;
+const buffer_iterator_1 = require("./buffer-iterator");
+const from_web_1 = require("./from-web");
+const get_dimensions_1 = require("./get-dimensions");
+const get_duration_1 = require("./get-duration");
+const get_fps_1 = require("./get-fps");
+const has_all_info_1 = require("./has-all-info");
+const parse_video_1 = require("./parse-video");
+const parseMedia = async (src, options, readerInterface = from_web_1.webReader) => {
+    const reader = await readerInterface.read(src, null);
+    const returnValue = {};
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]));
+    let parseResult = (0, parse_video_1.parseVideo)(iterator);
+    while (parseResult.status === 'incomplete') {
+        const result = await reader.read();
+        if (result.done) {
+            break;
+        }
+        iterator.addData(result.value);
+        parseResult = parseResult.continueParsing();
+        if ((0, has_all_info_1.hasAllInfo)(options, parseResult)) {
+            if (!reader.closed) {
+                reader.cancel(new Error('has all information'));
+            }
+            break;
+        }
+    }
+    if (options.dimensions) {
+        returnValue.dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments);
+    }
+    if (options.durationInSeconds) {
+        returnValue.durationInSeconds = (0, get_duration_1.getDuration)(parseResult.segments);
+    }
+    if (options.fps) {
+        returnValue.fps = (0, get_fps_1.getFps)(parseResult.segments);
+    }
+    if (options.boxes) {
+        returnValue.boxes = parseResult.segments;
+    }
+    return returnValue;
+};
+exports.parseMedia = parseMedia;

package/dist/has-all-info.d.ts

@@ -1,3 +1,3 @@
 import type { Options } from './options';
 import type { ParseResult } from './parse-result';
-export declare const hasAllInfo: (options: Options<boolean, boolean, boolean, boolean, boolean>, parseResult: ParseResult) => boolean;
+export declare const hasAllInfo: (options: Options<boolean, boolean, boolean, boolean, boolean, boolean>, parseResult: ParseResult) => boolean;

package/dist/has-all-info.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasAllInfo = void 0;
+const get_audio_codec_1 = require("./get-audio-codec");
 const get_dimensions_1 = require("./get-dimensions");
 const get_duration_1 = require("./get-duration");
 const get_fps_1 = require("./get-fps");
@@ -25,6 +26,9 @@ const hasAllInfo = (options, parseResult) => {
         if (key === 'videoCodec') {
             return (0, get_video_codec_1.hasVideoCodec)(parseResult.segments) !== null;
         }
+        if (key === 'audioCodec') {
+            return (0, get_audio_codec_1.hasAudioCodec)(parseResult.segments) !== null;
+        }
         throw new Error(`Unknown key: ${key}`);
     });
 };

package/dist/options.d.ts

@@ -2,14 +2,16 @@ import type { Dimensions } from './get-dimensions';
 import type { AnySegment } from './parse-result';
 import type { ReaderInterface } from './reader';
 export type KnownVideoCodecs = 'h264' | 'h265' | 'vp8' | 'vp9' | 'av1' | 'prores';
-export type Options<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean> = {
+export type KnownAudioCodecs = 'aac' | 'mp3' | 'aiff' | 'opus' | 'pcm' | 'unknown';
+export type Options<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean> = {
     dimensions?: EnableDimensions;
     durationInSeconds?: EnableDuration;
     boxes?: EnableBoxes;
     fps?: EnableFps;
     videoCodec?: EnableVideoCodec;
+    audioCodec?: EnableAudioCodec;
 };
-export type Metadata<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean> = (EnableDimensions extends true ? {
+export type Metadata<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean> = (EnableDimensions extends true ? {
     dimensions: Dimensions;
 } : {}) & (EnableDuration extends true ? {
     durationInSeconds: number | null;
@@ -19,5 +21,7 @@ export type Metadata<EnableDimensions extends boolean, EnableDuration extends bo
     fps: number | null;
 } : {}) & (EnableVideoCodec extends true ? {
     videoCodec: KnownVideoCodecs | null;
+} : {}) & (EnableAudioCodec extends true ? {
+    audioCodec: KnownAudioCodecs | null;
 } : {});
-export type ParseMedia = <EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean>(src: string, options: Options<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec>, readerInterface?: ReaderInterface) => Promise<Metadata<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec>>;
+export type ParseMedia = <EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean>(src: string, options: Options<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec, EnableAudioCodec>, readerInterface?: ReaderInterface) => Promise<Metadata<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec, EnableAudioCodec>>;

package/dist/parse-media.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMedia = void 0;
 const buffer_iterator_1 = require("./buffer-iterator");
 const from_web_1 = require("./from-web");
+const get_audio_codec_1 = require("./get-audio-codec");
 const get_dimensions_1 = require("./get-dimensions");
 const get_duration_1 = require("./get-duration");
 const get_fps_1 = require("./get-fps");
@@ -10,17 +11,27 @@ const get_video_codec_1 = require("./get-video-codec");
 const has_all_info_1 = require("./has-all-info");
 const parse_video_1 = require("./parse-video");
 const parseMedia = async (src, options, readerInterface = from_web_1.webReader) => {
-    const reader = await readerInterface.read(src, null);
+    const { reader, contentLength } = await readerInterface.read(src, null);
     const returnValue = {};
-    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]));
-    let parseResult = (0, parse_video_1.parseVideo)(iterator);
-    while (parseResult.status === 'incomplete') {
+    let iterator = null;
+    let parseResult = null;
+    while (parseResult === null || parseResult.status === 'incomplete') {
         const result = await reader.read();
         if (result.done) {
             break;
         }
-        iterator.addData(result.value);
-        parseResult = parseResult.continueParsing();
+        if (iterator) {
+            iterator.addData(result.value);
+        }
+        else {
+            iterator = (0, buffer_iterator_1.getArrayBufferIterator)(result.value, contentLength !== null && contentLength !== void 0 ? contentLength : undefined);
+        }
+        if (parseResult) {
+            parseResult = parseResult.continueParsing();
+        }
+        else {
+            parseResult = (0, parse_video_1.parseVideo)(iterator);
+        }
         if ((0, has_all_info_1.hasAllInfo)(options, parseResult)) {
             if (!reader.closed) {
                 reader.cancel(new Error('has all information'));
@@ -28,6 +39,9 @@ const parseMedia = async (src, options, readerInterface = from_web_1.webReader)
             break;
         }
     }
+    if (!parseResult) {
+        throw new Error('Could not parse video');
+    }
     if (options.dimensions) {
         returnValue.dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments);
     }
@@ -40,6 +54,9 @@ const parseMedia = async (src, options, readerInterface = from_web_1.webReader)
     if (options.videoCodec) {
         returnValue.videoCodec = (0, get_video_codec_1.getVideoCodec)(parseResult.segments);
     }
+    if (options.audioCodec) {
+        returnValue.audioCodec = (0, get_audio_codec_1.getAudioCodec)(parseResult.segments);
+    }
     if (options.boxes) {
         returnValue.boxes = parseResult.segments;
     }

package/dist/parse-result.d.ts

@@ -1,4 +1,5 @@
 import type { BaseBox } from './boxes/iso-base-media/base-type';
+import type { EsdsBox } from './boxes/iso-base-media/esds/esds';
 import type { FtypBox } from './boxes/iso-base-media/ftyp';
 import type { MdhdBox } from './boxes/iso-base-media/mdhd';
 import type { MoovBox } from './boxes/iso-base-media/moov/moov';
@@ -17,7 +18,7 @@ interface RegularBox extends BaseBox {
     offset: number;
     type: 'regular-box';
 }
-export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox;
+export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | EsdsBox;
 export type AnySegment = MatroskaSegment | IsoBaseMediaBox;
 export type ParseResult = {
     status: 'done';

package/dist/read-and-increment-offset.d.ts

@@ -0,0 +1,28 @@
+export declare class OffsetCounter {
+    #private;
+    constructor(initial: number);
+    increment(amount: number): void;
+    getOffset(): number;
+}
+export declare const getArrayBufferIterator: (data: ArrayBuffer, initialOffset: number) => {
+    view: DataView;
+    counter: OffsetCounter;
+    data: ArrayBuffer;
+    discard: (length: number) => void;
+    getSlice: (amount: number) => ArrayBuffer;
+    getAtom: () => string;
+    getMatroskaSegmentId: () => string;
+    getVint: (bytes: number) => number;
+    getUint8: () => number;
+    getEBML: () => number;
+    getInt8: () => number;
+    getUint16: () => number;
+    getInt16: () => number;
+    getUint32: () => number;
+    getFixedPoint1616Number: () => number;
+    getPascalString: () => number[];
+    getDecimalBytes(length: number): number;
+    getByteString(length: number): string;
+    getFloat64: () => number;
+};
+export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;

package/dist/read-and-increment-offset.js

@@ -0,0 +1,177 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _OffsetCounter_offset;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArrayBufferIterator = exports.OffsetCounter = void 0;
+class OffsetCounter {
+    constructor(initial) {
+        _OffsetCounter_offset.set(this, void 0);
+        __classPrivateFieldSet(this, _OffsetCounter_offset, initial, "f");
+    }
+    increment(amount) {
+        if (amount < 0) {
+            throw new Error('Cannot increment by a negative amount');
+        }
+        __classPrivateFieldSet(this, _OffsetCounter_offset, __classPrivateFieldGet(this, _OffsetCounter_offset, "f") + amount, "f");
+    }
+    getOffset() {
+        return __classPrivateFieldGet(this, _OffsetCounter_offset, "f");
+    }
+}
+exports.OffsetCounter = OffsetCounter;
+_OffsetCounter_offset = new WeakMap();
+const makeOffsetCounter = (initial) => {
+    return new OffsetCounter(initial);
+};
+const getArrayBufferIterator = (data, initialOffset) => {
+    const view = new DataView(data);
+    const counter = makeOffsetCounter(initialOffset);
+    const getSlice = (amount) => {
+        const value = data.slice(counter.getOffset(), counter.getOffset() + amount);
+        counter.increment(amount);
+        return value;
+    };
+    const getUint8 = () => {
+        const val = view.getUint8(counter.getOffset());
+        counter.increment(1);
+        return val;
+    };
+    const getUint32 = () => {
+        const val = view.getUint32(counter.getOffset());
+        counter.increment(4);
+        return val;
+    };
+    return {
+        view,
+        counter,
+        data,
+        discard: (length) => {
+            counter.increment(length);
+        },
+        getSlice,
+        getAtom: () => {
+            const atom = getSlice(4);
+            return new TextDecoder().decode(atom);
+        },
+        getMatroskaSegmentId: () => {
+            const first = getSlice(1);
+            const firstOneString = `0x${Array.from(new Uint8Array(first))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+            // Catch void block
+            const knownIdsWithOneLength = ['0xec', '0xae'];
+            if (knownIdsWithOneLength.includes(firstOneString)) {
+                return firstOneString;
+            }
+            const firstTwo = getSlice(1);
+            const knownIdsWithTwoLength = ['0x4dbb', '0x53ac', '0xec01'];
+            const firstTwoString = `${firstOneString}${Array.from(new Uint8Array(firstTwo))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+            if (knownIdsWithTwoLength.includes(firstTwoString)) {
+                return firstTwoString;
+            }
+            const knownIdsWithThreeLength = ['0x4d808c', '0x57418c', '0x448988'];
+            const firstThree = getSlice(1);
+            const firstThreeString = `${firstTwoString}${Array.from(new Uint8Array(firstThree))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+            if (knownIdsWithThreeLength.includes(firstThreeString)) {
+                return firstThreeString;
+            }
+            const segmentId = getSlice(1);
+            return `${firstThreeString}${Array.from(new Uint8Array(segmentId))
+                .map((b) => {
+                return b.toString(16).padStart(2, '0');
+            })
+                .join('')}`;
+        },
+        getVint: (bytes) => {
+            const slice = getSlice(bytes);
+            const d = [...Array.from(new Uint8Array(slice))];
+            const totalLength = d[0];
+            if (totalLength === 0) {
+                return 0;
+            }
+            // Calculate the actual length of the data based on the first set bit
+            let actualLength = 0;
+            while (((totalLength >> (7 - actualLength)) & 0x01) === 0) {
+                actualLength++;
+            }
+            actualLength += 1; // Include the first byte set as 1
+            // Combine the numbers to form the integer value
+            let value = 0;
+            // Mask the first byte properly then start combining
+            value = totalLength & (0xff >> actualLength);
+            for (let i = 1; i < actualLength; i++) {
+                value = (value << 8) | d[i];
+            }
+            return value;
+        },
+        getUint8,
+        getEBML: () => {
+            const val = getUint8();
+            // https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/#:~:text=The%20first%20four%20bytes%20(%201A,%E2%80%93%20read%20on%20for%20why).
+            // You drop the initial 0 bits and the first 1 bit to get the value. 0x81 is 0b10000001, so there are zero inital 0 bits, meaning length one byte, and the value is 1. The 0x9F value for length of the EBML header we saw earlier is 0b10011111, still one byte, value is 0b0011111, which is 31 (the python repl is very helpful for these conversions).
+            const actualValue = val & 0x7f; // 0x7F is binary 01111111, which masks out the first bit
+            return actualValue;
+        },
+        getInt8: () => {
+            const val = view.getInt8(counter.getOffset());
+            counter.increment(1);
+            return val;
+        },
+        getUint16: () => {
+            const val = view.getUint16(counter.getOffset());
+            counter.increment(2);
+            return val;
+        },
+        getInt16: () => {
+            const val = view.getInt16(counter.getOffset());
+            counter.increment(2);
+            return val;
+        },
+        getUint32,
+        // https://developer.apple.com/documentation/quicktime-file-format/sound_sample_description_version_1
+        // A 32-bit unsigned fixed-point number (16.16) that indicates the rate at which the sound samples were obtained.
+        getFixedPoint1616Number: () => {
+            const val = getUint32();
+            return val / 2 ** 16;
+        },
+        getPascalString: () => {
+            const val = getSlice(32);
+            return [...Array.from(new Uint8Array(val))];
+        },
+        getDecimalBytes(length) {
+            const bytes = getSlice(length);
+            const numbers = [...Array.from(new Uint8Array(bytes))];
+            return numbers.reduce((acc, byte, index) => acc + (byte << (8 * (numbers.length - index - 1))), 0);
+        },
+        getByteString(length) {
+            const bytes = getSlice(length);
+            return new TextDecoder().decode(bytes);
+        },
+        getFloat64: () => {
+            const val = view.getFloat64(counter.getOffset());
+            counter.increment(8);
+            return val;
+        },
+    };
+};
+exports.getArrayBufferIterator = getArrayBufferIterator;

package/dist/reader.d.ts

@@ -1,4 +1,8 @@
-type ReadContent = (src: string, range: [number, number] | null) => Promise<ReadableStreamDefaultReader<Uint8Array>>;
+type ReadResult = {
+    reader: ReadableStreamDefaultReader<Uint8Array>;
+    contentLength: number | null;
+};
+type ReadContent = (src: string, range: [number, number] | null) => Promise<ReadResult>;
 type GetLength = (src: string) => Promise<number>;
 export type ReaderInterface = {
     read: ReadContent;

package/package.json

@@ -3,11 +3,11 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.192",
+  "version": "4.0.193",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
-    "@remotion/renderer": "4.0.192"
+    "@remotion/renderer": "4.0.193"
   },
   "publishConfig": {
     "access": "public"