@remotion/media-parser 4.0.204 → 4.0.205

package/dist/create/matroska-header.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMatroskaHeader = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const makeMatroskaHeader = () => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Header',
+        value: [
+            {
+                minVintWidth: null,
+                type: 'EBMLVersion',
+                value: {
+                    value: 1,
+                    byteLength: null,
+                },
+            },
+            {
+                minVintWidth: null,
+                type: 'EBMLReadVersion',
+                value: {
+                    value: 1,
+                    byteLength: null,
+                },
+            },
+            {
+                type: 'EBMLMaxIDLength',
+                value: {
+                    byteLength: null,
+                    value: 4,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'EBMLMaxSizeLength',
+                value: {
+                    byteLength: null,
+                    value: 8,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'DocType',
+                value: 'webm',
+                minVintWidth: null,
+            },
+            {
+                type: 'DocTypeVersion',
+                value: {
+                    byteLength: null,
+                    value: 4,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'DocTypeReadVersion',
+                value: {
+                    byteLength: null,
+                    value: 2,
+                },
+                minVintWidth: null,
+            },
+        ],
+        minVintWidth: null,
+    });
+};
+exports.makeMatroskaHeader = makeMatroskaHeader;

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

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

package/dist/create/matroska-info.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMatroskaInfo = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const makeMatroskaInfo = ({ timescale, duration, }) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Info',
+        value: [
+            {
+                type: 'TimestampScale',
+                value: {
+                    value: timescale,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'MuxingApp',
+                value: '@remotion/media-parser',
+                minVintWidth: null,
+            },
+            {
+                type: 'WritingApp',
+                value: '@remotion/media-parser',
+                minVintWidth: null,
+            },
+            ...(0, make_header_1.padMatroskaBytes)({
+                type: 'Duration',
+                value: {
+                    value: duration,
+                    size: '64',
+                },
+                minVintWidth: null,
+            }, 1000),
+        ],
+        minVintWidth: null,
+    });
+};
+exports.makeMatroskaInfo = makeMatroskaInfo;

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

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

package/dist/create/matroska-segment.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMatroskaSegment = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const createMatroskaSegment = (children) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Segment',
+        value: children,
+        minVintWidth: 8,
+    });
+};
+exports.createMatroskaSegment = createMatroskaSegment;

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

@@ -0,0 +1,22 @@
+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) => BytesAndOffset;
+export declare const makeMatroskaVideoBytes: ({ color, width, height, }: {
+    color: MatroskaColorParams;
+    width: number;
+    height: number;
+}) => BytesAndOffset;
+export declare const makeMatroskaVideoTrackEntryBytes: ({ color, width, height, defaultDuration, trackNumber, codecId, }: {
+    color: MatroskaColorParams;
+    width: number;
+    height: number;
+    defaultDuration: number;
+    trackNumber: number;
+    codecId: string;
+}) => BytesAndOffset;
+export declare const makeMatroskaTracks: (tracks: BytesAndOffset[]) => BytesAndOffset;

