@remotion/media-parser 4.0.191 → 4.0.193

package/dist/buffer-iterator.js

@@ -54,8 +54,12 @@ const matchesPattern = (pattern) => {
 const makeOffsetCounter = () => {
     return new OffsetCounter(0);
 };
-const getArrayBufferIterator = (initialData) => {
-    let data = initialData;
+const getArrayBufferIterator = (initialData, maxBytes) => {
+    const buf = new ArrayBuffer(initialData.byteLength, {
+        maxByteLength: maxBytes !== null && maxBytes !== void 0 ? maxBytes : 1000000000,
+    });
+    let data = new Uint8Array(buf);
+    data.set(initialData);
     let view = new DataView(data.buffer);
     const counter = makeOffsetCounter();
     const getSlice = (amount) => {
@@ -71,15 +75,24 @@ const getArrayBufferIterator = (initialData) => {
     const getFourByteNumber = () => {
         return ((getUint8() << 24) | (getUint8() << 16) | (getUint8() << 8) | getUint8());
     };
+    const getPaddedFourByteNumber = () => {
+        let lastInt = 128;
+        while (((lastInt = getUint8()), lastInt === 128)) {
+            // Do nothing
+        }
+        return lastInt;
+    };
     const getUint32 = () => {
         const val = view.getUint32(counter.getDiscardedOffset());
         counter.increment(4);
         return val;
     };
     const addData = (newData) => {
-        const newArray = new Uint8Array(data.buffer.byteLength + newData.byteLength);
-        newArray.set(data);
-        newArray.set(new Uint8Array(newData), data.byteLength);
+        const oldLength = buf.byteLength;
+        const newLength = oldLength + newData.byteLength;
+        buf.resize(newLength);
+        const newArray = new Uint8Array(buf);
+        newArray.set(newData, oldLength);
         data = newArray;
         view = new DataView(data.buffer);
     };
@@ -98,9 +111,9 @@ const getArrayBufferIterator = (initialData) => {
     const removeBytesRead = () => {
         const bytesToRemove = counter.getDiscardedOffset();
         counter.discardBytes(bytesToRemove);
-        const newArray = new Uint8Array(data.buffer.byteLength - bytesToRemove);
-        newArray.set(data.slice(bytesToRemove));
-        data = newArray;
+        const newData = data.slice(bytesToRemove);
+        data.set(newData);
+        buf.resize(newData.byteLength);
         view = new DataView(data.buffer);
     };
     return {
@@ -120,6 +133,7 @@ const getArrayBufferIterator = (initialData) => {
             const atom = getSlice(4);
             return new TextDecoder().decode(atom);
         },
+        getPaddedFourByteNumber,
         getMatroskaSegmentId: () => {
             const first = getSlice(1);
             const firstOneString = `0x${Array.from(new Uint8Array(first))
@@ -139,6 +153,10 @@ const getArrayBufferIterator = (initialData) => {
                 '0xe0',
                 '0xb0',
                 '0xba',
+                '0x9a',
+                '0xe1',
+                '0xbf',
+                '0x88',
             ];
             if (knownIdsWithOneLength.includes(firstOneString)) {
                 return firstOneString;
@@ -155,6 +173,9 @@ const getArrayBufferIterator = (initialData) => {
                 '0x4489',
                 '0x55ee',
                 '0x55b0',
+                '0x7ba9',
+                '0x63a2',
+                '0x73a4',
             ];
             const firstTwoString = `${firstOneString}${Array.from(new Uint8Array(firstTwo))
                 .map((b) => {

package/dist/from-node.js

@@ -5,12 +5,16 @@ const fs_1 = require("fs");
 const promises_1 = require("node:fs/promises");
 const stream_1 = require("stream");
 exports.nodeReader = {
-    read: (src, range) => {
+    read: async (src, range) => {
         const stream = (0, fs_1.createReadStream)(src, {
             start: range === null ? 0 : range[0],
             end: range === null ? Infinity : range[1],
         });
-        return Promise.resolve(stream_1.Readable.toWeb(stream).getReader());
+        const stats = await (0, promises_1.stat)(src);
+        return {
+            reader: stream_1.Readable.toWeb(stream).getReader(),
+            contentLength: stats.size,
+        };
     },
     getLength: async (src) => {
         const stats = await (0, promises_1.stat)(src);

package/dist/from-web.js

@@ -21,8 +21,13 @@ exports.webReader = {
         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;
+        return { reader, contentLength };
     },
     getLength: async (src) => {
         const res = await fetch(src, {

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

@@ -0,0 +1,4 @@
+import type { KnownAudioCodecs } from './options';
+import type { AnySegment } from './parse-result';
+export declare const hasAudioCodec: (boxes: AnySegment[]) => boolean;
+export declare const getAudioCodec: (boxes: AnySegment[]) => KnownAudioCodecs | null;

package/dist/get-audio-codec.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAudioCodec = exports.hasAudioCodec = void 0;
+const get_fps_1 = require("./get-fps");
+const hasAudioCodec = (boxes) => {
+    try {
+        return (0, exports.getAudioCodec)(boxes) !== null;
+    }
+    catch (e) {
+        return false;
+    }
+};
+exports.hasAudioCodec = hasAudioCodec;
+const onEsdsBox = (child) => {
+    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;
+        }
+    }
+    return null;
+};
+const onSample = (sample) => {
+    if (!sample) {
+        return null;
+    }
+    if (sample.type !== 'audio') {
+        return null;
+    }
+    if (sample.format === 'sowt') {
+        return 'aiff';
+    }
+    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 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;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    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 === 'A_OPUS') {
+                    return 'opus';
+                }
+                if (trackType.codec === 'A_PCM/INT/LIT') {
+                    return 'pcm';
+                }
+            }
+        }
+    }
+    return null;
+};
+exports.getAudioCodec = getAudioCodec;

package/dist/get-dimensions.js

@@ -6,8 +6,12 @@ const getDimensionsFromMatroska = (segments) => {
     if (!tracksSegment || tracksSegment.type !== 'tracks-segment') {
         throw new Error('No tracks segment');
     }
-    // TODO: What if there are multiple video tracks, or audio track is first?
-    const trackEntrySegment = tracksSegment.children.find((b) => b.type === 'track-entry-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');
     }

package/dist/get-fps.d.ts

@@ -1,3 +1,11 @@
 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 getFps: (segments: AnySegment[]) => number | null;
 export declare const hasFps: (boxes: AnySegment[]) => boolean;
+export {};

package/dist/get-fps.js

@@ -1,16 +1,122 @@
 "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 = exports.trakBoxContainsAudio = 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 trakBoxContainsAudio = (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 === 'audio');
+    if (!videoSample || videoSample.type !== 'audio') {
+        return false;
+    }
+    return true;
+};
+exports.trakBoxContainsAudio = trakBoxContainsAudio;
+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 +125,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 +160,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,79 @@
+"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';
+                }
+                if (trackType.codec === 'V_MPEG4/ISO/AVC') {
+                    return 'h264';
+                }
+            }
+        }
+    }
+    return null;
+};
+exports.getVideoCodec = getVideoCodec;

package/dist/get-video-metadata.d.ts

@@ -0,0 +1,2 @@
+import type { ParseMedia } from './options';
+export declare const parseMedia: ParseMedia;

package/dist/get-video-metadata.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMedia = void 0;
+const buffer_iterator_1 = require("./buffer-iterator");
+const from_web_1 = require("./from-web");
+const get_dimensions_1 = require("./get-dimensions");
+const get_duration_1 = require("./get-duration");
+const get_fps_1 = require("./get-fps");
+const has_all_info_1 = require("./has-all-info");
+const parse_video_1 = require("./parse-video");
+const parseMedia = async (src, options, readerInterface = from_web_1.webReader) => {
+    const reader = await readerInterface.read(src, null);
+    const returnValue = {};
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]));
+    let parseResult = (0, parse_video_1.parseVideo)(iterator);
+    while (parseResult.status === 'incomplete') {
+        const result = await reader.read();
+        if (result.done) {
+            break;
+        }
+        iterator.addData(result.value);
+        parseResult = parseResult.continueParsing();
+        if ((0, has_all_info_1.hasAllInfo)(options, parseResult)) {
+            if (!reader.closed) {
+                reader.cancel(new Error('has all information'));
+            }
+            break;
+        }
+    }
+    if (options.dimensions) {
+        returnValue.dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments);
+    }
+    if (options.durationInSeconds) {
+        returnValue.durationInSeconds = (0, get_duration_1.getDuration)(parseResult.segments);
+    }
+    if (options.fps) {
+        returnValue.fps = (0, get_fps_1.getFps)(parseResult.segments);
+    }
+    if (options.boxes) {
+        returnValue.boxes = parseResult.segments;
+    }
+    return returnValue;
+};
+exports.parseMedia = parseMedia;

package/dist/has-all-info.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, boolean>, parseResult: ParseResult) => boolean;

