@remotion/media-parser 4.0.202 → 4.0.205

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) => 1 | 2 | 3 | 4 | 5 | 6;
 export declare const getVariableInt: (value: number, minWidth: number | null) => Uint8Array;

package/dist/boxes/webm/get-track.js

@@ -150,7 +150,6 @@ const getTrack = ({ timescale, track, }) => {
                 denominator: 1,
             },
             timescale,
-            samplePositions: [],
             codedHeight: height.value.value,
             codedWidth: width.value.value,
             displayAspectHeight: displayHeight
@@ -160,6 +159,7 @@ const getTrack = ({ timescale, track, }) => {
                 ? displayWidth.value.value
                 : width.value.value,
             rotation: 0,
+            trakBox: null,
         };
     }
     if ((0, track_entry_1.trackTypeToString)(trackType.value.value) === 'audio') {
@@ -172,11 +172,11 @@ const getTrack = ({ timescale, track, }) => {
             type: 'audio',
             trackId,
             codec: getMatroskaAudioCodecString(track),
-            samplePositions: null,
             timescale,
             numberOfChannels,
             sampleRate,
             description: (0, description_1.getAudioDescription)(track),
+            trakBox: null,
         };
     }
     return null;

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/buffer-iterator.d.ts

@@ -50,6 +50,7 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     getFloat32: () => number;
     getUint32Le: () => number;
     getInt32Le: () => number;
+    getInt32: () => number;
     destroy: () => void;
     isMp3: () => boolean;
 };

package/dist/buffer-iterator.js

@@ -392,8 +392,8 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         },
         getUint24: () => {
             const val1 = view.getUint8(counter.getDiscardedOffset());
-            const val2 = view.getUint8(counter.getDiscardedOffset());
-            const val3 = view.getUint8(counter.getDiscardedOffset());
+            const val2 = view.getUint8(counter.getDiscardedOffset() + 1);
+            const val3 = view.getUint8(counter.getDiscardedOffset() + 2);
             counter.increment(3);
             return (val1 << 16) | (val2 << 8) | val3;
         },
@@ -443,6 +443,7 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         },
         getUint32Le,
         getInt32Le,
+        getInt32,
         destroy,
         isMp3,
     };

package/dist/create/cluster-segment.d.ts

@@ -0,0 +1,10 @@
+export declare const CLUSTER_MIN_VINT_WIDTH = 8;
+export declare const createClusterSegment: () => import("../boxes/webm/segments/all-segments").BytesAndOffset;
+export declare const makeSimpleBlock: ({ bytes, trackNumber, timecodeRelativeToCluster, keyframe, invisible, lacing, }: {
+    bytes: Uint8Array;
+    trackNumber: number;
+    timecodeRelativeToCluster: number;
+    keyframe: boolean;
+    invisible: boolean;
+    lacing: number;
+}) => Uint8Array;

package/dist/create/cluster-segment.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSimpleBlock = exports.createClusterSegment = exports.CLUSTER_MIN_VINT_WIDTH = void 0;
+const ebml_1 = require("../boxes/webm/ebml");
+const make_header_1 = require("../boxes/webm/make-header");
+exports.CLUSTER_MIN_VINT_WIDTH = 8;
+const createClusterSegment = () => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Cluster',
+        value: [
+            {
+                type: 'Timestamp',
+                minVintWidth: 4,
+                value: {
+                    value: 0,
+                    byteLength: null,
+                },
+            },
+        ],
+        minVintWidth: exports.CLUSTER_MIN_VINT_WIDTH,
+    });
+};
+exports.createClusterSegment = createClusterSegment;
+const makeSimpleBlock = ({ bytes, trackNumber, timecodeRelativeToCluster, keyframe, invisible, lacing, }) => {
+    const simpleBlockHeader = (0, make_header_1.matroskaToHex)('0xa3');
+    const headerByte = (Number(keyframe) << 7) | (Number(invisible) << 3) | (lacing << 1);
+    const body = (0, make_header_1.combineUint8Arrays)([
+        (0, ebml_1.getVariableInt)(trackNumber, null),
+        // TODO: Cannot encode long videos because of uint16 overflow
+        // need to make new cluster
+        (0, make_header_1.serializeUint16)(timecodeRelativeToCluster),
+        new Uint8Array([headerByte]),
+        bytes,
+    ]);
+    return (0, make_header_1.combineUint8Arrays)([
+        simpleBlockHeader,
+        (0, ebml_1.getVariableInt)(body.length, null),
+        body,
+    ]);
+};
+exports.makeSimpleBlock = makeSimpleBlock;

package/dist/create/create-media.d.ts

@@ -1,2 +1,7 @@
 import type { WriterInterface } from '../writers/writer';
-export declare const createMedia: (writer: WriterInterface) => Promise<() => Promise<void>>;
+export type MediaFn = {
+    save: () => Promise<void>;
+    addSample: (chunk: EncodedVideoChunk, trackNumber: number) => Promise<void>;
+    updateDuration: (duration: number) => Promise<void>;
+};
+export declare const createMedia: (writer: WriterInterface) => Promise<MediaFn>;

package/dist/create/create-media.js

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMedia = void 0;
+const ebml_1 = require("../boxes/webm/ebml");
+const make_header_1 = require("../boxes/webm/make-header");
+const all_segments_1 = require("../boxes/webm/segments/all-segments");
+const cluster_segment_1 = require("./cluster-segment");
 const matroska_header_1 = require("./matroska-header");
 const matroska_info_1 = require("./matroska-info");
 const matroska_segment_1 = require("./matroska-segment");
 const matroska_trackentry_1 = require("./matroska-trackentry");
 const createMedia = async (writer) => {
+    var _a, _b;
     const header = (0, matroska_header_1.makeMatroskaHeader)();
     const w = await writer.createContent();
-    await w.write(header);
+    await w.write(header.bytes);
     const matroskaInfo = (0, matroska_info_1.makeMatroskaInfo)({
         timescale: 1000000,
         duration: 2658,
@@ -28,9 +33,58 @@ const createMedia = async (writer) => {
     });
     const matroskaTracks = (0, matroska_trackentry_1.makeMatroskaTracks)([matroskaTrackEntry]);
     const matroskaSegment = (0, matroska_segment_1.createMatroskaSegment)([matroskaInfo, matroskaTracks]);
-    await w.write(matroskaSegment);
-    return async () => {
-        await w.save();
+    const durationOffset = ((_b = (_a = matroskaSegment.offsets.children[0].children.find((c) => c.field === 'Duration')) === null || _a === void 0 ? void 0 : _a.offset) !== null && _b !== void 0 ? _b : 0) + w.getWrittenByteCount();
+    if (!durationOffset) {
+        throw new Error('could not get duration offset');
+    }
+    await w.write(matroskaSegment.bytes);
+    const cluster = (0, cluster_segment_1.createClusterSegment)();
+    const clusterVIntPosition = w.getWrittenByteCount() +
+        cluster.offsets.offset +
+        (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Cluster).byteLength;
+    let clusterSize = cluster.bytes.byteLength;
+    await w.write(cluster.bytes);
+    const addSample = async (chunk, trackNumber) => {
+        const arr = new Uint8Array(chunk.byteLength);
+        chunk.copyTo(arr);
+        const simpleBlock = (0, cluster_segment_1.makeSimpleBlock)({
+            bytes: arr,
+            invisible: false,
+            keyframe: chunk.type === 'key',
+            lacing: 0,
+            trackNumber,
+            // TODO: Maybe this is bad, because it's in microseconds, but should be in timescale
+            // Maybe it only works by coincidence
+            timecodeRelativeToCluster: Math.round(chunk.timestamp / 1000),
+        });
+        clusterSize += simpleBlock.byteLength;
+        await w.updateDataAt(clusterVIntPosition, (0, ebml_1.getVariableInt)(clusterSize, cluster_segment_1.CLUSTER_MIN_VINT_WIDTH));
+        await w.write(simpleBlock);
+    };
+    const updateDuration = async (newDuration) => {
+        const blocks = (0, make_header_1.padMatroskaBytes)({
+            type: 'Duration',
+            value: {
+                value: newDuration,
+                size: '64',
+            },
+            minVintWidth: null,
+        }, 1000);
+        await w.updateDataAt(durationOffset, (0, make_header_1.combineUint8Arrays)(blocks.map((b) => b.bytes)));
+    };
+    let operationProm = Promise.resolve();
+    return {
+        save: async () => {
+            await w.save();
+        },
+        addSample: (chunk, trackNumber) => {
+            operationProm = operationProm.then(() => addSample(chunk, trackNumber));
+            return operationProm;
+        },
+        updateDuration: (duration) => {
+            operationProm = operationProm.then(() => updateDuration(duration));
+            return operationProm;
+        },
     };
 };
 exports.createMedia = createMedia;

package/dist/create/matroska-header.d.ts

@@ -1 +1 @@
-export declare const makeMatroskaHeader: () => Uint8Array;
+export declare const makeMatroskaHeader: () => import("../boxes/webm/segments/all-segments").BytesAndOffset;

package/dist/create/matroska-info.d.ts

@@ -1,4 +1,4 @@
 export declare const makeMatroskaInfo: ({ timescale, duration, }: {
     timescale: number;
     duration: number;
-}) => Uint8Array;
+}) => import("../boxes/webm/segments/all-segments").BytesAndOffset;

