@remotion/media-parser 4.0.194 → 4.0.196

package/dist/from-fetch.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchReader = void 0;
+exports.fetchReader = {
+    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;
+        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]}`}`,
+                    },
+            // Disable Next.js caching
+            cache: 'no-store',
+        });
+        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();
+        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',
+        });
+        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/from-node.js

@@ -6,6 +6,9 @@ const promises_1 = require("node:fs/promises");
 const stream_1 = require("stream");
 exports.nodeReader = {
     read: async (src, range) => {
+        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
@@ -21,6 +24,9 @@ exports.nodeReader = {
         };
     },
     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/from-web-file.d.ts

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

package/dist/from-web-file.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webFileReader = void 0;
+exports.webFileReader = {
+    read: (file, range) => {
+        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);
+        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-web.js

@@ -14,20 +14,17 @@ 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 };

package/dist/get-audio-codec.d.ts

@@ -1,4 +1,23 @@
+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 { KnownAudioCodecs } from './options';
 import type { AnySegment } from './parse-result';
 export declare const hasAudioCodec: (boxes: AnySegment[]) => boolean;
+type AudioCodecInfo = {
+    format: string;
+    primarySpecificator: number | null;
+    secondarySpecificator: number | null;
+    description: Uint8Array | undefined;
+};
+export declare const getNumberOfChannelsFromTrak: (trak: TrakBox) => number | null;
+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) => "opus" | "vorbis" | "mp3" | "aac" | "pcm" | null;
+export declare const getAudioCodecStringFromTrak: (trak: TrakBox) => {
+    codecString: string;
+    description: Uint8Array | undefined;
+};
 export declare const getAudioCodec: (boxes: AnySegment[]) => KnownAudioCodecs | null;
+export {};

package/dist/get-audio-codec.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAudioCodec = exports.hasAudioCodec = void 0;
+exports.getAudioCodec = exports.getAudioCodecStringFromTrak = exports.getAudioCodecFromMatroska = exports.getAudioCodecFromIso = exports.getAudioCodecFromTrak = exports.getSampleRate = exports.getNumberOfChannelsFromTrak = exports.hasAudioCodec = void 0;
 const get_fps_1 = require("./get-fps");
