@remotion/media-parser 4.0.193 → 4.0.194

package/dist/boxes/iso-base-media/esds-descriptors.d.ts

@@ -0,0 +1,21 @@
+import type { BufferIterator } from '../../buffer-iterator';
+type AudioObjectType = 'aac' | 'mp3' | 'unknown';
+type DecoderConfigDescriptor = {
+    type: 'decoder-config-descriptor';
+    objectTypeIndication: AudioObjectType;
+};
+type SlConfigDescriptor = {
+    type: 'sl-config-descriptor';
+};
+type UnknownDescriptor = {
+    type: 'unknown-descriptor';
+};
+export type Descriptor = DecoderConfigDescriptor | SlConfigDescriptor | UnknownDescriptor;
+type DescriptorAndNext = {
+    descriptor: Descriptor | null;
+};
+export declare const processDescriptor: ({ iterator, }: {
+    iterator: BufferIterator;
+}) => DescriptorAndNext;
+export declare const parseDescriptors: (iterator: BufferIterator, maxBytes: number) => Descriptor[];
+export {};

package/dist/boxes/iso-base-media/esds-descriptors.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDescriptors = exports.processDescriptor = void 0;
+const mapToObjectAudioIndicator = (num) => {
+    // https://chromium.googlesource.com/chromium/src/media/+/master/formats/mp4/es_descriptor.h
+    // http://netmedia.zju.edu.cn/multimedia2013/mpeg-4/ISO%20IEC%2014496-1%20MPEG-4%20System%20Standard.pdf
+    // Page 42, table 8
+    if (num === 0x40) {
+        return 'aac';
+    }
+    if (num === 0x6b) {
+        return 'mp3';
+    }
+    return 'unknown';
+};
+const processDescriptor = ({ iterator, }) => {
+    const tag = iterator.getUint8();
+    if (tag === 4) {
+        const size = iterator.getPaddedFourByteNumber();
+        const initialOffset = iterator.counter.getOffset();
+        const objectTypeIndication = iterator.getUint8();
+        const remaining = size - (iterator.counter.getOffset() - initialOffset);
+        iterator.discard(remaining);
+        return {
+            descriptor: {
+                type: 'decoder-config-descriptor',
+                objectTypeIndication: mapToObjectAudioIndicator(objectTypeIndication),
+            },
+        };
+    }
+    if (tag === 6) {
+        const size = iterator.getPaddedFourByteNumber();
+        iterator.discard(size);
+        return {
+            descriptor: {
+                type: 'sl-config-descriptor',
+            },
+        };
+    }
+    return {
+        descriptor: null,
+    };
+};
+exports.processDescriptor = processDescriptor;
+const parseDescriptors = (iterator, maxBytes) => {
+    const descriptors = [];
+    const initialOffset = iterator.counter.getOffset();
+    while (iterator.bytesRemaining() > 0 &&
+        iterator.counter.getOffset() - initialOffset < maxBytes) {
+        const { descriptor } = (0, exports.processDescriptor)({
+            iterator,
+        });
+        if (descriptor) {
+            descriptors.push(descriptor);
+        }
+        else {
+            break;
+        }
+    }
+    return descriptors;
+};
+exports.parseDescriptors = parseDescriptors;

package/dist/boxes/iso-base-media/esds.d.ts

@@ -0,0 +1,15 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { Descriptor } from './esds-descriptors';
+export interface EsdsBox {
+    type: 'esds-box';
+    version: number;
+    tag: number;
+    sizeOfInstance: number;
+    esId: number;
+    descriptors: Descriptor[];
+}
+export declare const parseEsds: ({ data, size, fileOffset, }: {
+    data: BufferIterator;
+    size: number;
+    fileOffset: number;
+}) => EsdsBox;

package/dist/boxes/iso-base-media/esds.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEsds = void 0;
+const esds_descriptors_1 = require("./esds-descriptors");
+const parseEsds = ({ data, size, fileOffset, }) => {
+    const version = data.getUint8();
+    // Flags, we discard them
+    data.discard(3);
+    const tag = data.getUint8();
+    const sizeOfInstance = data.getPaddedFourByteNumber();
+    const esId = data.getUint16();
+    // disard 1 byte, currently unknown
+    data.discard(1);
+    const remaining = size - (data.counter.getOffset() - fileOffset);
+    const descriptors = (0, esds_descriptors_1.parseDescriptors)(data, remaining);
+    const remainingNow = size - (data.counter.getOffset() - fileOffset);
+    data.discard(remainingNow);
+    return {
+        type: 'esds-box',
+        version,
+        tag,
+        sizeOfInstance,
+        esId,
+        descriptors,
+    };
+};
+exports.parseEsds = parseEsds;