package/dist/create/matroska-info.js

@@ -24,14 +24,14 @@ const makeMatroskaInfo = ({ timescale, duration, }) => {
                 value: '@remotion/media-parser',
                 minVintWidth: null,
             },
-            {
+            ...(0, make_header_1.padMatroskaBytes)({
                 type: 'Duration',
                 value: {
                     value: duration,
                     size: '64',
                 },
                 minVintWidth: null,
-            },
+            }, 1000),
         ],
         minVintWidth: null,
     });

package/dist/create/matroska-segment.d.ts

@@ -1 +1,2 @@
-export declare const createMatroskaSegment: (children: Uint8Array[]) => Uint8Array;
+import type { BytesAndOffset } from '../boxes/webm/segments/all-segments';
+export declare const createMatroskaSegment: (children: BytesAndOffset[]) => BytesAndOffset;

package/dist/create/matroska-trackentry.d.ts

@@ -1,15 +1,16 @@
+import type { BytesAndOffset } from '../boxes/webm/segments/all-segments';
 export type MatroskaColorParams = {
     transferChracteristics: 'bt709' | 'smpte170m' | 'iec61966-2-1' | null;
     matrixCoefficients: 'bt709' | 'bt470bg' | 'rgb' | 'smpte170m' | null;
     primaries: 'bt709' | 'smpte170m' | 'bt470bg' | null;
     fullRange: boolean | null;
 };
-export declare const makeMatroskaColorBytes: ({ transferChracteristics, matrixCoefficients, primaries, fullRange, }: MatroskaColorParams) => Uint8Array;
+export declare const makeMatroskaColorBytes: ({ transferChracteristics, matrixCoefficients, primaries, fullRange, }: MatroskaColorParams) => BytesAndOffset;
 export declare const makeMatroskaVideoBytes: ({ color, width, height, }: {
     color: MatroskaColorParams;
     width: number;
     height: number;
-}) => Uint8Array;
+}) => BytesAndOffset;
 export declare const makeMatroskaVideoTrackEntryBytes: ({ color, width, height, defaultDuration, trackNumber, codecId, }: {
     color: MatroskaColorParams;
     width: number;
@@ -17,5 +18,5 @@ export declare const makeMatroskaVideoTrackEntryBytes: ({ color, width, height,
     defaultDuration: number;
     trackNumber: number;
     codecId: string;
-}) => Uint8Array;
-export declare const makeMatroskaTracks: (tracks: Uint8Array[]) => Uint8Array;
+}) => BytesAndOffset;
+export declare const makeMatroskaTracks: (tracks: BytesAndOffset[]) => BytesAndOffset;

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-duration.d.ts

@@ -1,3 +1,4 @@
 import type { AnySegment } from './parse-result';
-export declare const getDuration: (boxes: AnySegment[]) => number | null;
-export declare const hasDuration: (boxes: AnySegment[]) => boolean;
+import type { ParserState } from './parser-state';
+export declare const getDuration: (boxes: AnySegment[], parserState: ParserState) => number | null;
+export declare const hasDuration: (boxes: AnySegment[], parserState: ParserState) => boolean;

package/dist/get-duration.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasDuration = exports.getDuration = void 0;
+const get_sample_positions_from_track_1 = require("./boxes/iso-base-media/get-sample-positions-from-track");
+const get_tracks_1 = require("./get-tracks");
 const traversal_1 = require("./traversal");
 const getDurationFromMatroska = (segments) => {
     const mainSegment = segments.find((s) => s.type === 'Segment');
@@ -26,7 +28,7 @@ const getDurationFromMatroska = (segments) => {
     }
     return (duration.value.value / timestampScale.value.value) * 1000;
 };