+const traversal_1 = require("./traversal");
 const hasAudioCodec = (boxes) => {
     try {
         return (0, exports.getAudioCodec)(boxes) !== null;
@@ -11,79 +12,109 @@ const hasAudioCodec = (boxes) => {
     }
 };
 exports.hasAudioCodec = hasAudioCodec;
-const onEsdsBox = (child) => {
+const getCodecSpecificatorFromEsdsBox = ({ child, }) => {
+    const descriptor = child.descriptors.find((d) => d.type === 'decoder-config-descriptor');
+    if (!descriptor) {
+        throw new Error('No decoder-config-descriptor');
+    }
+    if (descriptor.type !== 'decoder-config-descriptor') {
+        throw new Error('Expected decoder-config-descriptor');
+    }
+    if (descriptor.asNumber !== 0x40) {
+        return {
+            primary: descriptor.asNumber,
+            secondary: null,
+            description: undefined,
+        };
+    }
+    const audioSpecificConfig = descriptor.decoderSpecificConfigs.find((d) => {
+        return d.type === 'audio-specific-config' ? d : null;
+    });
+    if (!audioSpecificConfig ||
+        audioSpecificConfig.type !== 'audio-specific-config') {
+        throw new Error('No audio-specific-config');
+    }
+    return {
+        primary: descriptor.asNumber,
+        secondary: audioSpecificConfig.audioObjectType,
+        description: audioSpecificConfig.asBytes,
+    };
+};
+const onSample = (sample, children) => {
+    const child = children.find((c) => c.type === 'esds-box');
     if (child && child.type === 'esds-box') {
-        const descriptor = child.descriptors.find((d) => d.type === 'decoder-config-descriptor');
-        if (descriptor && descriptor.type === 'decoder-config-descriptor') {
-            return descriptor.objectTypeIndication;
-        }
+        const ret = getCodecSpecificatorFromEsdsBox({ child });
+        return {
+            format: sample.format,
+            primarySpecificator: ret.primary,
+            secondarySpecificator: ret.secondary,
+            description: ret.description,
+        };
     }
-    return null;
+    return {
+        format: sample.format,
+        primarySpecificator: null,
+        secondarySpecificator: null,
+        description: undefined,
+    };
 };
-const onSample = (sample) => {
-    if (!sample) {
+const getNumberOfChannelsFromTrak = (trak) => {
+    const stsdBox = (0, traversal_1.getStsdBox)(trak);
+    if (!stsdBox) {
         return null;
     }
-    if (sample.type !== 'audio') {
+    const sample = stsdBox.samples.find((s) => s.type === 'audio');
+    if (!sample || sample.type !== 'audio') {
         return null;
     }
-    if (sample.format === 'sowt') {
-        return 'aiff';
+    return sample.numberOfChannels;
+};
+exports.getNumberOfChannelsFromTrak = getNumberOfChannelsFromTrak;
+const getSampleRate = (trak) => {
+    const stsdBox = (0, traversal_1.getStsdBox)(trak);
+    if (!stsdBox) {
+        return null;
     }
-    const child = sample.children.find((c) => c.type === 'esds-box');
-    if (child && child.type === 'esds-box') {
-        const ret = onEsdsBox(child);
-        if (ret) {
-            return ret;
-        }
+    const sample = stsdBox.samples.find((s) => s.type === 'audio');
+    if (!sample || sample.type !== 'audio') {
+        return null;
     }
+    return sample.sampleRate;
 };
-const getAudioCodec = (boxes) => {
-    const moovBox = boxes.find((b) => b.type === 'moov-box');
-    if (moovBox && moovBox.type === 'moov-box') {
-        const trakBox = moovBox.children.find((b) => b.type === 'trak-box' && (0, get_fps_1.trakBoxContainsAudio)(b));
-        if (trakBox && trakBox.type === 'trak-box') {
-            const mdiaBox = trakBox.children.find((b) => b.type === 'regular-box' && b.boxType === 'mdia');
-            if (mdiaBox &&
-                mdiaBox.type === 'regular-box' &&
-                mdiaBox.boxType === 'mdia') {
-                const minfBox = mdiaBox === null || mdiaBox === void 0 ? void 0 : mdiaBox.children.find((b) => b.type === 'regular-box' && b.boxType === 'minf');
-                if (minfBox &&
-                    minfBox.type === 'regular-box' &&
-                    minfBox.boxType === 'minf') {
-                    const stblBox = minfBox === null || minfBox === void 0 ? void 0 : minfBox.children.find((b) => b.type === 'regular-box' && b.boxType === 'stbl');
-                    if (stblBox && stblBox.type === 'regular-box') {
-                        const stsdBox = stblBox === null || stblBox === void 0 ? void 0 : stblBox.children.find((b) => b.type === 'stsd-box');
-                        if (stsdBox && stsdBox.type === 'stsd-box') {
-                            const sample = stsdBox.samples.find((s) => s.type === 'audio');
-                            if (sample && sample.type === 'audio') {
-                                const ret = onSample(sample);
-                                if (ret) {
-                                    return ret;
-                                }
-                                const waveBox = sample.children.find((b) => b.type === 'regular-box' && b.boxType === 'wave');
-                                if (waveBox &&
-                                    waveBox.type === 'regular-box' &&
-                                    waveBox.boxType === 'wave') {
-                                    const esdsBox = waveBox.children.find((b) => b.type === 'esds-box');
-                                    if (esdsBox && esdsBox.type === 'esds-box') {
-                                        const ret2 = onEsdsBox(esdsBox);
-                                        if (ret2) {
-                                            return ret2;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+exports.getSampleRate = getSampleRate;
+const getAudioCodecFromTrak = (trak) => {
+    const stsdBox = (0, traversal_1.getStsdBox)(trak);
+    if (!stsdBox) {
+        return null;
+    }
+    const sample = stsdBox.samples.find((s) => s.type === 'audio');
+    if (!sample || sample.type !== 'audio') {
+        return null;
+    }
+    const waveBox = sample.children.find((b) => b.type === 'regular-box' && b.boxType === 'wave');
+    if (waveBox && waveBox.type === 'regular-box' && waveBox.boxType === 'wave') {
+        const esdsSample = onSample(sample, waveBox.children);
+        if (esdsSample) {
+            return esdsSample;
         }
     }
-    const mainSegment = boxes.find((b) => b.type === 'main-segment');
-    if (!mainSegment || mainSegment.type !== 'main-segment') {
+    const ret = onSample(sample, sample.children);
+    if (ret) {
+        return ret;
+    }
+    return null;
+};
+exports.getAudioCodecFromTrak = getAudioCodecFromTrak;
+const getAudioCodecFromIso = (moov) => {
+    const traks = (0, traversal_1.getTraks)(moov);
+    const trakBox = traks.find((b) => b.type === 'trak-box' && (0, get_fps_1.trakBoxContainsAudio)(b));
+    if (!trakBox) {
         return null;
     }
+    return (0, exports.getAudioCodecFromTrak)(trakBox);
+};
+exports.getAudioCodecFromIso = getAudioCodecFromIso;
+const getAudioCodecFromMatroska = (mainSegment) => {
     const tracksSegment = mainSegment.children.find((b) => b.type === 'tracks-segment');
     if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
         return null;
@@ -95,12 +126,74 @@ const getAudioCodec = (boxes) => {
                 if (trackType.codec === 'A_OPUS') {
                     return 'opus';
                 }
+                if (trackType.codec === 'A_VORBIS') {
+                    return 'vorbis';
+                }
                 if (trackType.codec === 'A_PCM/INT/LIT') {
                     return 'pcm';
                 }
+                if (trackType.codec === 'A_AAC') {
+                    return 'aac';
+                }
+                if (trackType.codec === 'A_MPEG/L3') {
+                    return 'mp3';
+                }
             }
         }
     }
     return null;
 };
+exports.getAudioCodecFromMatroska = getAudioCodecFromMatroska;
+const getAudioCodecStringFromTrak = (trak) => {
+    const codec = (0, exports.getAudioCodecFromTrak)(trak);
+    if (!codec) {
+        throw new Error('Expected codec');
+    }
+    const codecStringWithoutMp3Exception = [
+        codec.format,
+        codec.primarySpecificator ? codec.primarySpecificator.toString(16) : null,
+        codec.secondarySpecificator
+            ? codec.secondarySpecificator.toString().padStart(2, '0')
+            : null,
+    ].filter(Boolean).join('.');
+    // Really, MP3? 😔
+    const codecString = codecStringWithoutMp3Exception === 'mp4a.6b'
+        ? 'mp3' // or "mp4a.6B" would also work, with the uppercasing, but mp3 is probably more obvious
+        : codecStringWithoutMp3Exception;
+    return {
+        codecString,
+        description: codec.description,
+    };
+};
+exports.getAudioCodecStringFromTrak = getAudioCodecStringFromTrak;
+const getAudioCodec = (boxes) => {
+    const moovBox = (0, traversal_1.getMoovBox)(boxes);
+    if (moovBox) {
+        const codec = (0, exports.getAudioCodecFromIso)(moovBox);
+        if (!codec) {
+            return null;
+        }
+        if (codec.format === 'sowt') {
+            return 'aiff';
+        }
+        if (codec.format === 'mp4a') {
+            if (codec.primarySpecificator === 0x40) {
+                return 'aac';
+            }
+            if (codec.primarySpecificator === 0x6b) {
+                return 'mp3';
+            }
+            if (codec.primarySpecificator === null) {
+                return 'aac';
+            }
+            throw new Error('Unknown mp4a codec: ' + codec.primarySpecificator);
+        }
+        throw new Error('Unknown audio format: ' + codec.format);
+    }
+    const mainSegment = boxes.find((b) => b.type === 'main-segment');
+    if (!mainSegment || mainSegment.type !== 'main-segment') {
+        return null;
+    }
+    return (0, exports.getAudioCodecFromMatroska)(mainSegment);
+};
 exports.getAudioCodec = getAudioCodec;

package/dist/get-dimensions.d.ts

@@ -1,7 +1,13 @@
 import type { AnySegment } from './parse-result';
+import type { ParserState } from './parser-state';
 export type Dimensions = {
     width: number;
     height: number;
 };
-export declare const getDimensions: (boxes: AnySegment[]) => Dimensions;
-export declare const hasDimensions: (boxes: AnySegment[]) => boolean;
+export type ExpandedDimensions = Dimensions & {
+    rotation: number;
+    unrotatedWidth: number;
+    unrotatedHeight: number;
+};
+export declare const getDimensions: (boxes: AnySegment[], state: ParserState) => ExpandedDimensions;
+export declare const hasDimensions: (boxes: AnySegment[], state: ParserState) => boolean;

package/dist/get-dimensions.js

@@ -1,105 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasDimensions = exports.getDimensions = void 0;
-const getDimensionsFromMatroska = (segments) => {
-    const tracksSegment = segments.children.find((b) => b.type === 'tracks-segment');
-    if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
-        throw new Error('No tracks segment');
-    }
-    const trackEntrySegment = tracksSegment.children.find((b) => {
-        if (b.type !== 'track-entry-segment') {
-            return false;
-        }
-        return (b.children.find((c) => c.type === 'codec-segment' && c.codec.startsWith('V_')) !== undefined);
-    });
-    if (!trackEntrySegment || trackEntrySegment.type !== 'track-entry-segment') {
-        throw new Error('No track entry segment');
-    }
-    const videoSegment = trackEntrySegment.children.find((b) => b.type === 'video-segment');
-    if (!videoSegment || videoSegment.type !== 'video-segment') {
-        throw new Error('No video segment');
-    }
-    const widthSegment = videoSegment.children.find((b) => b.type === 'width-segment');
-    if (!widthSegment || widthSegment.type !== 'width-segment') {
-        throw new Error('No width segment');
-    }
-    const heightSegment = videoSegment.children.find((b) => b.type === 'height-segment');
-    if (!heightSegment || heightSegment.type !== 'height-segment') {
-        throw new Error('No height segment');
+const get_tracks_1 = require("./get-tracks");
+const getDimensions = (boxes, state) => {
+    const { videoTracks } = (0, get_tracks_1.getTracks)(boxes, state);
+    if (!videoTracks.length) {
+        throw new Error('Expected video track');
     }
+    const firstVideoTrack = videoTracks[0];
     return {
-        width: widthSegment.width,
-        height: heightSegment.height,
+        width: firstVideoTrack.width,
+        height: firstVideoTrack.height,
+        rotation: firstVideoTrack.rotation,
+        unrotatedHeight: firstVideoTrack.displayAspectHeight,
+        unrotatedWidth: firstVideoTrack.displayAspectWidth,
     };
 };
-const getDimensions = (boxes) => {
-    const matroskaBox = boxes.find((b) => b.type === 'main-segment');
-    if (matroskaBox && matroskaBox.type === 'main-segment') {
-        return getDimensionsFromMatroska(matroskaBox);
-    }
-    const moovBox = boxes.find((b) => b.type === 'moov-box');
-    if (!moovBox || moovBox.type !== 'moov-box') {
-        throw new Error('Expected moov box');
-    }
-    const { children } = moovBox;
-    if (!children) {
-        throw new Error('Expected moov box children');
-    }
-    const t = children.find((b) => b.type === 'trak-box');
-    if (!t || t.type !== 'trak-box') {
-        throw new Error('Expected trak box');
-    }
-    const mdiaBox = t.children.find((c) => c.type === 'regular-box' && c.boxType === 'mdia');
-    const tkhdBox = t.children.find((c) => c.type === 'tkhd-box');
-    if (tkhdBox && tkhdBox.type === 'tkhd-box') {
-        return {
-            width: tkhdBox.width,
-            height: tkhdBox.height,
-        };
-    }
-    if (!mdiaBox) {
-        throw new Error('Expected mdia box');
-    }
-    if (mdiaBox.type !== 'regular-box') {
-        throw new Error('Expected mdia box');
-    }
-    const minfBox = mdiaBox.children.find((c) => c.type === 'regular-box' && c.boxType === 'minf');
-    if (!minfBox) {
-        throw new Error('Expected minf box');
-    }
-    if (minfBox.type !== 'regular-box') {
-        throw new Error('Expected minf box');
-    }
-    const stblBox = minfBox.children.find((c) => c.type === 'regular-box' && c.boxType === 'stbl');
-    if (!stblBox) {
-        throw new Error('Expected stbl box');
-    }
-    if (stblBox.type !== 'regular-box') {
-        throw new Error('Expected stbl box');
-    }
-    const stsdBox = stblBox.children.find((c) => c.type === 'stsd-box');
-    if (!stsdBox) {
-        throw new Error('Expected stsd box');
-    }
-    if (stsdBox.type !== 'stsd-box') {
-        throw new Error('Expected stsd box');
-    }
-    const videoSamples = stsdBox.samples.filter((s) => s.type === 'video');
-    if (videoSamples.length === 0) {
-        throw new Error('Has no video stream');
-    }
-    const [firstTrack] = videoSamples;
-    if (firstTrack.type !== 'video') {
-        throw new Error('Expected video track');
-    }
-    return { width: firstTrack.width, height: firstTrack.height };
-};
 exports.getDimensions = getDimensions;
 // TODO: An audio track should return 'hasDimensions' = true on an audio file
 // and stop parsing
-const hasDimensions = (boxes) => {
+const hasDimensions = (boxes, state) => {
     try {
-        return (0, exports.getDimensions)(boxes) !== null;
+        return (0, exports.getDimensions)(boxes, state) !== null;
     }
     catch (err) {
         return false;

package/dist/get-duration.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasDuration = exports.getDuration = void 0;
+const traversal_1 = require("./traversal");
 const getDurationFromMatroska = (segments) => {
     const mainSegment = segments.find((s) => s.type === 'main-segment');
     if (!mainSegment || mainSegment.type !== 'main-segment') {
@@ -32,15 +33,11 @@ const getDuration = (boxes) => {
     if (matroskaBox) {
         return getDurationFromMatroska(boxes);
     }
-    const moovBox = boxes.find((b) => b.type === 'moov-box');
-    if (!moovBox || moovBox.type !== 'moov-box') {
+    const moovBox = (0, traversal_1.getMoovBox)(boxes);
+    if (!moovBox) {
         return null;
     }
-    const { children } = moovBox;
-    if (!children) {
-        return null;
-    }
-    const mvhdBox = children.find((b) => b.type === 'mvhd-box');
+    const mvhdBox = (0, traversal_1.getMvhdBox)(moovBox);
     if (!mvhdBox) {
         return null;
     }

package/dist/get-fps.d.ts

@@ -1,11 +1,12 @@
+import type { TrakBox } from './boxes/iso-base-media/trak/trak';
 import type { AnySegment } from './parse-result';
 type TimescaleAndDuration = {
     timescale: number;
     duration: number;
 };
-export declare const trakBoxContainsAudio: (trakBox: AnySegment) => boolean;
-export declare const trakBoxContainsVideo: (trakBox: AnySegment) => boolean;
-export declare const getTimescaleAndDuration: (boxes: AnySegment[]) => TimescaleAndDuration | null;
+export declare const trakBoxContainsAudio: (trakBox: TrakBox) => boolean;
+export declare const trakBoxContainsVideo: (trakBox: TrakBox) => boolean;
+export declare const getTimescaleAndDuration: (trakBox: TrakBox) => TimescaleAndDuration | null;
 export declare const getFps: (segments: AnySegment[]) => number | null;
 export declare const hasFps: (boxes: AnySegment[]) => boolean;
 export {};