package/dist/boxes/iso-base-media/mdat/mdat.d.ts

@@ -0,0 +1,12 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { AnySegment } from '../../../parse-result';
+export interface MdatBox {
+    type: 'mdat-box';
+    boxSize: number;
+}
+export declare const parseMdat: ({ data, size, fileOffset, }: {
+    data: BufferIterator;
+    size: number;
+    fileOffset: number;
+    existingBoxes: AnySegment[];
+}) => MdatBox;

package/dist/boxes/iso-base-media/mdat/mdat.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMdat = void 0;
+const parseMdat = ({ data, size, fileOffset, }) => {
+    // TODO: Do something cool with it
+    // 	const tracks = getTracks(existingBoxes);
+    data.discard(size - (data.counter.getOffset() - fileOffset));
+    return {
+        type: 'mdat-box',
+        boxSize: size,
+    };
+};
+exports.parseMdat = parseMdat;

package/dist/boxes/iso-base-media/process-box.js

@@ -44,6 +44,29 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
         throw new Error(`Expected box size of not 0, got ${boxSize}`);
     }
     if (bytesRemaining < boxSize) {
+        if (bytesRemaining >= 4) {
+            const type = iterator.getByteString(4);
+            iterator.counter.decrement(4);
+            if (type === 'mdat') {
+                const skipTo = fileOffset + boxSize;
+                const bytesToSkip = skipTo - iterator.counter.getOffset();
+                // If there is a huge mdat chunk, we can skip it because we don't need it for the metadata
+                if (bytesToSkip > 1000000) {
+                    return {
+                        type: 'complete',
+                        box: {
+                            type: 'regular-box',
+                            boxType: 'mdat',
+                            children: [],
+                            boxSize,
+                            offset: fileOffset,
+                        },
+                        size: boxSize,
+                        skipTo: fileOffset + boxSize,
+                    };
+                }
+            }
+        }
         iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
         if (allowIncompleteBoxes) {
             return {
@@ -59,6 +82,7 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             type: 'complete',
             box,
             size: boxSize,
+            skipTo: null,
         };
     }
     if (boxType === 'mvhd') {
@@ -67,6 +91,7 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             type: 'complete',
             box,
             size: boxSize,
+            skipTo: null,
         };
     }
     if (boxType === 'tkhd') {
@@ -75,6 +100,7 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             type: 'complete',
             box,
             size: boxSize,
+            skipTo: null,
         };
     }
     if (boxType === 'stsd') {
@@ -83,6 +109,7 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             type: 'complete',
             box,
             size: boxSize,
+            skipTo: null,
         };
     }
     if (boxType === 'mebx') {
@@ -91,6 +118,7 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             type: 'complete',
             box,
             size: boxSize,
+            skipTo: null,
         };
     }
     if (boxType === 'moov') {
@@ -99,6 +127,7 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             type: 'complete',
             box,
             size: boxSize,
+            skipTo: null,
         };
     }
     if (boxType === 'trak') {
@@ -111,6 +140,7 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             type: 'complete',
             box,
             size: boxSize,
+            skipTo: null,
         };
     }
     if (boxType === 'stts') {
@@ -123,6 +153,7 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             type: 'complete',
             box,
             size: boxSize,
+            skipTo: null,
         };
     }
     if (boxType === 'mdhd') {
@@ -135,6 +166,7 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             type: 'complete',
             box,
             size: boxSize,
+            skipTo: null,
         };
     }
     if (boxType === 'esds') {
@@ -147,6 +179,7 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             type: 'complete',
             box,
             size: boxSize,
+            skipTo: null,
         };
     }
     const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
@@ -165,6 +198,7 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             offset: fileOffset,
         },
         size: boxSize,
+        skipTo: null,
     };
 };
 const parseBoxes = ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, }) => {
@@ -191,9 +225,25 @@ const parseBoxes = ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, })
                         initialBoxes: boxes,
                     });
                 },
+                skipTo: null,
             };
         }
         boxes.push(result.box);