-const getDuration = (boxes) => {
+const getDuration = (boxes, parserState) => {
     const matroskaBox = boxes.find((b) => b.type === 'Segment');
     if (matroskaBox) {
         return getDurationFromMatroska(boxes);
@@ -35,6 +37,7 @@ const getDuration = (boxes) => {
     if (!moovBox) {
         return null;
     }
+    const moofBox = (0, traversal_1.getMoofBox)(boxes);
     const mvhdBox = (0, traversal_1.getMvhdBox)(moovBox);
     if (!mvhdBox) {
         return null;
@@ -42,12 +45,29 @@ const getDuration = (boxes) => {
     if (mvhdBox.type !== 'mvhd-box') {
         throw new Error('Expected mvhd-box');
     }
-    return mvhdBox.durationInSeconds;
+    if (mvhdBox.durationInSeconds > 0) {
+        return mvhdBox.durationInSeconds;
+    }
+    const tracks = (0, get_tracks_1.getTracks)(boxes, parserState);
+    const allTracks = [
+        ...tracks.videoTracks,
+        ...tracks.audioTracks,
+        ...tracks.otherTracks,
+    ];
+    const allSamples = allTracks.map((t) => {
+        const { timescale: ts } = t;
+        const samplePositions = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)(t.trakBox, moofBox);
+        const highest = samplePositions === null || samplePositions === void 0 ? void 0 : samplePositions.map((sp) => (sp.cts + sp.duration) / ts).reduce((a, b) => Math.max(a, b), 0);
+        return highest !== null && highest !== void 0 ? highest : 0;
+    });
+    const highestTimestamp = Math.max(...allSamples);
+    return highestTimestamp;
 };
 exports.getDuration = getDuration;
-const hasDuration = (boxes) => {
+const hasDuration = (boxes, parserState) => {
     try {
-        return (0, exports.getDuration)(boxes) !== null;
+        const duration = (0, exports.getDuration)(boxes, parserState);
+        return (0, exports.getDuration)(boxes, parserState) !== null && duration !== 0;
     }
     catch (err) {
         return false;

package/dist/get-tracks.d.ts

@@ -1,5 +1,5 @@
 import type { MoovBox } from './boxes/iso-base-media/moov/moov';
-import type { SamplePosition } from './get-sample-positions';
+import type { TrakBox } from './boxes/iso-base-media/trak/trak';
 import type { AnySegment } from './parse-result';
 import type { ParserState } from './parser-state';
 type SampleAspectRatio = {
@@ -8,7 +8,6 @@ type SampleAspectRatio = {
 };
 export type VideoTrack = {
     type: 'video';
-    samplePositions: SamplePosition[] | null;
     trackId: number;
     description: Uint8Array | undefined;
     timescale: number;
@@ -21,22 +20,23 @@ export type VideoTrack = {
     codedWidth: number;
     codedHeight: number;
     rotation: number;
+    trakBox: TrakBox | null;
 };
 export type AudioTrack = {
     type: 'audio';
-    samplePositions: SamplePosition[] | null;
     trackId: number;
     timescale: number;
     codec: string;
     numberOfChannels: number;
     sampleRate: number;
     description: Uint8Array | undefined;
+    trakBox: TrakBox | null;
 };
 export type OtherTrack = {
     type: 'other';
-    samplePositions: SamplePosition[] | null;
     trackId: number;
     timescale: number;
+    trakBox: TrakBox | null;
 };
 export type Track = VideoTrack | AudioTrack | OtherTrack;
 export declare const getNumberOfTracks: (moovBox: MoovBox) => number;

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.js

@@ -16,7 +16,7 @@ const hasAllInfo = (options, parseResult, state) => {
             return parseResult.status === 'done';
         }
         if (key === 'durationInSeconds') {
-            return (0, get_duration_1.hasDuration)(parseResult.segments);
+            return (0, get_duration_1.hasDuration)(parseResult.segments, state);
         }
         if (key === 'dimensions' ||
             key === 'rotation' ||

package/dist/parse-media.js

@@ -100,7 +100,7 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
         returnValue.rotation = dimensions.rotation;
     }
     if (fields === null || fields === void 0 ? void 0 : fields.durationInSeconds) {
-        returnValue.durationInSeconds = (0, get_duration_1.getDuration)(parseResult.segments);
+        returnValue.durationInSeconds = (0, get_duration_1.getDuration)(parseResult.segments, state);
     }
     if (fields === null || fields === void 0 ? void 0 : fields.fps) {
         returnValue.fps = (0, get_fps_1.getFps)(parseResult.segments);