@remotion/media-parser 4.0.200 → 4.0.202

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;
+}) => Uint8Array;

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,
+            },
+            {
+                type: 'Duration',
+                value: {
+                    value: duration,
+                    size: '64',
+                },
+                minVintWidth: null,
+            },
+        ],
+        minVintWidth: null,
+    });
+};
+exports.makeMatroskaInfo = makeMatroskaInfo;

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

@@ -0,0 +1 @@
+export declare const createMatroskaSegment: (children: Uint8Array[]) => Uint8Array;

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

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/create-media.d.ts

@@ -0,0 +1 @@
+export declare const createMedia: () => Promise<void>;

package/dist/create-media.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMedia = void 0;
+const make_header_1 = require("./boxes/webm/make-header");
+const createMedia = async () => {
+    const header = (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,
+    });
+    const handle = await window.showSaveFilePicker({
+        suggestedName: 'out.webm',
+        types: [
+            {
+                description: 'WebM video',
+                accept: { 'video/webm': ['.webm'] },
+            },
+        ],
+    });
+    const writable = await handle.createWritable();
+    await writable.write(header);
+    writable.close();
+};
+exports.createMedia = createMedia;

package/dist/from-fetch.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchReader = void 0;
 exports.fetchReader = {
-    read: async (src, range) => {
+    read: async (src, range, signal) => {
         if (typeof src !== 'string') {
-            throw new Error('src must be a string when using `webReader`');
+            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()
@@ -24,20 +24,30 @@ exports.fetchReader = {
                     : {
                         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 `webReader`');
+            throw new Error('src must be a string when using `fetchReader`');
         }
         const res = await fetch(src, {
             method: 'HEAD',

package/dist/from-input-type-file.d.ts

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

package/dist/from-input-type-file.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputTypeFileReader = void 0;
+exports.inputTypeFileReader = {
+    read: (file, range) => {
+        if (typeof file === 'string') {
+            throw new Error('`inputTypeFileReader` only supports `File` objects');
+        }
+        if (range !== null) {
+            throw new Error('`inputTypeFileReader` does not support `range`');
+        }
+        const part = range === null
+            ? file
+            : typeof range === 'number'
+                ? file.slice(range)
+                : file.slice(range[0], range[1]);
+        const reader = new FileReader();
+        reader.readAsArrayBuffer(file);
+        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/from-node.js

@@ -5,7 +5,7 @@ const fs_1 = require("fs");
 const promises_1 = require("node:fs/promises");
 const stream_1 = require("stream");
 exports.nodeReader = {
-    read: async (src, range) => {
+    read: async (src, range, signal) => {
         if (typeof src !== 'string') {
             throw new Error('src must be a string when using `nodeReader`');
         }
@@ -16,10 +16,17 @@ exports.nodeReader = {
                 : 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: stream_1.Readable.toWeb(stream).getReader(),
+            reader,
             contentLength: stats.size,
         };
     },

package/dist/from-web-file.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webFileReader = void 0;
 exports.webFileReader = {
-    read: (file, range) => {
+    read: (file, range, signal) => {
         if (typeof file === 'string') {
             throw new Error('`inputTypeFileReader` only supports `File` objects');
         }
@@ -13,6 +13,11 @@ exports.webFileReader = {
                 : 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({

package/dist/from-web.js

@@ -3,6 +3,9 @@ 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;
@@ -14,22 +17,28 @@ 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 };
     },
     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-audio-codec.d.ts

@@ -1,6 +1,6 @@
 import type { MoovBox } from './boxes/iso-base-media/moov/moov';
 import type { TrakBox } from './boxes/iso-base-media/trak/trak';
-import type { MainSegment } from './boxes/webm/segments/main';
+import type { MainSegment } from './boxes/webm/segments/all-segments';
 import type { KnownAudioCodecs } from './options';
 import type { AnySegment } from './parse-result';
 export declare const hasAudioCodec: (boxes: AnySegment[]) => boolean;
@@ -14,7 +14,7 @@ export declare const getNumberOfChannelsFromTrak: (trak: TrakBox) => number | nu
 export declare const getSampleRate: (trak: TrakBox) => number | null;
 export declare const getAudioCodecFromTrak: (trak: TrakBox) => AudioCodecInfo | null;
 export declare const getAudioCodecFromIso: (moov: MoovBox) => AudioCodecInfo | null;
-export declare const getAudioCodecFromMatroska: (mainSegment: MainSegment) => "vorbis" | "opus" | "mp3" | "aac" | "pcm" | null;
+export declare const getAudioCodecFromMatroska: (mainSegment: MainSegment) => "aac" | "mp3" | "opus" | "pcm" | "vorbis" | null;
 export declare const getAudioCodecStringFromTrak: (trak: TrakBox) => {
     codecString: string;
     description: Uint8Array | undefined;

package/dist/get-audio-codec.js

@@ -115,27 +115,27 @@ const getAudioCodecFromIso = (moov) => {
 };
 exports.getAudioCodecFromIso = getAudioCodecFromIso;
 const getAudioCodecFromMatroska = (mainSegment) => {
-    const tracksSegment = mainSegment.children.find((b) => b.type === 'tracks-segment');
-    if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+    const tracksSegment = mainSegment.value.find((b) => b.type === 'Tracks');
+    if (!tracksSegment || tracksSegment.type !== 'Tracks') {
         return null;
     }
-    for (const track of tracksSegment.children) {
-        if (track.type === 'track-entry-segment') {
-            const trackType = track.children.find((b) => b.type === 'codec-segment');
-            if (trackType && trackType.type === 'codec-segment') {
-                if (trackType.codec === 'A_OPUS') {
+    for (const track of tracksSegment.value) {
+        if (track.type === 'TrackEntry') {
+            const trackType = track.value.find((b) => b.type === 'CodecID');
+            if (trackType && trackType.type === 'CodecID') {
+                if (trackType.value === 'A_OPUS') {
                     return 'opus';
                 }
-                if (trackType.codec === 'A_VORBIS') {
+                if (trackType.value === 'A_VORBIS') {
                     return 'vorbis';
                 }
-                if (trackType.codec === 'A_PCM/INT/LIT') {
+                if (trackType.value === 'A_PCM/INT/LIT') {
                     return 'pcm';
                 }
-                if (trackType.codec === 'A_AAC') {
+                if (trackType.value === 'A_AAC') {
                     return 'aac';
                 }
-                if (trackType.codec === 'A_MPEG/L3') {
+                if (trackType.value === 'A_MPEG/L3') {
                     return 'mp3';
                 }
             }
@@ -190,8 +190,8 @@ const getAudioCodec = (boxes) => {
         }
         throw new Error('Unknown audio format: ' + codec.format);
     }
-    const mainSegment = boxes.find((b) => b.type === 'main-segment');
-    if (!mainSegment || mainSegment.type !== 'main-segment') {
+    const mainSegment = boxes.find((b) => b.type === 'Segment');
+    if (!mainSegment || mainSegment.type !== 'Segment') {
         return null;
     }
     return (0, exports.getAudioCodecFromMatroska)(mainSegment);

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;