@remotion/media-parser 4.0.202 → 4.0.204

package/dist/av1-codec-string.d.ts

@@ -1,8 +1,3 @@
 import type { ColorParameterBox } from './boxes/iso-base-media/stsd/colr';
 import type { Av1BitstreamHeaderSegment } from './boxes/webm/bitstream/av1/header-segment';
-import type { ClusterSegment, TrackEntrySegment } from './boxes/webm/segments/track-entry';
 export declare const constructAv1CodecString: (av1BitstreamHeader: Av1BitstreamHeaderSegment, colrAtom: ColorParameterBox | null) => string;
-export declare const av1CodecStringToString: ({ track, clusterSegment, }: {
-    track: TrackEntrySegment;
-    clusterSegment: ClusterSegment;
-}) => string | null;

package/dist/av1-codec-string.js

@@ -1,9 +1,7 @@
 "use strict";
 // https://aomediacodec.github.io/av1-isobmff/#codecsparam
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.av1CodecStringToString = exports.constructAv1CodecString = void 0;
-const traversal_1 = require("./boxes/webm/traversal");
-const traversal_2 = require("./traversal");
+exports.constructAv1CodecString = void 0;
 const constructAv1CodecString = (av1BitstreamHeader, colrAtom) => {
     let str = 'av01.';
     // Profile
@@ -91,18 +89,3 @@ const constructAv1CodecString = (av1BitstreamHeader, colrAtom) => {
     return str;
 };
 exports.constructAv1CodecString = constructAv1CodecString;
-const av1CodecStringToString = ({ track, clusterSegment, }) => {
-    const codecSegment = (0, traversal_2.getCodecSegment)(track);
-    if (!codecSegment) {
-        throw new Error('Expected codec segment');
-    }
-    if (codecSegment.codec !== 'V_AV1') {
-        throw new Error(`Should not call this function if it is not AV1: ${codecSegment.codec}`);
-    }
-    const av1BitstreamHeader = (0, traversal_1.getAv1BitstreamHeader)(clusterSegment);
-    if (!av1BitstreamHeader) {
-        return null;
-    }
-    return (0, exports.constructAv1CodecString)(av1BitstreamHeader, null);
-};
-exports.av1CodecStringToString = av1CodecStringToString;

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

@@ -0,0 +1,9 @@
+import type { BaseBox } from './base-type';
+export interface FtypBox extends BaseBox {
+    type: 'ftyp-box';
+    majorBrand: string;
+    minorVersion: number;
+    compatibleBrands: string[];
+}
+export declare const fourByteToNumber: (data: ArrayBuffer, from: number) => number;
+export declare const parseFtyp: (data: ArrayBuffer, offset: number) => FtypBox;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFtyp = exports.fourByteToNumber = void 0;
+const fourByteToNumber = (data, from) => {
+    const view = new DataView(data);
+    return ((view.getUint8(from + 0) << 24) |
+        (view.getUint8(from + 1) << 16) |
+        (view.getUint8(from + 2) << 8) |
+        view.getUint8(from + 3));
+};
+exports.fourByteToNumber = fourByteToNumber;
+const parseFtyp = (data, offset) => {
+    const majorBrand = new TextDecoder().decode(data.slice(8, 12)).trim();
+    const minorVersion = (0, exports.fourByteToNumber)(data, 12);
+    const rest = data.slice(16);
+    const types = rest.byteLength / 4;
+    const compatibleBrands = [];
+    for (let i = 0; i < types; i++) {
+        const fourBytes = rest.slice(i * 4, i * 4 + 4);
+        compatibleBrands.push(new TextDecoder().decode(fourBytes).trim());
+    }
+    return {
+        type: 'ftyp-box',
+        majorBrand,
+        minorVersion,
+        compatibleBrands,
+        offset,
+        boxSize: data.byteLength,
+    };
+};
+exports.parseFtyp = parseFtyp;

package/dist/boxes/iso-base-media/get-sample-positions-from-track.d.ts

@@ -0,0 +1,4 @@
+import type { SamplePosition } from '../../get-sample-positions';
+import type { IsoBaseMediaBox } from '../../parse-result';
+import type { TrakBox } from './trak/trak';
+export declare const getSamplePositionsFromTrack: (trakBox: TrakBox, moofBox: IsoBaseMediaBox | null) => SamplePosition[];

package/dist/boxes/iso-base-media/get-sample-positions-from-track.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSamplePositionsFromTrack = void 0;
+const get_fps_1 = require("../../get-fps");
+const get_sample_positions_1 = require("../../get-sample-positions");
+const samples_from_moof_1 = require("../../samples-from-moof");
+const traversal_1 = require("../../traversal");
+const getSamplePositionsFromTrack = (trakBox, moofBox) => {
+    const stszBox = (0, traversal_1.getStszBox)(trakBox);
+    const stcoBox = (0, traversal_1.getStcoBox)(trakBox);
+    const stscBox = (0, traversal_1.getStscBox)(trakBox);
+    const stssBox = (0, traversal_1.getStssBox)(trakBox);
+    const sttsBox = (0, traversal_1.getSttsBox)(trakBox);
+    const tkhdBox = (0, traversal_1.getTkhdBox)(trakBox);
+    const cttsBox = (0, traversal_1.getCttsBox)(trakBox);
+    const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
+    if (!tkhdBox) {
+        throw new Error('Expected tkhd box in trak box');
+    }
+    if (!stszBox) {
+        throw new Error('Expected stsz box in trak box');
+    }
+    if (!stcoBox) {
+        throw new Error('Expected stco box in trak box');
+    }
+    if (!stscBox) {
+        throw new Error('Expected stsc box in trak box');
+    }
+    if (!sttsBox) {
+        throw new Error('Expected stts box in trak box');
+    }
+    if (!timescaleAndDuration) {
+        throw new Error('Expected timescale and duration in trak box');
+    }
+    let samplePositions = (0, get_sample_positions_1.getSamplePositions)({
+        stcoBox,
+        stscBox,
+        stszBox,
+        stssBox,
+        sttsBox,
+        cttsBox,
+    });
+    if (samplePositions.length === 0 && moofBox) {
+        samplePositions = (0, samples_from_moof_1.getSamplesFromMoof)({ moofBox, trackId: tkhdBox.trackId });
+    }
+    return samplePositions;
+};
+exports.getSamplePositionsFromTrack = getSamplePositionsFromTrack;

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

@@ -0,0 +1,12 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export interface TfdtBox {
+    type: 'tfdt-box';
+    version: number;
+    baseMediaDecodeTime: number;
+    offset: number;
+}
+export declare const parseTfdt: ({ iterator, size, offset, }: {
+    iterator: BufferIterator;
+    size: number;
+    offset: number;
+}) => TfdtBox;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTfdt = void 0;
+const parseTfdt = ({ iterator, size, offset, }) => {
+    const version = iterator.getUint8();
+    iterator.discard(3);
+    // Flags, discard them
+    const num = version === 0 ? iterator.getUint32() : Number(iterator.getUint64());
+    const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+    if (bytesRemaining !== 0) {
+        throw new Error('expected 0 bytes ' + bytesRemaining);
+    }
+    return {
+        type: 'tfdt-box',
+        version,
+        baseMediaDecodeTime: num,
+        offset,
+    };
+};
+exports.parseTfdt = parseTfdt;

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

@@ -0,0 +1,16 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export interface TfhdBox {
+    type: 'tfhd-box';
+    version: number;
+    trackId: number;
+    baseDataOffset: number;
+    baseSampleDescriptionIndex: number;
+    defaultSampleDuration: number;
+    defaultSampleSize: number;
+    defaultSampleFlags: number;
+}
+export declare const getTfhd: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    size: number;
+    offset: number;
+}) => TfhdBox;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTfhd = void 0;
+const getTfhd = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    const flags = iterator.getUint24();
+    const trackId = iterator.getUint32();
+    const baseDataOffsetPresent = flags & 0x01;
+    const baseDataOffset = baseDataOffsetPresent
+        ? Number(iterator.getUint64())
+        : 0;
+    const baseSampleDescriptionIndexPresent = flags & 0x02;
+    const baseSampleDescriptionIndex = baseSampleDescriptionIndexPresent
+        ? iterator.getUint32()
+        : 0;
+    const defaultSampleDurationPresent = flags & 0x08;
+    const defaultSampleDuration = defaultSampleDurationPresent
+        ? iterator.getUint32()
+        : 0;
+    const defaultSampleSizePresent = flags & 0x10;
+    const defaultSampleSize = defaultSampleSizePresent ? iterator.getUint32() : 0;
+    const defaultSampleFlagsPresent = flags & 0x20;
+    const defaultSampleFlags = defaultSampleFlagsPresent
+        ? iterator.getUint32()
+        : 0;
+    const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+    if (bytesRemaining !== 0) {
+        throw new Error('expected 0 bytes ' + bytesRemaining);
+    }
+    return {
+        type: 'tfhd-box',
+        version,
+        trackId,
+        baseDataOffset,
+        baseSampleDescriptionIndex,
+        defaultSampleDuration,
+        defaultSampleSize,
+        defaultSampleFlags,
+    };
+};
+exports.getTfhd = getTfhd;

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

