@remotion/media-parser 4.0.304 → 4.0.306

package/dist/containers/riff/parse-movi.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMovi = exports.handleChunk = void 0;
-const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
+const webcodecs_timescale_1 = require("../../webcodecs-timescale");
 const key_1 = require("../avc/key");
 const parse_avc_1 = require("../avc/parse-avc");
 const convert_queued_sample_to_mediaparser_sample_1 = require("./convert-queued-sample-to-mediaparser-sample");
@@ -31,10 +31,8 @@ const handleChunk = async ({ state, ckId, ckSize, }) => {
             // this sample would be longer. Chrome will pad it with silence.
             // If we'd pass a duration instead, it would shift the audio and we think that audio is not finished
             duration: 1 / samplesPerSecond,
-            trackId,
             type: keyOrDelta === 'bidirectional' ? 'delta' : keyOrDelta,
             offset,
-            timescale: samplesPerSecond,
             avc: info,
         };
         const maxFramesInBuffer = state.avc.getMaxFramesInBuffer();
@@ -51,14 +49,29 @@ const handleChunk = async ({ state, ckId, ckSize, }) => {
                 poc: info.poc,
             });
         }
-        state.riff.queuedBFrames.addFrame(rawSample, maxFramesInBuffer);
+        state.riff.queuedBFrames.addFrame({
+            frame: rawSample,
+            trackId,
+            maxFramesInBuffer,
+            timescale: samplesPerSecond,
+        });
         const releasedFrame = state.riff.queuedBFrames.getReleasedFrame();
         if (!releasedFrame) {
             return;
         }
-        const videoSample = (0, convert_queued_sample_to_mediaparser_sample_1.convertQueuedSampleToMediaParserSample)(releasedFrame, state);
-        state.riff.sampleCounter.onVideoSample(videoSample);
-        await state.callbacks.onVideoSample(trackId, videoSample);
+        const videoSample = (0, convert_queued_sample_to_mediaparser_sample_1.convertQueuedSampleToMediaParserSample)({
+            sample: releasedFrame.sample,
+            state,
+            trackId: releasedFrame.trackId,
+        });
+        state.riff.sampleCounter.onVideoSample({
+            trackId,
+            videoSample,
+        });
+        await state.callbacks.onVideoSample({
+            videoSample,
+            trackId,
+        });
     }
     const audioChunk = ckId.match(/^([0-9]{2})wb$/);
     if (audioChunk) {
@@ -73,28 +86,25 @@ const handleChunk = async ({ state, ckId, ckSize, }) => {
             trackId,
         });
         const timeInSec = nthSample / samplesPerSecond;
-        const timestamp = timeInSec;
+        const timestamp = Math.floor(timeInSec * webcodecs_timescale_1.WEBCODECS_TIMESCALE);
         const data = iterator.getSlice(ckSize);
-        const audioSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
-            sample: {
-                cts: timestamp,
-                dts: timestamp,
-                data, // We must also NOT pass a duration because if the the next sample is 0,
-                // this sample would be longer. Chrome will pad it with silence.
-                // If we'd pass a duration instead, it would shift the audio and we think that audio is not finished
-                duration: undefined,
-                timestamp,
-                trackId,
-                type: 'key',
-                offset,
-                timescale: samplesPerSecond,
-            },
-            timescale: 1,
-        });
+        const audioSample = {
+            decodingTimestamp: timestamp,
+            data, // We must also NOT pass a duration because if the the next sample is 0,
+            // this sample would be longer. Chrome will pad it with silence.
+            // If we'd pass a duration instead, it would shift the audio and we think that audio is not finished
+            duration: undefined,
+            timestamp,
+            type: 'key',
+            offset,
+        };
         state.riff.sampleCounter.onAudioSample(trackId, audioSample);
         // In example.avi, we have samples with 0 data
         // Chrome fails on these
-        await state.callbacks.onAudioSample(trackId, audioSample);
+        await state.callbacks.onAudioSample({
+            audioSample,
+            trackId,
+        });
     }
 };
 exports.handleChunk = handleChunk;