package/dist/create/matroska-trackentry.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMatroskaTracks = exports.makeMatroskaVideoTrackEntryBytes = exports.makeMatroskaVideoBytes = exports.makeMatroskaColorBytes = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const makeMatroskaColorBytes = ({ transferChracteristics, matrixCoefficients, primaries, fullRange, }) => {
+    const rangeValue = transferChracteristics && matrixCoefficients
+        ? 3
+        : fullRange === true
+            ? 2
+            : fullRange === false
+                ? 1
+                : 0;
+    // https://datatracker.ietf.org/doc/draft-ietf-cellar-matroska/
+    // 5.1.4.1.28.27
+    const primariesValue = primaries === 'bt709'
+        ? 1
+        : primaries === 'smpte170m'
+            ? 6
+            : primaries === 'bt470bg'
+                ? 5
+                : 2;
+    const transferChracteristicsValue = transferChracteristics === 'bt709'
+        ? 1
+        : transferChracteristics === 'smpte170m'
+            ? 6
+            : transferChracteristics === 'iec61966-2-1'
+                ? 13
+                : 2;
+    if (matrixCoefficients === 'rgb') {
+        throw new Error('Cannot encode Matroska in RGB');
+    }
+    const matrixCoefficientsValue = matrixCoefficients === 'bt709'
+        ? 1
+        : matrixCoefficients === 'bt470bg'
+            ? 5
+            : matrixCoefficients === 'smpte170m'
+                ? 6
+                : 2;
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Colour',
+        minVintWidth: null,
+        value: [
+            {
+                type: 'TransferCharacteristics',
+                value: {
+                    value: transferChracteristicsValue,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'MatrixCoefficients',
+                value: {
+                    value: matrixCoefficientsValue,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'Primaries',
+                value: {
+                    value: primariesValue,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'Range',
+                value: {
+                    value: rangeValue,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+        ],
+    });
+};
+exports.makeMatroskaColorBytes = makeMatroskaColorBytes;
+const makeMatroskaVideoBytes = ({ color, width, height, }) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Video',
+        value: [
+            {
+                type: 'PixelWidth',
+                value: {
+                    value: width,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'PixelHeight',
+                value: {
+                    value: height,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'FlagInterlaced',
+                value: {
+                    // https://datatracker.ietf.org/doc/draft-ietf-cellar-matroska/
+                    // 5.1.4.1.28.1.
+                    value: 2, // 2 - progressive, no interlaced
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            (0, exports.makeMatroskaColorBytes)(color),
+        ],
+        minVintWidth: null,
+    });
+};
+exports.makeMatroskaVideoBytes = makeMatroskaVideoBytes;
+const makeMatroskaVideoTrackEntryBytes = ({ color, width, height, defaultDuration, trackNumber, codecId, }) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'TrackEntry',
+        minVintWidth: null,
+        value: [
+            {
+                type: 'TrackNumber',
+                value: {
+                    value: trackNumber,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'TrackUID',
+                value: '0xab2171012bb9020a',
+                minVintWidth: null,
+            },
+            {
+                type: 'FlagLacing',
+                value: {
+                    value: 0,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'Language',
+                value: 'und',
+                minVintWidth: null,
+            },
+            {
+                type: 'FlagDefault',
+                value: {
+                    value: 0,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'CodecID',
+                value: codecId,
+                minVintWidth: null,
+            },
+            {
+                type: 'TrackType',
+                value: {
+                    value: 1, // 'video'
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            {
+                type: 'DefaultDuration',
+                value: {
+                    value: defaultDuration,
+                    byteLength: null,
+                },
+                minVintWidth: null,
+            },
+            (0, exports.makeMatroskaVideoBytes)({
+                color,
+                width,
+                height,
+            }),
+        ],
+    });
+};
+exports.makeMatroskaVideoTrackEntryBytes = makeMatroskaVideoTrackEntryBytes;
+const makeMatroskaTracks = (tracks) => {
+    return (0, make_header_1.makeMatroskaBytes)({
+        type: 'Tracks',
+        value: tracks,
+        minVintWidth: null,
+    });
+};
+exports.makeMatroskaTracks = makeMatroskaTracks;

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

package/dist/parse-result.d.ts

@@ -19,8 +19,11 @@ import type { StsdBox } from './boxes/iso-base-media/stsd/stsd';
 import type { StssBox } from './boxes/iso-base-media/stsd/stss';
 import type { StszBox } from './boxes/iso-base-media/stsd/stsz';
 import type { SttsBox } from './boxes/iso-base-media/stsd/stts';
+import type { TfdtBox } from './boxes/iso-base-media/tfdt';
+import type { TfhdBox } from './boxes/iso-base-media/tfhd';
 import type { TkhdBox } from './boxes/iso-base-media/tkhd';
 import type { TrakBox } from './boxes/iso-base-media/trak/trak';
+import type { TrunBox } from './boxes/iso-base-media/trun';
 import type { VoidBox } from './boxes/iso-base-media/void-box';
 import type { MatroskaSegment } from './boxes/webm/segments';
 export interface RegularBox extends BaseBox {
@@ -30,7 +33,7 @@ export interface RegularBox extends BaseBox {
     offset: number;
     type: 'regular-box';
 }
-export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | EsdsBox | MdatBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | ColorParameterBox;
+export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | EsdsBox | MdatBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | ColorParameterBox | TfdtBox | TfhdBox;
 export type AnySegment = MatroskaSegment | IsoBaseMediaBox;
 export type ParseResult = {
     status: 'done';

package/dist/readers/from-fetch.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const fetchReader: ReaderInterface;

package/dist/readers/from-fetch.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchReader = void 0;
+exports.fetchReader = {
+    read: async (src, range, signal) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `fetchReader`');
+        }
+        const resolvedUrl = typeof window !== 'undefined' && typeof window.location !== 'undefined'
+            ? new URL(src, window.location.origin).toString()
+            : src;
+        if (!resolvedUrl.startsWith('https://') &&
+            !resolvedUrl.startsWith('http://')) {
+            return Promise.reject(new Error(resolvedUrl +
+                ' is not a URL - needs to start with http:// or https://. If you want to read a local file, pass `nodeReader` to parseMedia().'));
+        }
+        const res = await fetch(resolvedUrl, {
+            headers: range === null
+                ? {}
+                : typeof range === 'number'
+                    ? {
+                        Range: `bytes=${range}`,
+                    }
+                    : {
+                        Range: `bytes=${`${range[0]}-${range[1]}`}`,
+                    },
+            signal,
+            // Disable Next.js caching
+            cache: 'no-store',
+        });
+        if (res.status.toString().startsWith('4') ||
+            res.status.toString().startsWith('5')) {
+            throw new Error(`Server returned status code ${res.status} for ${src}`);
+        }
+        if (!res.body) {
+            throw new Error('No body');
+        }
+        const length = res.headers.get('content-length');
+        const contentLength = length === null ? null : parseInt(length, 10);
+        const reader = res.body.getReader();
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                reader.cancel();
+            }, { once: true });
+        }
+        return { reader, contentLength };
+    },
+    getLength: async (src) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `fetchReader`');
+        }
+        const res = await fetch(src, {
+            method: 'HEAD',
+        });
+        if (!res.body) {
+            throw new Error('No body');
+        }
+        const length = res.headers.get('content-length');
+        if (!length) {
+            throw new Error('No content-length');
+        }
+        return parseInt(length, 10);
+    },
+};

package/dist/readers/from-node.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const nodeReader: ReaderInterface;

package/dist/readers/from-node.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeReader = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("node:fs/promises");
+const stream_1 = require("stream");
+exports.nodeReader = {
+    read: async (src, range, signal) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `nodeReader`');
+        }
+        const stream = (0, fs_1.createReadStream)(src, {
+            start: range === null ? 0 : typeof range === 'number' ? range : range[0],
+            end: range === null
+                ? Infinity
+                : typeof range === 'number'
+                    ? Infinity
+                    : range[1],
+            signal,
+        });
+        const stats = await (0, promises_1.stat)(src);
+        const reader = stream_1.Readable.toWeb(stream).getReader();
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                reader.cancel();
+            }, { once: true });
+        }
+        return {
+            reader,
+            contentLength: stats.size,
+        };
+    },
+    getLength: async (src) => {
+        if (typeof src !== 'string') {
+            throw new Error('src must be a string when using `nodeReader`');
+        }
+        const stats = await (0, promises_1.stat)(src);
+        return stats.size;
+    },
+};