@@ -0,0 +1,21 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export interface TrunBox {
+    type: 'trun-box';
+    version: number;
+    sampleCount: number;
+    dataOffset: number | null;
+    firstSampleFlags: number | null;
+    samples: TRunSample[];
+}
+type TRunSample = {
+    sampleDuration: number | null;
+    sampleSize: number | null;
+    sampleFlags: number | null;
+    sampleCompositionTimeOffset: number | null;
+};
+export declare const parseTrun: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => TrunBox;
+export {};

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTrun = void 0;
+const parseTrun = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported TRUN version ${version}`);
+    }
+    const flags = iterator.getUint24();
+    const sampleCount = iterator.getUint32();
+    const dataOffset = flags & 0x01 ? iterator.getInt32() : null;
+    const firstSampleFlags = flags & 0x04 ? iterator.getUint32() : null;
+    const samples = [];
+    for (let i = 0; i < sampleCount; i++) {
+        const sampleDuration = flags & 0x100 ? iterator.getUint32() : null;
+        const sampleSize = flags & 0x200 ? iterator.getUint32() : null;
+        const sampleFlags = flags & 0x400 ? iterator.getUint32() : null;
+        const sampleCompositionTimeOffset = flags & 0x800
+            ? version === 0
+                ? iterator.getUint32()
+                : iterator.getInt32Le()
+            : null;
+        samples.push({
+            sampleDuration,
+            sampleSize,
+            sampleFlags,
+            sampleCompositionTimeOffset,
+        });
+    }
+    const currentOffset = iterator.counter.getOffset();
+    const left = size - (currentOffset - offset);
+    if (left !== 0) {
+        throw new Error(`Unexpected data left in TRUN box: ${left}`);
+    }
+    return {
+        type: 'trun-box',
+        version,
+        sampleCount,
+        dataOffset,
+        firstSampleFlags,
+        samples,
+    };
+};
+exports.parseTrun = parseTrun;

package/dist/boxes/webm/bitstream/av1.js

@@ -50,15 +50,6 @@ const av1Bitstream = ({ stream, length, onVideoSample, trackNumber, context, tim
         : {
             type: 'av1-bitstream-unimplemented',
         };
-    if (segment.type === 'av1-bitstream-header') {
-        if (!size) {
-            throw new Error('Expected size');
-        }
-        const toSample = bytesReadSoFar + size;
-        stream.counter.decrement(stream.counter.getOffset() - address);
-        const header = stream.getSlice(toSample);
-        context.parserState.setAv1BitstreamHeaderSegment(segment, header);
-    }
     if (obuType === 6) {
         const head = context.parserState.getAv1BitstreamHeaderSegment();
         if (!head) {
@@ -89,7 +80,7 @@ const av1Bitstream = ({ stream, length, onVideoSample, trackNumber, context, tim
             }
         }
         onVideoSample(trackNumber, {
-            bytes: (0, combine_uint8array_1.combineUint8Arrays)(extraBytes, frame),
+            data: (0, combine_uint8array_1.combineUint8Arrays)(extraBytes, frame),
             timestamp: timecode + clusterTimestamp,
             duration: undefined,
             trackId: trackNumber,

package/dist/boxes/webm/ebml.d.ts

@@ -1,2 +1,2 @@
-export declare const measureEBMLVarInt: (value: number) => 4 | 6 | 1 | 5 | 3 | 2;
+export declare const measureEBMLVarInt: (value: number) => 2 | 3 | 1 | 4 | 5 | 6;
 export declare const getVariableInt: (value: number, minWidth: number | null) => Uint8Array;

package/dist/boxes/webm/segments/seek-position.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSeekPositionSegment = void 0;
 const parseSeekPositionSegment = (iterator, length) => {
-    const seekPosition = iterator.getDecimalBytes(length);
+    const seekPosition = iterator.getUint(length);
     return {
         type: 'seek-position-segment',
         seekPosition,

package/dist/boxes/webm/segments/seek.d.ts

@@ -10,4 +10,4 @@ export type SeekIdSegment = {
     type: 'seek-id-segment';
     seekId: string;
 };
-export declare const parseSeekIdSegment: (iterator: BufferIterator) => SeekIdSegment;
+export declare const parseSeekIdSegment: (iterator: BufferIterator, length: number) => SeekIdSegment;

package/dist/boxes/webm/segments/seek.js

@@ -19,8 +19,14 @@ const parseSeekSegment = async (iterator, length, parserContext) => {
     };
 };
 exports.parseSeekSegment = parseSeekSegment;
-const parseSeekIdSegment = (iterator) => {
-    const seekId = iterator.getMatroskaSegmentId();
+const parseSeekIdSegment = (iterator, length) => {
+    const seekId = '0x' +
+        [...iterator.getSlice(length)]
+            .map((b) => b.toString(16).padStart(2, '0'))
+            .join('');
+    if (seekId === null) {
+        throw new Error('Not enough bytes to parse seek id');
+    }
     return {
         type: 'seek-id-segment',
         seekId,

package/dist/boxes/webm/segments/timestamp-scale.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTimestampScaleSegment = void 0;
 const parseTimestampScaleSegment = (iterator) => {
-    const timestampScale = iterator.getDecimalBytes(3);
+    const timestampScale = iterator.getUint(3);
     return {
         type: 'timestamp-scale-segment',
         timestampScale,

package/dist/boxes/webm/tracks.d.ts

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParserContext } from '../../parser-context';
+import type { MatroskaSegment } from './segments';
+export type TracksSegment = {
+    type: 'tracks-segment';
+    children: MatroskaSegment[];
+};
+export declare const parseTracksSegment: (iterator: BufferIterator, length: number, parserContext: ParserContext) => Promise<TracksSegment>;

package/dist/boxes/webm/tracks.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTracksSegment = void 0;
+const parse_children_1 = require("./segments/parse-children");
+const parseTracksSegment = async (iterator, length, parserContext) => {
+    const children = await (0, parse_children_1.expectChildren)({
+        iterator,
+        length,
+        initialChildren: [],
+        wrap: null,
+        parserContext,
+    });
+    if (children.status === 'incomplete') {
+        throw new Error('Incomplete children');
+    }
+    return {
+        type: 'tracks-segment',
+        children: children.segments,
+    };
+};
+exports.parseTracksSegment = parseTracksSegment;

package/dist/from-web.js

@@ -3,9 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.webReader = void 0;
 exports.webReader = {
     read: async (src, range) => {
-        if (typeof src !== 'string') {
-            throw new Error('src must be a string when using `webReader`');
-        }
         const resolvedUrl = typeof window !== 'undefined' && typeof window.location !== 'undefined'
             ? new URL(src, window.location.origin).toString()
             : src;
@@ -17,28 +14,22 @@ exports.webReader = {
         const res = await fetch(resolvedUrl, {
             headers: range === null
                 ? {}
-                : typeof range === 'number'
-                    ? {
-                        Range: `bytes=${range}`,
-                    }
-                    : {
-                        Range: `bytes=${`${range[0]}-${range[1]}`}`,
-                    },
-            // Disable Next.js caching
-            cache: 'no-store',
+                : {
+                    Range: `bytes=${`${range[0]}-${range[1]}`}`,
+                },
         });
         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 };
     },
     getLength: async (src) => {
-        if (typeof src !== 'string') {
-            throw new Error('src must be a string when using `webReader`');
-        }
         const res = await fetch(src, {
             method: 'HEAD',
         });

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/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>;