package/dist/containers/riff/parse-riff-body.js

@@ -10,9 +10,19 @@ const parse_video_section_1 = require("./parse-video-section");
 const parseRiffBody = async (state) => {
     const releasedFrame = state.riff.queuedBFrames.getReleasedFrame();
     if (releasedFrame) {
-        const converted = (0, convert_queued_sample_to_mediaparser_sample_1.convertQueuedSampleToMediaParserSample)(releasedFrame, state);
-        state.riff.sampleCounter.onVideoSample(converted);
-        await state.callbacks.onVideoSample(releasedFrame.trackId, converted);
+        const converted = (0, convert_queued_sample_to_mediaparser_sample_1.convertQueuedSampleToMediaParserSample)({
+            sample: releasedFrame.sample,
+            state,
+            trackId: releasedFrame.trackId,
+        });
+        state.riff.sampleCounter.onVideoSample({
+            trackId: releasedFrame.trackId,
+            videoSample: converted,
+        });
+        await state.callbacks.onVideoSample({
+            videoSample: converted,
+            trackId: releasedFrame.trackId,
+        });
         return null;
     }
     if (state.mediaSection.isCurrentByteInMediaSection(state.iterator) ===

package/dist/containers/riff/seek/fetch-idx1.d.ts

@@ -3,13 +3,14 @@ import type { PrefetchCache } from '../../../fetch';
 import { type MediaParserLogLevel } from '../../../log';
 import type { ParseMediaSrc } from '../../../options';
 import type { MediaParserReaderInterface } from '../../../readers/reader';
-export declare const fetchIdx1: ({ src, readerInterface, controller, position, logLevel, prefetchCache, }: {
+export declare const fetchIdx1: ({ src, readerInterface, controller, position, logLevel, prefetchCache, contentLength, }: {
     src: ParseMediaSrc;
     readerInterface: MediaParserReaderInterface;
     controller: MediaParserController;
     position: number;
     logLevel: MediaParserLogLevel;
     prefetchCache: PrefetchCache;
+    contentLength: number;
 }) => Promise<{
     entries: import("../riff-box").Idx1Entry[];
     videoTrackIndex: number | null;

package/dist/containers/riff/seek/fetch-idx1.js

@@ -4,7 +4,7 @@ exports.fetchIdx1 = void 0;
 const buffer_iterator_1 = require("../../../iterator/buffer-iterator");
 const log_1 = require("../../../log");
 const expect_riff_box_1 = require("../expect-riff-box");
-const fetchIdx1 = async ({ src, readerInterface, controller, position, logLevel, prefetchCache, }) => {
+const fetchIdx1 = async ({ src, readerInterface, controller, position, logLevel, prefetchCache, contentLength, }) => {
     log_1.Log.verbose(logLevel, 'Making request to fetch idx1 from ', src, 'position', position);
     const result = await readerInterface.read({
         controller,
@@ -13,7 +13,10 @@ const fetchIdx1 = async ({ src, readerInterface, controller, position, logLevel,
         logLevel,
         prefetchCache,
     });
-    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array(), Infinity);
+    if (result.contentLength === null) {
+        throw new Error('Content length is null');
+    }
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array(), contentLength - position + 1);
     while (true) {
         const res = await result.reader.reader.read();
         if (res.value) {

package/dist/containers/transport-stream/handle-aac-packet.js

@@ -4,6 +4,7 @@ exports.handleAacPacket = void 0;
 const aac_codecprivate_1 = require("../../aac-codecprivate");
 const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
 const register_track_1 = require("../../register-track");
+const webcodecs_timescale_1 = require("../../webcodecs-timescale");
 const adts_header_1 = require("./adts-header");
 const handle_avc_packet_1 = require("./handle-avc-packet");
 const handleAacPacket = async ({ streamBuffer, programId, offset, sampleCallbacks, logLevel, onAudioTrack, transportStream, makeSamplesStartAtZero, }) => {
@@ -28,7 +29,7 @@ const handleAacPacket = async ({ streamBuffer, programId, offset, sampleCallback
             type: 'audio',
             codecData: { type: 'aac-config', data: codecPrivate },
             trackId: programId,
-            timescale: handle_avc_packet_1.MPEG_TIMESCALE,
+            originalTimescale: handle_avc_packet_1.MPEG_TIMESCALE,
             codecEnum: 'aac',
             codec: (0, aac_codecprivate_1.mapAudioObjectTypeToCodecString)(audioObjectType),
             // https://www.w3.org/TR/webcodecs-aac-codec-registration/
@@ -38,6 +39,7 @@ const handleAacPacket = async ({ streamBuffer, programId, offset, sampleCallback
             numberOfChannels: channelConfiguration,
             sampleRate,
             startInSeconds: 0,
+            timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
         };
         await (0, register_track_1.registerAudioTrack)({
             track,
@@ -49,24 +51,23 @@ const handleAacPacket = async ({ streamBuffer, programId, offset, sampleCallback
         });
     }
     const sample = {
-        cts: streamBuffer.pesHeader.pts -
-            transportStream.startOffset.getOffset(programId),
-        dts: ((_b = streamBuffer.pesHeader.dts) !== null && _b !== void 0 ? _b : streamBuffer.pesHeader.pts) -
+        decodingTimestamp: ((_b = streamBuffer.pesHeader.dts) !== null && _b !== void 0 ? _b : streamBuffer.pesHeader.pts) -
             transportStream.startOffset.getOffset(programId),
         timestamp: streamBuffer.pesHeader.pts -
             transportStream.startOffset.getOffset(programId),
         duration: undefined,
         data: streamBuffer.getBuffer(),
-        trackId: programId,
         type: 'key',
         offset,
-        timescale: handle_avc_packet_1.MPEG_TIMESCALE,
     };
     const audioSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
         sample,
         timescale: handle_avc_packet_1.MPEG_TIMESCALE,
     });
-    await sampleCallbacks.onAudioSample(programId, audioSample);
+    await sampleCallbacks.onAudioSample({
+        audioSample,
+        trackId: programId,
+    });
     transportStream.lastEmittedSample.setLastEmittedSample(sample);
 };
 exports.handleAacPacket = handleAacPacket;

package/dist/containers/transport-stream/handle-avc-packet.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleAvcPacket = exports.MPEG_TIMESCALE = void 0;
 const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
 const register_track_1 = require("../../register-track");
+const webcodecs_timescale_1 = require("../../webcodecs-timescale");
 const codec_string_1 = require("../avc/codec-string");
 const create_sps_pps_data_1 = require("../avc/create-sps-pps-data");
 const interpret_sps_1 = require("../avc/interpret-sps");
@@ -35,7 +36,7 @@ const handleAvcPacket = async ({ streamBuffer, programId, offset, sampleCallback
             rotation: 0,
             trackId: programId,
             type: 'video',
-            timescale: exports.MPEG_TIMESCALE,
+            originalTimescale: exports.MPEG_TIMESCALE,
             codec: (0, codec_string_1.getCodecStringFromSpsAndPps)(spsAndPps.sps),
             codecData: { type: 'avc-sps-pps', data: codecPrivate },
             fps: null,
@@ -57,6 +58,7 @@ const handleAvcPacket = async ({ streamBuffer, programId, offset, sampleCallback
             colorSpace: (0, color_to_webcodecs_colors_1.mediaParserAdvancedColorToWebCodecsColor)(advancedColor),
             advancedColor,
             startInSeconds: 0,
+            timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
         };
         await (0, register_track_1.registerVideoTrack)({
             track,
@@ -70,18 +72,14 @@ const handleAvcPacket = async ({ streamBuffer, programId, offset, sampleCallback
     const type = (0, key_1.getKeyFrameOrDeltaFromAvcInfo)(avc);
     // sample for webcodecs needs to be in nano seconds
     const sample = {
-        cts: streamBuffer.pesHeader.pts -
-            transportStream.startOffset.getOffset(programId),
-        dts: ((_b = streamBuffer.pesHeader.dts) !== null && _b !== void 0 ? _b : streamBuffer.pesHeader.pts) -
+        decodingTimestamp: ((_b = streamBuffer.pesHeader.dts) !== null && _b !== void 0 ? _b : streamBuffer.pesHeader.pts) -
             transportStream.startOffset.getOffset(programId),
         timestamp: streamBuffer.pesHeader.pts -
             transportStream.startOffset.getOffset(programId),
         duration: undefined,
         data: streamBuffer.getBuffer(),
-        trackId: programId,
         type: type === 'bidirectional' ? 'delta' : type,
         offset,
-        timescale: exports.MPEG_TIMESCALE,
     };
     if (type === 'key') {
         transportStream.observedPesHeaders.markPtsAsKeyframe(streamBuffer.pesHeader.pts);
@@ -90,7 +88,10 @@ const handleAvcPacket = async ({ streamBuffer, programId, offset, sampleCallback
         sample,
         timescale: exports.MPEG_TIMESCALE,
     });
-    await sampleCallbacks.onVideoSample(programId, videoSample);
+    await sampleCallbacks.onVideoSample({
+        videoSample,
+        trackId: programId,
+    });
     transportStream.lastEmittedSample.setLastEmittedSample(sample);
 };
 exports.handleAvcPacket = handleAvcPacket;

package/dist/containers/wav/parse-fmt.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFmt = void 0;
 const register_track_1 = require("../../register-track");
+const webcodecs_timescale_1 = require("../../webcodecs-timescale");
 const parseFmt = async ({ state, }) => {
     const { iterator } = state;
     const ckSize = iterator.getUint32Le(); // chunkSize
@@ -43,9 +44,10 @@ const parseFmt = async ({ state, }) => {
             codecEnum: format,
             numberOfChannels,
             sampleRate,
-            timescale: 1000000,
+            originalTimescale: 1000000,
             trackId: 0,
             startInSeconds: 0,
+            timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
         },
         container: 'wav',
         registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,

package/dist/containers/wav/parse-media-section.js

@@ -20,19 +20,19 @@ const parseMediaSection = async ({ state, }) => {
     const data = iterator.getSlice(toRead);
     const audioSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
         sample: {
-            cts: timestamp,
-            dts: timestamp,
+            decodingTimestamp: timestamp,
             data,
             duration,
             timestamp,
-            trackId: 0,
             type: 'key',
             offset,
-            timescale: 1000000,
         },
         timescale: 1,
     });
-    await state.callbacks.onAudioSample(0, audioSample);
+    await state.callbacks.onAudioSample({
+        audioSample,
+        trackId: 0,
+    });
     return null;
 };
 exports.parseMediaSection = parseMediaSection;

package/dist/containers/webm/get-sample-from-block.d.ts

@@ -8,12 +8,18 @@ import type { BlockSegment, SimpleBlockSegment } from './segments/all-segments';
 type SampleResult = {
     type: 'video-sample';
     videoSample: MediaParserVideoSample;
+    trackId: number;
+    timescale: number;
 } | {
     type: 'audio-sample';
     audioSample: MediaParserAudioSample;
+    trackId: number;
+    timescale: number;
 } | {
     type: 'partial-video-sample';
     partialVideoSample: Omit<MediaParserVideoSample, 'type'>;
+    trackId: number;
+    timescale: number;
 } | {
     type: 'no-sample';
 };

package/dist/containers/webm/get-sample-from-block.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSampleFromBlock = void 0;
 const buffer_iterator_1 = require("../../iterator/buffer-iterator");
 const register_track_1 = require("../../register-track");
+const webcodecs_timescale_1 = require("../../webcodecs-timescale");
 const parse_avc_1 = require("../avc/parse-avc");
 const get_ready_tracks_1 = require("./get-ready-tracks");
 const all_segments_1 = require("./segments/all-segments");
@@ -75,19 +76,18 @@ const getSampleFromBlock = async ({ ebml, webmState, offset, structureState, cal
     if (codec.startsWith('V_')) {
         const partialVideoSample = {
             data: iterator.getSlice(remainingNow),
-            cts: timecodeInMicroseconds,
-            dts: timecodeInMicroseconds,
+            decodingTimestamp: timecodeInMicroseconds,
             duration: undefined,
-            trackId: trackNumber,
             timestamp: timecodeInMicroseconds,
             offset,
-            timescale,
         };
         if (keyframe === null) {
             iterator.destroy();
             return {
                 type: 'partial-video-sample',
                 partialVideoSample,
+                trackId: trackNumber,
+                timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
             };
         }
         await addAvcToTrackAndActivateTrackIfNecessary({
@@ -109,24 +109,25 @@ const getSampleFromBlock = async ({ ebml, webmState, offset, structureState, cal
         return {
             type: 'video-sample',
             videoSample: sample,
+            trackId: trackNumber,
+            timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
         };
     }
     if (codec.startsWith('A_')) {
         const audioSample = {
             data: iterator.getSlice(remainingNow),
-            trackId: trackNumber,
             timestamp: timecodeInMicroseconds,
             type: 'key',
             duration: undefined,
-            cts: timecodeInMicroseconds,
-            dts: timecodeInMicroseconds,
+            decodingTimestamp: timecodeInMicroseconds,
             offset,
-            timescale,
         };
         iterator.destroy();
         return {
             type: 'audio-sample',
             audioSample,
+            trackId: trackNumber,
+            timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
         };
     }
     iterator.destroy();

package/dist/containers/webm/make-track.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTrack = exports.getMatroskaAudioCodecEnum = exports.NO_CODEC_PRIVATE_SHOULD_BE_DERIVED_FROM_SPS = void 0;
 const buffer_iterator_1 = require("../../iterator/buffer-iterator");
 const make_hvc1_codec_strings_1 = require("../../make-hvc1-codec-strings");
+const webcodecs_timescale_1 = require("../../webcodecs-timescale");
 const color_to_webcodecs_colors_1 = require("../iso-base-media/color-to-webcodecs-colors");
 const av1_codec_private_1 = require("./av1-codec-private");
 const color_1 = require("./color");
@@ -247,7 +248,7 @@ const getTrack = ({ timescale, track, }) => {
                 numerator: 1,
                 denominator: 1,
             },
-            timescale,
+            originalTimescale: timescale,
             codedHeight: height.value.value,
             codedWidth: width.value.value,
             displayAspectHeight: displayHeight
@@ -263,6 +264,7 @@ const getTrack = ({ timescale, track, }) => {
             codecEnum,
             fps: null,
             startInSeconds: 0,
+            timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
         };
     }
     if ((0, track_entry_1.trackTypeToString)(trackType.value.value) === 'audio') {
@@ -277,7 +279,7 @@ const getTrack = ({ timescale, track, }) => {
             type: 'audio',
             trackId,
             codec: codecString,
-            timescale,
+            originalTimescale: timescale,
             numberOfChannels,
             sampleRate,
             description: (0, description_1.getAudioDescription)(track),
@@ -290,6 +292,7 @@ const getTrack = ({ timescale, track, }) => {
                 track,
             }),
             startInSeconds: 0,
+            timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
         };
     }
     return null;

package/dist/containers/webm/parse-ebml.js

@@ -158,7 +158,10 @@ const postprocessEbml = async ({ offset, ebml, statesForProcessing: { webmState,
             avcState,
         });
         if (sample.type === 'video-sample') {
-            await callbacks.onVideoSample(sample.videoSample.trackId, sample.videoSample);
+            await callbacks.onVideoSample({
+                videoSample: sample.videoSample,
+                trackId: sample.trackId,
+            });
             return {
                 type: 'Block',
                 value: new Uint8Array([]),
@@ -166,7 +169,10 @@ const postprocessEbml = async ({ offset, ebml, statesForProcessing: { webmState,
             };
         }
         if (sample.type === 'audio-sample') {
-            await callbacks.onAudioSample(sample.audioSample.trackId, sample.audioSample);
+            await callbacks.onAudioSample({
+                audioSample: sample.audioSample,
+                trackId: sample.trackId,
+            });
             return {
                 type: 'Block',
                 value: new Uint8Array([]),
@@ -208,7 +214,10 @@ const postprocessEbml = async ({ offset, ebml, statesForProcessing: { webmState,
                 ...sample.partialVideoSample,
                 type: hasReferenceBlock ? 'delta' : 'key',
             };
-            await callbacks.onVideoSample(sample.partialVideoSample.trackId, completeFrame);
+            await callbacks.onVideoSample({
+                videoSample: completeFrame,
+                trackId: sample.trackId,
+            });
         }
         return {
             type: 'BlockGroup',

package/dist/containers/webm/seek/seeking-hints.js

@@ -10,7 +10,7 @@ const getSeekingHintsFromMatroska = (tracksState, keyframesState, webmState) =>
         type: 'webm-seeking-hints',
         track: firstVideoTrack
             ? {
-                timescale: firstVideoTrack.timescale,
+                timescale: firstVideoTrack.originalTimescale,
                 trackId: firstVideoTrack.trackId,
             }
             : null,

package/dist/convert-audio-or-video-sample.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertAudioOrVideoSampleToWebCodecsTimestamps = void 0;
-const TARGET_TIMESCALE = 1000000;
+const webcodecs_timescale_1 = require("./webcodecs-timescale");
 const fixFloat = (value) => {
     if (value % 1 < 0.0000001) {
         return Math.floor(value);
@@ -12,22 +12,19 @@ const fixFloat = (value) => {
     return value;
 };
 const convertAudioOrVideoSampleToWebCodecsTimestamps = ({ sample, timescale, }) => {
-    if (timescale === TARGET_TIMESCALE) {
+    if (timescale === webcodecs_timescale_1.WEBCODECS_TIMESCALE) {
         return sample;
     }
-    const { cts, dts, timestamp } = sample;
+    const { decodingTimestamp: dts, timestamp } = sample;
     return {
-        cts: fixFloat(cts * (TARGET_TIMESCALE / timescale)),
-        dts: fixFloat(dts * (TARGET_TIMESCALE / timescale)),
-        timestamp: fixFloat(timestamp * (TARGET_TIMESCALE / timescale)),
+        decodingTimestamp: fixFloat(dts * (webcodecs_timescale_1.WEBCODECS_TIMESCALE / timescale)),
+        timestamp: fixFloat(timestamp * (webcodecs_timescale_1.WEBCODECS_TIMESCALE / timescale)),
         duration: sample.duration === undefined
             ? undefined
-            : fixFloat(sample.duration * (TARGET_TIMESCALE / timescale)),
+            : fixFloat(sample.duration * (webcodecs_timescale_1.WEBCODECS_TIMESCALE / timescale)),
         data: sample.data,
-        trackId: sample.trackId,
         type: sample.type,
         offset: sample.offset,
-        timescale: TARGET_TIMESCALE,
         ...('avc' in sample ? { avc: sample.avc } : {}),
     };
 };

package/dist/download-and-parse-media.js

@@ -7,6 +7,9 @@ const log_1 = require("./log");
 const web_1 = require("./web");
 const downloadAndParseMedia = async (options) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16;
+    if (!options) {
+        return Promise.reject(new Error('No options provided. See https://www.remotion.dev/media-parser for how to get started.'));
+    }
     const logLevel = (_a = options.logLevel) !== null && _a !== void 0 ? _a : 'info';
     const content = await options.writer.createContent({
         filename: 'hmm',