@remotion/media-parser 4.0.191 → 4.0.192

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

@@ -0,0 +1,14 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export interface MdhdBox {
+    type: 'mdhd-box';
+    version: number;
+    timescale: number;
+    duration: number;
+    language: number;
+    quality: number;
+}
+export declare const parseMdhd: ({ data, size, fileOffset, }: {
+    data: BufferIterator;
+    size: number;
+    fileOffset: number;
+}) => MdhdBox;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMdhd = void 0;
+const parseMdhd = ({ data, size, fileOffset, }) => {
+    const version = data.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported MDHD version ${version}`);
+    }
+    // flags, we discard them
+    data.discard(3);
+    // creation time
+    data.discard(4);
+    // modification time
+    data.discard(4);
+    const timescale = data.getUint32();
+    const duration = data.getUint32();
+    const language = data.getUint16();
+    // quality
+    const quality = data.getUint16();
+    const remaining = size - (data.counter.getOffset() - fileOffset);
+    if (remaining !== 0) {
+        throw new Error(`Expected remaining bytes to be 0, got ${remaining}`);
+    }
+    return {
+        type: 'mdhd-box',
+        duration,
+        timescale,
+        version,
+        language,
+        quality,
+    };
+};
+exports.parseMdhd = parseMdhd;

package/dist/boxes/iso-base-media/process-box.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseBoxes = void 0;
 const ftyp_1 = require("./ftyp");
+const mdhd_1 = require("./mdhd");
 const moov_1 = require("./moov/moov");
 const mvhd_1 = require("./mvhd");
 const mebx_1 = require("./stsd/mebx");
@@ -119,6 +120,18 @@ const processBox = ({ iterator, allowIncompleteBoxes, }) => {
             size: boxSize,
         };
     }
+    if (boxType === 'mdhd') {
+        const box = (0, mdhd_1.parseMdhd)({
+            data: iterator,
+            size: boxSize,
+            fileOffset,
+        });
+        return {
+            type: 'complete',
+            box,
+            size: boxSize,
+        };
+    }
     const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
     const children = getChildren({
         boxType,

package/dist/boxes/iso-base-media/stsd/samples.js

@@ -30,6 +30,7 @@ const videoTags = [
     'v410',
     'v210',
     'hvc1',
+    'ap4h',
 ];
 // https://developer.apple.com/documentation/quicktime-file-format/sound_sample_descriptions
 const audioTags = [

package/dist/boxes/webm/parse-webm-header.js

@@ -5,7 +5,7 @@ const segments_1 = require("./segments");
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
 const parseWebm = (counter) => {
     counter.discard(4);
-    const length = counter.getEBML();
+    const length = counter.getVint();
     if (length !== 31) {
         throw new Error(`Expected header length 31, got ${length}`);
     }

package/dist/boxes/webm/segments/track-entry.d.ts

@@ -69,3 +69,13 @@ export type ColorSegment = {
     type: 'color-segment';
 };
 export declare const parseColorSegment: (iterator: BufferIterator) => ColorSegment;
+export type TitleSegment = {
+    type: 'title-segment';
+    title: string;
+};
+export declare const parseTitleSegment: (iterator: BufferIterator) => TitleSegment;
+export type InterlacedSegment = {
+    type: 'interlaced-segment';
+    interlaced: boolean;
+};
+export declare const parseInterlacedSegment: (iterator: BufferIterator) => InterlacedSegment;

package/dist/boxes/webm/segments/track-entry.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseColorSegment = exports.parseMaxBlockAdditionId = exports.parseAlphaModeSegment = exports.parseHeightSegment = exports.parseWidthSegment = exports.parseVideoSegment = exports.parseDefaultDurationSegment = exports.parseTrackTypeSegment = exports.parseCodecSegment = exports.parseLanguageSegment = exports.parseFlagLacing = exports.parseTrackUID = exports.parseTrackNumber = exports.parseTrackEntry = void 0;
+exports.parseInterlacedSegment = exports.parseTitleSegment = exports.parseColorSegment = exports.parseMaxBlockAdditionId = exports.parseAlphaModeSegment = exports.parseHeightSegment = exports.parseWidthSegment = exports.parseVideoSegment = exports.parseDefaultDurationSegment = exports.parseTrackTypeSegment = exports.parseCodecSegment = exports.parseLanguageSegment = exports.parseFlagLacing = exports.parseTrackUID = exports.parseTrackNumber = exports.parseTrackEntry = void 0;
 const parse_children_1 = require("./parse-children");
 const parseTrackEntry = (iterator) => {
     const offset = iterator.counter.getOffset();
@@ -25,10 +25,6 @@ const parseTrackNumber = (iterator) => {
 exports.parseTrackNumber = parseTrackNumber;
 const parseTrackUID = (iterator) => {
     const length = iterator.getVint();
-    // Observation: AV1 has 8 bytes, WebM has 7
-    if (length !== 8 && length !== 7) {
-        throw new Error('Expected track number to be 8 byte');
-    }
     const bytes = iterator.getSlice(length);
     const asString = [...bytes]
         .map((b) => b.toString(16).padStart(2, '0'))
@@ -109,11 +105,10 @@ const parseDefaultDurationSegment = (iterator) => {
 };
 exports.parseDefaultDurationSegment = parseDefaultDurationSegment;
 const parseVideoSegment = (iterator) => {
-    const offset = iterator.counter.getOffset();
     const length = iterator.getVint();
     return {
         type: 'video-segment',
-        children: (0, parse_children_1.expectChildren)(iterator, length - (iterator.counter.getOffset() - offset)),
+        children: (0, parse_children_1.expectChildren)(iterator, length),
     };
 };
 exports.parseVideoSegment = parseVideoSegment;
@@ -173,3 +168,24 @@ const parseColorSegment = (iterator) => {
     };
 };
 exports.parseColorSegment = parseColorSegment;
+const parseTitleSegment = (iterator) => {
+    const length = iterator.getVint();
+    const title = iterator.getByteString(length);
+    return {
+        type: 'title-segment',
+        title,
+    };
+};
+exports.parseTitleSegment = parseTitleSegment;
+const parseInterlacedSegment = (iterator) => {
+    const length = iterator.getVint();
+    if (length !== 1) {
+        throw new Error('Expected interlaced segment to be 1 byte');
+    }
+    const interlaced = iterator.getUint8();
+    return {
+        type: 'interlaced-segment',
+        interlaced: Boolean(interlaced),
+    };
+};
+exports.parseInterlacedSegment = parseInterlacedSegment;

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

@@ -7,10 +7,10 @@ import { type SeekSegment } from './segments/seek';
 import type { SeekHeadSegment } from './segments/seek-head';
 import { type SeekPositionSegment } from './segments/seek-position';
 import type { TimestampScaleSegment } from './segments/timestamp-scale';
-import type { AlphaModeSegment, CodecSegment, ColorSegment, DefaultDurationSegment, FlagLacingSegment, HeightSegment, LanguageSegment, MaxBlockAdditionId, TrackEntrySegment, TrackNumberSegment, TrackTypeSegment, TrackUIDSegment, VideoSegment, WidthSegment } from './segments/track-entry';
+import type { AlphaModeSegment, CodecSegment, ColorSegment, DefaultDurationSegment, FlagLacingSegment, HeightSegment, InterlacedSegment, LanguageSegment, MaxBlockAdditionId, TitleSegment, TrackEntrySegment, TrackNumberSegment, TrackTypeSegment, TrackUIDSegment, VideoSegment, WidthSegment } from './segments/track-entry';
 import type { TracksSegment } from './segments/tracks';
 import type { UnknownSegment } from './segments/unknown';
 import type { VoidSegment } from './segments/void';
 import type { WritingAppSegment } from './segments/writing';
-export type MatroskaSegment = MainSegment | UnknownSegment | SeekHeadSegment | SeekSegment | SeekPositionSegment | VoidSegment | InfoSegment | TimestampScaleSegment | MuxingAppSegment | WritingAppSegment | DurationSegment | TracksSegment | TrackEntrySegment | TrackNumberSegment | TrackUIDSegment | FlagLacingSegment | LanguageSegment | CodecSegment | TrackTypeSegment | DefaultDurationSegment | VideoSegment | WidthSegment | HeightSegment | AlphaModeSegment | MaxBlockAdditionId | ColorSegment;
+export type MatroskaSegment = MainSegment | UnknownSegment | SeekHeadSegment | SeekSegment | SeekPositionSegment | VoidSegment | InfoSegment | TimestampScaleSegment | MuxingAppSegment | WritingAppSegment | DurationSegment | TracksSegment | TrackEntrySegment | TrackNumberSegment | TrackUIDSegment | FlagLacingSegment | LanguageSegment | CodecSegment | TrackTypeSegment | DefaultDurationSegment | VideoSegment | WidthSegment | HeightSegment | AlphaModeSegment | MaxBlockAdditionId | ColorSegment | TitleSegment | InterlacedSegment;
 export declare const expectSegment: (iterator: BufferIterator) => MatroskaSegment;

package/dist/boxes/webm/segments.js

@@ -94,9 +94,15 @@ const expectSegment = (iterator) => {
     if (segmentId === '0xba') {
         return (0, track_entry_1.parseHeightSegment)(iterator);
     }
+    if (segmentId === '0x9a') {
+        return (0, track_entry_1.parseInterlacedSegment)(iterator);
+    }
     if (segmentId === '0x53c0') {
         return (0, track_entry_1.parseAlphaModeSegment)(iterator);
     }
+    if (segmentId === '0x7ba9') {
+        return (0, track_entry_1.parseTitleSegment)(iterator);
+    }
     const length = iterator.getVint();
     const bytesRemaining = iterator.byteLength() - iterator.counter.getOffset();
     const toDiscard = Math.min(bytesRemaining, length > 0 ? length : bytesRemaining);

package/dist/buffer-iterator.js

@@ -139,6 +139,7 @@ const getArrayBufferIterator = (initialData) => {
                 '0xe0',
                 '0xb0',
                 '0xba',
+                '0x9a',
             ];
             if (knownIdsWithOneLength.includes(firstOneString)) {
                 return firstOneString;
@@ -155,6 +156,7 @@ const getArrayBufferIterator = (initialData) => {
                 '0x4489',
                 '0x55ee',
                 '0x55b0',
+                '0x7ba9',
             ];
             const firstTwoString = `${firstOneString}${Array.from(new Uint8Array(firstTwo))
                 .map((b) => {

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;

package/dist/get-codec.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoCodec = exports.hasVideoCodec = void 0;
+const hasVideoCodec = (boxes) => {
+    try {
+        return boxes.some((b) => b.type === 'ftyp-box');
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.hasVideoCodec = hasVideoCodec;
+const getVideoCodec = (boxes) => {
+    const ftypBox = boxes.find((b) => b.type === 'ftyp-box');
+    if (ftypBox && ftypBox.type === 'ftyp-box') {
+        if (ftypBox.compatibleBrands.find((b) => b === 'avc1')) {
+            return 'h264';
+        }
+    }
+    return null;
+};
+exports.getVideoCodec = getVideoCodec;

package/dist/get-fps.d.ts

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

package/dist/get-fps.js

@@ -1,16 +1,89 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasFps = exports.getFps = void 0;
-const calculateFps = (sttsBox, timeScale) => {
-    let sum = 0;
+exports.hasFps = exports.getFps = exports.getTimescaleAndDuration = exports.trakBoxContainsVideo = void 0;
+const calculateFps = ({ sttsBox, timeScale, durationInSamples, }) => {
     let totalSamples = 0;
     for (const sample of sttsBox.sampleDistribution) {
-        sum += sample.sampleCount * sample.sampleDelta;
         totalSamples += sample.sampleCount;
     }
-    return timeScale / (sum / totalSamples);
+    const durationInSeconds = durationInSamples / timeScale;
+    const fps = totalSamples / durationInSeconds;
+    return fps;
 };
+const trakBoxContainsVideo = (trakBox) => {
+    if (trakBox.type !== 'trak-box') {
+        return false;
+    }
+    const { children } = trakBox;
+    const mediaBoxes = children.filter((c) => c.type === 'regular-box' && c.boxType === 'mdia');
+    if (!mediaBoxes || mediaBoxes.length === 0) {
+        return false;
+    }
+    const firstMediaBox = mediaBoxes[0];
+    if (firstMediaBox.type !== 'regular-box' ||
+        firstMediaBox.boxType !== 'mdia') {
+        return false;
+    }
+    const minf = firstMediaBox.children.find((c) => c.type === 'regular-box' && c.boxType === 'minf');
+    if (!minf || minf.type !== 'regular-box' || minf.boxType !== 'minf') {
+        return false;
+    }
+    const stbl = minf.children.find((c) => c.type === 'regular-box' && c.boxType === 'stbl');
+    if (!stbl || stbl.type !== 'regular-box' || stbl.boxType !== 'stbl') {
+        return false;
+    }
+    const stsd = stbl.children.find((c) => c.type === 'stsd-box');
+    if (!stsd || stsd.type !== 'stsd-box') {
+        return false;
+    }
+    const videoSample = stsd.samples.find((s) => s.type === 'video');
+    if (!videoSample || videoSample.type !== 'video') {
+        return false;
+    }
+    return true;
+};
+exports.trakBoxContainsVideo = trakBoxContainsVideo;
+const getTimescaleAndDuration = (boxes) => {
+    const moovBox = boxes.find((s) => s.type === 'moov-box');
+    if (!moovBox || moovBox.type !== 'moov-box') {
+        return null;
+    }
+    const { children } = moovBox;
+    const trackBoxes = children.filter((c) => c.type === 'trak-box');
+    if (!trackBoxes || trackBoxes.length === 0) {
+        return null;
+    }
+    const trackBox = trackBoxes.find(exports.trakBoxContainsVideo);
+    if (!trackBox || trackBox.type !== 'trak-box') {
+        return null;
+    }
+    const trackBoxChildren = trackBox.children;
+    if (!trackBoxChildren || trackBoxChildren.length === 0) {
+        return null;
+    }
+    const mdiaBox = trackBoxChildren.find((c) => c.type === 'regular-box' && c.boxType === 'mdia');
+    if (!mdiaBox ||
+        mdiaBox.type !== 'regular-box' ||
+        mdiaBox.boxType !== 'mdia') {
+        return null;
+    }
+    const mdhdBox = mdiaBox === null || mdiaBox === void 0 ? void 0 : mdiaBox.children.find((c) => c.type === 'mdhd-box');
+    if (mdhdBox && mdhdBox.type === 'mdhd-box') {
+        return { timescale: mdhdBox.timescale, duration: mdhdBox.duration };
+    }
+    const mvhdBox = moovBox.children.find((c) => c.type === 'mvhd-box');
+    if (!mvhdBox || mvhdBox.type !== 'mvhd-box') {
+        return null;
+    }
+    const { timeScale, durationInUnits } = mvhdBox;
+    return { timescale: timeScale, duration: durationInUnits };
+};
+exports.getTimescaleAndDuration = getTimescaleAndDuration;
 const getFps = (segments) => {
+    const timescaleAndDuration = (0, exports.getTimescaleAndDuration)(segments);
+    if (!timescaleAndDuration) {
+        return null;
+    }
     const moovBox = segments.find((s) => s.type === 'moov-box');
     if (!moovBox || moovBox.type !== 'moov-box') {
         return null;
@@ -19,14 +92,12 @@ const getFps = (segments) => {
     if (!mvhdBox || mvhdBox.type !== 'mvhd-box') {
         return null;
     }
-    const { timeScale } = mvhdBox;
     const { children } = moovBox;
     const trackBoxes = children.filter((c) => c.type === 'trak-box');
     if (!trackBoxes || trackBoxes.length === 0) {
         return null;
     }
-    // TODO: What if the video track is not the first track?
-    const trackBox = trackBoxes[0];
+    const trackBox = trackBoxes.find(exports.trakBoxContainsVideo);
     if (!trackBox || trackBox.type !== 'trak-box') {
         return null;
     }
@@ -56,7 +127,11 @@ const getFps = (segments) => {
     if (!sttsBox || sttsBox.type !== 'stts-box') {
         return null;
     }
-    return calculateFps(sttsBox, timeScale);
+    return calculateFps({
+        sttsBox,
+        timeScale: timescaleAndDuration.timescale,
+        durationInSamples: timescaleAndDuration.duration,
+    });
 };
 exports.getFps = getFps;
 const hasFps = (boxes) => {

package/dist/get-video-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;

package/dist/get-video-codec.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoCodec = exports.hasVideoCodec = void 0;
+/* eslint-disable max-depth */
+const get_fps_1 = require("./get-fps");
+const hasVideoCodec = (boxes) => {
+    try {
+        return (0, exports.getVideoCodec)(boxes) !== null;
+    }
+    catch (e) {
+        return false;
+    }
+};
+exports.hasVideoCodec = hasVideoCodec;
+const getVideoCodec = (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.trakBoxContainsVideo)(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 videoSample = stsdBox.samples.find((s) => s.type === 'video');
+                            if (videoSample && videoSample.type === 'video') {
+                                if (videoSample.format === 'hvc1') {
+                                    return 'h265';
+                                }
+                                if (videoSample.format === 'avc1') {
+                                    return 'h264';
+                                }
+                                if (videoSample.format === 'ap4h') {
+                                    return 'prores';
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    const mainSegment = boxes.find((b) => b.type === 'main-segment');
+    if (!mainSegment || mainSegment.type !== 'main-segment') {
+        return null;
+    }
+    const tracksSegment = mainSegment.children.find((b) => b.type === 'tracks-segment');
+    if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
+        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 === 'V_VP8') {
+                    return 'vp8';
+                }
+                if (trackType.codec === 'V_VP9') {
+                    return 'vp9';
+                }
+                if (trackType.codec === 'V_AV1') {
+                    return 'av1';
+                }
+            }
+        }
+    }
+    return null;
+};
+exports.getVideoCodec = getVideoCodec;

package/dist/has-all-info.d.ts

@@ -1,3 +1,3 @@
 import type { Options } from './options';
 import type { ParseResult } from './parse-result';
-export declare const hasAllInfo: (options: Options<boolean, boolean, boolean, boolean>, parseResult: ParseResult) => boolean;
+export declare const hasAllInfo: (options: Options<boolean, boolean, boolean, boolean, boolean>, parseResult: ParseResult) => boolean;

package/dist/has-all-info.js

@@ -4,6 +4,7 @@ exports.hasAllInfo = void 0;
 const get_dimensions_1 = require("./get-dimensions");
 const get_duration_1 = require("./get-duration");
 const get_fps_1 = require("./get-fps");
+const get_video_codec_1 = require("./get-video-codec");
 const hasAllInfo = (options, parseResult) => {
     const keys = Object.entries(options)
         .filter(([, value]) => value)
@@ -21,6 +22,9 @@ const hasAllInfo = (options, parseResult) => {
         if (key === 'fps') {
             return (0, get_fps_1.hasFps)(parseResult.segments) !== null;
         }
+        if (key === 'videoCodec') {
+            return (0, get_video_codec_1.hasVideoCodec)(parseResult.segments) !== null;
+        }
         throw new Error(`Unknown key: ${key}`);
     });
 };

package/dist/options.d.ts

@@ -1,13 +1,15 @@
 import type { Dimensions } from './get-dimensions';
 import type { AnySegment } from './parse-result';
 import type { ReaderInterface } from './reader';
-export type Options<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean> = {
+export type KnownVideoCodecs = 'h264' | 'h265' | 'vp8' | 'vp9' | 'av1' | 'prores';
+export type Options<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean> = {
     dimensions?: EnableDimensions;
     durationInSeconds?: EnableDuration;
     boxes?: EnableBoxes;
     fps?: EnableFps;
+    videoCodec?: EnableVideoCodec;
 };
-export type Metadata<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean> = (EnableDimensions extends true ? {
+export type Metadata<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean> = (EnableDimensions extends true ? {
     dimensions: Dimensions;
 } : {}) & (EnableDuration extends true ? {
     durationInSeconds: number | null;
@@ -15,5 +17,7 @@ export type Metadata<EnableDimensions extends boolean, EnableDuration extends bo
     boxes: AnySegment[];
 } : {}) & (EnableFps extends true ? {
     fps: number | null;
+} : {}) & (EnableVideoCodec extends true ? {
+    videoCodec: KnownVideoCodecs | null;
 } : {});
-export type ParseMedia = <EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean>(src: string, options: Options<EnableDimensions, EnableDuration, EnableBoxes, EnableFps>, readerInterface?: ReaderInterface) => Promise<Metadata<EnableDimensions, EnableDuration, EnableBoxes, EnableFps>>;
+export type ParseMedia = <EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean>(src: string, options: Options<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec>, readerInterface?: ReaderInterface) => Promise<Metadata<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec>>;

package/dist/parse-media.js

@@ -6,6 +6,7 @@ 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 get_video_codec_1 = require("./get-video-codec");
 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) => {
@@ -36,6 +37,9 @@ const parseMedia = async (src, options, readerInterface = from_web_1.webReader)
     if (options.fps) {
         returnValue.fps = (0, get_fps_1.getFps)(parseResult.segments);
     }
+    if (options.videoCodec) {
+        returnValue.videoCodec = (0, get_video_codec_1.getVideoCodec)(parseResult.segments);
+    }
     if (options.boxes) {
         returnValue.boxes = parseResult.segments;
     }

package/dist/parse-result.d.ts

@@ -1,5 +1,6 @@
 import type { BaseBox } from './boxes/iso-base-media/base-type';
 import type { FtypBox } from './boxes/iso-base-media/ftyp';
+import type { MdhdBox } from './boxes/iso-base-media/mdhd';
 import type { MoovBox } from './boxes/iso-base-media/moov/moov';
 import type { MvhdBox } from './boxes/iso-base-media/mvhd';
 import type { KeysBox } from './boxes/iso-base-media/stsd/keys';
@@ -16,7 +17,7 @@ interface RegularBox extends BaseBox {
     offset: number;
     type: 'regular-box';
 }
-export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox;
+export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox;
 export type AnySegment = MatroskaSegment | IsoBaseMediaBox;
 export type ParseResult = {
     status: 'done';

package/package.json

@@ -3,11 +3,11 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.191",
+  "version": "4.0.192",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
-    "@remotion/renderer": "4.0.191"
+    "@remotion/renderer": "4.0.192"
   },
   "publishConfig": {
     "access": "public"

package/src/boxes/iso-base-media/mdhd.ts

@@ -0,0 +1,56 @@
+import type {BufferIterator} from '../../buffer-iterator';
+
+export interface MdhdBox {
+	type: 'mdhd-box';
+	version: number;
+	timescale: number;
+	duration: number;
+	language: number;
+	quality: number;
+}
+
+export const parseMdhd = ({
+	data,
+	size,
+	fileOffset,
+}: {
+	data: BufferIterator;
+	size: number;
+	fileOffset: number;
+}): MdhdBox => {
+	const version = data.getUint8();
+	if (version !== 0) {
+		throw new Error(`Unsupported MDHD version ${version}`);
+	}
+
+	// flags, we discard them
+	data.discard(3);
+
+	// creation time
+	data.discard(4);
+
+	// modification time
+	data.discard(4);
+
+	const timescale = data.getUint32();
+	const duration = data.getUint32();
+
+	const language = data.getUint16();
+
+	// quality
+	const quality = data.getUint16();
+
+	const remaining = size - (data.counter.getOffset() - fileOffset);
+	if (remaining !== 0) {
+		throw new Error(`Expected remaining bytes to be 0, got ${remaining}`);
+	}
+
+	return {
+		type: 'mdhd-box',
+		duration,
+		timescale,
+		version,
+		language,
+		quality,
+	};
+};

package/src/boxes/iso-base-media/process-box.ts

@@ -2,6 +2,7 @@ import type {BufferIterator} from '../../buffer-iterator';
 import type {IsoBaseMediaBox, ParseResult} from '../../parse-result';
 import type {BoxAndNext} from '../../parse-video';
 import {parseFtyp} from './ftyp';
+import {parseMdhd} from './mdhd';
 import {parseMoov} from './moov/moov';
 import {parseMvhd} from './mvhd';
 import {parseMebx} from './stsd/mebx';
@@ -162,6 +163,20 @@ const processBox = ({
 		};
 	}
 
+	if (boxType === 'mdhd') {
+		const box = parseMdhd({
+			data: iterator,
+			size: boxSize,
+			fileOffset,
+		});
+
+		return {
+			type: 'complete',
+			box,
+			size: boxSize,
+		};
+	}
+
 	const bytesRemainingInBox =
 		boxSize - (iterator.counter.getOffset() - fileOffset);