+        if (result.skipTo !== null) {
+            return {
+                status: 'incomplete',
+                segments: boxes,
+                continueParsing: () => {
+                    return (0, exports.parseBoxes)({
+                        iterator,
+                        maxBytes,
+                        allowIncompleteBoxes,
+                        initialBoxes: boxes,
+                    });
+                },
+                skipTo: result.skipTo,
+            };
+        }
         iterator.discardFirstBytes();
     }
     return {

package/dist/boxes/iso-base-media/stsd/stco.d.ts

@@ -0,0 +1,14 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+export interface StcoBox extends BaseBox {
+    type: 'stco-box';
+    version: number;
+    flags: number[];
+    entryCount: number;
+    entries: number[];
+}
+export declare const parseStco: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => StcoBox;

package/dist/boxes/iso-base-media/stsd/stco.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStco = void 0;
+const parseStco = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported STSD version ${version}`);
+    }
+    const flags = iterator.getSlice(3);
+    const entryCount = iterator.getUint32();
+    const entries = [];
+    for (let i = 0; i < entryCount; i++) {
+        const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+        if (bytesRemaining < 4) {
+            break;
+        }
+        entries.push(iterator.getUint32());
+    }
+    iterator.discard(size - (iterator.counter.getOffset() - offset));
+    return {
+        type: 'stco-box',
+        boxSize: size,
+        offset,
+        version,
+        flags: [...flags],
+        entries,
+        entryCount,
+    };
+};
+exports.parseStco = parseStco;

package/dist/boxes/iso-base-media/stsd/stsc.d.ts

@@ -0,0 +1,19 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+type StscEntry = {
+    firstChunk: number;
+    samplesPerChunk: number;
+};
+export interface StscBox extends BaseBox {
+    type: 'stsc-box';
+    version: number;
+    flags: number[];
+    entryCount: number;
+    entries: StscEntry[];
+}
+export declare const parseStsc: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => StscBox;
+export {};

package/dist/boxes/iso-base-media/stsd/stsc.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStsc = void 0;
+const parseStsc = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported STSD version ${version}`);
+    }
+    const flags = iterator.getSlice(3);
+    const entryCount = iterator.getUint32();
+    const entries = [];
+    for (let i = 0; i < entryCount; i++) {
+        const firstChunk = iterator.getUint32();
+        const samplesPerChunk = iterator.getUint32();
+        const sampleDescriptionIndex = iterator.getUint32();
+        if (sampleDescriptionIndex !== 1) {
+            throw new Error(`Expected sampleDescriptionIndex to be 1, but got ${sampleDescriptionIndex}`);
+        }
+        entries.push({
+            firstChunk,
+            samplesPerChunk,
+        });
+    }
+    return {
+        type: 'stsc-box',
+        boxSize: size,
+        offset,
+        version,
+        flags: [...flags],
+        entryCount,
+        entries,
+    };
+};
+exports.parseStsc = parseStsc;

package/dist/boxes/iso-base-media/stsd/stsz.d.ts

@@ -0,0 +1,15 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+export type StszBox = BaseBox & {
+    type: 'stsz-box';
+    version: number;
+    flags: number[];
+    sampleSize: number;
+    sampleCount: number;
+    samples: number[];
+};
+export declare const parseStsz: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => StszBox;

package/dist/boxes/iso-base-media/stsd/stsz.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStsz = void 0;
+const parseStsz = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported STSD version ${version}`);
+    }
+    const flags = iterator.getSlice(3);
+    const sampleSize = iterator.getUint32();
+    const sampleCount = iterator.getUint32();
+    const samples = [];
+    for (let i = 0; i < sampleCount; i++) {
+        const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+        if (bytesRemaining < 4) {
+            break;
+        }
+        samples.push(iterator.getUint32());
+    }
+    iterator.discard(size - (iterator.counter.getOffset() - offset));
+    return {
+        type: 'stsz-box',
+        boxSize: size,
+        offset,
+        version,
+        flags: [...flags],
+        sampleSize,
+        sampleCount,
+        samples,
+    };
+};
+exports.parseStsz = parseStsz;

package/dist/buffer-iterator.d.ts

@@ -8,6 +8,7 @@ export declare class OffsetCounter {
     decrement(amount: number): void;
 }
 export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes?: number) => {
+    skipTo: (offset: number) => void;
     addData: (newData: Uint8Array) => void;
     counter: OffsetCounter;
     byteLength: () => number;

package/dist/buffer-iterator.js

@@ -58,6 +58,9 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     const buf = new ArrayBuffer(initialData.byteLength, {
         maxByteLength: maxBytes !== null && maxBytes !== void 0 ? maxBytes : 1000000000,
     });
+    if (!buf.resize) {
+        throw new Error('`ArrayBuffer.resize` is not supported in this Runtime. Use at least Node.js 20 or Bun.');
+    }
     let data = new Uint8Array(buf);
     data.set(initialData);
     let view = new DataView(data.buffer);
@@ -110,13 +113,24 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     };
     const removeBytesRead = () => {
         const bytesToRemove = counter.getDiscardedOffset();
+        // Only to this operation if it is really worth it 😇
+        if (bytesToRemove < 100000) {
+            return;
+        }
         counter.discardBytes(bytesToRemove);
         const newData = data.slice(bytesToRemove);
         data.set(newData);
         buf.resize(newData.byteLength);
         view = new DataView(data.buffer);
     };
+    const skipTo = (offset) => {
+        buf.resize(offset);
+        const currentOffset = counter.getOffset();
+        counter.increment(offset - currentOffset);
+        removeBytesRead();
+    };
     return {
+        skipTo,
         addData,
         counter,
         byteLength,

package/dist/from-node.js

@@ -7,8 +7,12 @@ const stream_1 = require("stream");
 exports.nodeReader = {
     read: async (src, range) => {
         const stream = (0, fs_1.createReadStream)(src, {
-            start: range === null ? 0 : range[0],
-            end: range === null ? Infinity : range[1],
+            start: range === null ? 0 : typeof range === 'number' ? range : range[0],
+            end: range === null
+                ? Infinity
+                : typeof range === 'number'
+                    ? Infinity
+                    : range[1],
         });
         const stats = await (0, promises_1.stat)(src);
         return {

package/dist/from-web.js

@@ -14,17 +14,20 @@ exports.webReader = {
         const res = await fetch(resolvedUrl, {
             headers: range === null
                 ? {}
-                : {
-                    Range: `bytes=${`${range[0]}-${range[1]}`}`,
-                },
+                : typeof range === 'number'
+                    ? {
+                        Range: `bytes=${range}`,
+                    }
+                    : {
+                        Range: `bytes=${`${range[0]}-${range[1]}`}`,
+                    },
+            // Disable Next.js caching
+            cache: 'no-store',
         });
         if (!res.body) {
             throw new Error('No body');
         }
         const length = res.headers.get('content-length');
-        if (!length) {
-            throw new Error('No content-length');
-        }
         const contentLength = length === null ? null : parseInt(length, 10);
         const reader = res.body.getReader();
         return { reader, contentLength };

package/dist/get-codec.d.ts

@@ -0,0 +1,4 @@
+import type { KnownVideoCodecs } from './options';
+import type { AnySegment } from './parse-result';
+export declare const hasVideoCodec: (boxes: AnySegment[]) => boolean;
+export declare const getVideoCodec: (boxes: AnySegment[]) => KnownVideoCodecs | null;

package/dist/get-codec.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoCodec = exports.hasVideoCodec = void 0;
+const hasVideoCodec = (boxes) => {
+    try {
+        return boxes.some((b) => b.type === 'ftyp-box');
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.hasVideoCodec = hasVideoCodec;
+const getVideoCodec = (boxes) => {
+    const ftypBox = boxes.find((b) => b.type === 'ftyp-box');
+    if (ftypBox && ftypBox.type === 'ftyp-box') {
+        if (ftypBox.compatibleBrands.find((b) => b === 'avc1')) {
+            return 'h264';
+        }
+    }
+    return null;
+};
+exports.getVideoCodec = getVideoCodec;

package/dist/get-sample-positions.d.ts

@@ -0,0 +1,12 @@
+import type { StcoBox } from './boxes/iso-base-media/stsd/stco';
+import type { StscBox } from './boxes/iso-base-media/stsd/stsc';
+import type { StszBox } from './boxes/iso-base-media/stsd/stsz';
+export type SamplePosition = {
+    offset: number;
+    size: number;
+};
+export declare const getSamplePositions: ({ stcoBox, stszBox, stscBox, }: {
+    stcoBox: StcoBox;
+    stszBox: StszBox;
+    stscBox: StscBox;
+}) => SamplePosition[];

package/dist/get-sample-positions.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSamplePositions = void 0;
+const getSamplePositions = ({ stcoBox, stszBox, stscBox, }) => {
+    const chunks = stcoBox.entries;
+    const samples = [];
+    let samplesPerChunk = 1;
+    for (let i = 0; i < chunks.length; i++) {
+        const hasEntry = stscBox.entries.find((entry) => entry.firstChunk === i + 1);
+        if (hasEntry) {
+            samplesPerChunk = hasEntry.samplesPerChunk;
+        }
+        let offsetInThisChunk = 0;
+        for (let j = 0; j < samplesPerChunk; j++) {
+            const size = stszBox.samples[samples.length];
+            samples.push({
+                offset: chunks[i] + offsetInThisChunk,
+                size,
+            });
+            offsetInThisChunk += size;
+        }
+    }
+    return samples;
+};
+exports.getSamplePositions = getSamplePositions;

package/dist/get-samples.js

@@ -0,0 +1 @@
+"use strict";

package/dist/get-tracks.d.ts

@@ -0,0 +1,10 @@
+import type { SamplePosition } from './get-sample-positions';
+import type { AnySegment } from './parse-result';
+type Track = {
+    type: 'audio' | 'video';
+    samplePositions: SamplePosition[];
+    trackId: number;
+};
+export declare const getNumberOfTracks: (segments: AnySegment[]) => number;
+export declare const getTracks: (segments: AnySegment[]) => Track[];
+export {};