package/dist/has-all-info.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasAllInfo = void 0;
+const get_audio_codec_1 = require("./get-audio-codec");
 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 +23,12 @@ 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;
+        }
+        if (key === 'audioCodec') {
+            return (0, get_audio_codec_1.hasAudioCodec)(parseResult.segments) !== null;
+        }
         throw new Error(`Unknown key: ${key}`);
     });
 };

package/dist/options.d.ts

@@ -1,13 +1,17 @@
 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 KnownAudioCodecs = 'aac' | 'mp3' | 'aiff' | 'opus' | 'pcm' | 'unknown';
+export type Options<EnableDimensions extends boolean, EnableDuration extends boolean, EnableBoxes extends boolean, EnableFps extends boolean, EnableVideoCodec extends boolean, EnableAudioCodec extends boolean> = {
     dimensions?: EnableDimensions;
     durationInSeconds?: EnableDuration;
     boxes?: EnableBoxes;
     fps?: EnableFps;
+    videoCodec?: EnableVideoCodec;
+    audioCodec?: EnableAudioCodec;
 };
-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, EnableAudioCodec extends boolean> = (EnableDimensions extends true ? {
     dimensions: Dimensions;
 } : {}) & (EnableDuration extends true ? {
     durationInSeconds: number | null;
@@ -15,5 +19,9 @@ export type Metadata<EnableDimensions extends boolean, EnableDuration extends bo
     boxes: AnySegment[];
 } : {}) & (EnableFps extends true ? {
     fps: number | null;
+} : {}) & (EnableVideoCodec extends true ? {
+    videoCodec: KnownVideoCodecs | null;
+} : {}) & (EnableAudioCodec extends true ? {
+    audioCodec: KnownAudioCodecs | 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, EnableAudioCodec extends boolean>(src: string, options: Options<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec, EnableAudioCodec>, readerInterface?: ReaderInterface) => Promise<Metadata<EnableDimensions, EnableDuration, EnableBoxes, EnableFps, EnableVideoCodec, EnableAudioCodec>>;