package/dist/readers/from-web-file.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const webFileReader: ReaderInterface;

package/dist/readers/from-web-file.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFileReader = void 0;
+exports.webFileReader = {
+    read: (file, range, signal) => {
+        if (typeof file === 'string') {
+            throw new Error('`inputTypeFileReader` only supports `File` objects');
+        }
+        const part = range === null
+            ? file
+            : typeof range === 'number'
+                ? file.slice(range)
+                : file.slice(range[0], range[1]);
+        const reader = new FileReader();
+        reader.readAsArrayBuffer(file);
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                reader.abort();
+            }, { once: true });
+        }
+        return new Promise((resolve, reject) => {
+            reader.onload = () => {
+                resolve({
+                    reader: part.stream().getReader(),
+                    contentLength: file.size,
+                });
+            };
+            reader.onerror = (error) => {
+                reject(error);
+            };
+        });
+    },
+    getLength: (src) => {
+        if (typeof src === 'string') {
+            throw new Error('`inputTypeFileReader` only supports `File` objects');
+        }
+        return Promise.resolve(src.size);
+    },
+};

package/dist/readers/reader.d.ts

@@ -0,0 +1,11 @@
+type ReadResult = {
+    reader: ReadableStreamDefaultReader<Uint8Array>;
+    contentLength: number | null;
+};
+type ReadContent = (src: string | File, range: [number, number] | number | null, signal: AbortSignal | undefined) => Promise<ReadResult>;
+type GetLength = (src: string | File) => Promise<number>;
+export type ReaderInterface = {
+    read: ReadContent;
+    getLength: GetLength;
+};
+export {};

package/dist/readers/reader.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });